1
=== modified file 'NEWS'
2
--- NEWS	2010-04-20 10:30:30 +0000
3
+++ NEWS	2010-04-20 13:35:41 +0000
4
@@ -107,6 +107,10 @@
5
107
  less.)
107
  less.)
6
108
  (Martin Pool, #553017)
108
  (Martin Pool, #553017)
7
109
109
8
110
* The ``news_merge`` plugin is now smarter.  It can resolve conflicts
9
111
  involving section headings as well as bullet points.
10
112
  (Andrew Bennetts)
11
113
12
110
Documentation
114
Documentation
13
111
*************
115
*************
14
112
116
15
113
117
16
=== modified file 'bzrlib/merge3.py'
17
--- bzrlib/merge3.py	2009-03-23 14:59:43 +0000
18
+++ bzrlib/merge3.py	2010-04-20 13:35:41 +0000
19
@@ -66,10 +66,24 @@
20
66
    Given BASE, OTHER, THIS, tries to produce a combined text
66
    Given BASE, OTHER, THIS, tries to produce a combined text
21
67
    incorporating the changes from both BASE->OTHER and BASE->THIS.
67
    incorporating the changes from both BASE->OTHER and BASE->THIS.
22
68
    All three will typically be sequences of lines."""
68
    All three will typically be sequences of lines."""
27
69
    def __init__(self, base, a, b, is_cherrypick=False):
69
28
70
        check_text_lines(base)
70
    def __init__(self, base, a, b, is_cherrypick=False, allow_objects=False):
29
71
        check_text_lines(a)
71
        """Constructor.
30
72
        check_text_lines(b)
72
31
73
        :param base: lines in BASE
32
74
        :param a: lines in A
33
75
        :param b: lines in B
34
76
        :param is_cherrypick: flag indicating if this merge is a cherrypick.
35
77
            When cherrypicking b => a, matches with b and base do not conflict.
36
78
        :param allow_objects: if True, do not require that base, a and b are
37
79
            plain Python strs.  Also prevents BinaryFile from being raised.
38
80
            Lines can be any sequence of comparable and hashable Python
39
81
            objects.
40
82
        """
41
83
        if not allow_objects:
42
84
            check_text_lines(base)
43
85
            check_text_lines(a)
44
86
            check_text_lines(b)
45
73
        self.base = base
87
        self.base = base
46
74
        self.a = a
88
        self.a = a
47
75
        self.b = b
89
        self.b = b
48
76
90
49
=== modified file 'bzrlib/plugins/news_merge/__init__.py'
50
--- bzrlib/plugins/news_merge/__init__.py	2010-01-28 17:27:16 +0000
51
+++ bzrlib/plugins/news_merge/__init__.py	2010-04-20 13:35:41 +0000
52
@@ -26,10 +26,30 @@
53
26
The news_merge_files config option takes a list of file paths, separated by
26
The news_merge_files config option takes a list of file paths, separated by
54
27
commas.
27
commas.
55
28
28
56
29
The basic approach is that this plugin parses the NEWS file into a simple
57
30
series of versions, with sections of bullets in those versions.  Sections
58
31
contain a sorted set of bullets, and sections within a version also have a
59
32
fixed order (see the template at the bottom of NEWS).  The plugin merges
60
33
additions and deletions to the set of bullets (and sections of bullets), then
61
34
sorts the contents of these sets and turns them back into a series of lines of
62
35
text.
63
36
64
29
Limitations:
37
Limitations:
65
30
38
68
31
* if there's a conflict in more than just bullet points, this doesn't yet know
39
* invisible whitespace in blank lines is not tracked, so is discarded.  (i.e.
69
32
  how to resolve that, so bzr will fallback to the default line-based merge.
40
  [newline, space, newline] is collapsed to just [newline, newline])
70
41
71
42
* empty sections are generally deleted, even if they were present in the
72
43
  originals.
73
44
74
45
* modified sections will typically be reordered to match the standard order (as
75
46
  shown in the template at the bottom of NEWS).
76
47
77
48
* if there's a conflict that involves more than simple sections of bullets,
78
49
  this plugin doesn't know how to handle that.  e.g. a conflict in preamble
79
50
  text describing a new version, or sufficiently many conflicts that the
80
51
  matcher thinks a conflict spans a version heading.  bzr's builtin merge logic
81
52
  will be tried instead.
82
33
"""
53
"""
83
34
54
84
35
# Since we are a built-in plugin we share the bzrlib version
55
# Since we are a built-in plugin we share the bzrlib version
85
36
56
86
=== modified file 'bzrlib/plugins/news_merge/news_merge.py'
87
--- bzrlib/plugins/news_merge/news_merge.py	2010-01-28 18:05:44 +0000
88
+++ bzrlib/plugins/news_merge/news_merge.py	2010-04-20 13:35:41 +0000
89
@@ -16,12 +16,21 @@
90
16
16
91
17
"""Merge logic for news_merge plugin."""
17
"""Merge logic for news_merge plugin."""
92
18
18
99
19
19
import copy
100
20
from bzrlib.plugins.news_merge.parser import simple_parse
20
101
21
from bzrlib import merge, merge3
21
from bzrlib.plugins.news_merge.parser import (
102
22
22
    ContainerChunk,
103
23
23
    parse_lines_to_structure,
104
24
magic_marker = '|NEWS-MERGE-MAGIC-MARKER|'
24
    simple_parse,
105
25
    )
106
26
from bzrlib import merge, merge3, trace
107
27
108
28
109
29
class Infinity(object):
110
30
    """Object that always sorts to the end of a list."""
111
31
112
32
    def __lt__(self, other):
113
33
        return True
114
25
34
115
26
35
116
27
class NewsMerger(merge.ConfigurableFileMerger):
36
class NewsMerger(merge.ConfigurableFileMerger):
117
@@ -29,6 +38,51 @@
118
29
38
119
30
    name_prefix = "news"
39
    name_prefix = "news"
120
31
40
121
41
    def __init__(self, merger):
122
42
        super(NewsMerger, self).__init__(merger)
123
43
        self.canonical_section_order = None
124
44
125
45
    def get_section_ordering(self):
126
46
        if self.canonical_section_order is None:
127
47
            # None is a placeholder for an unseen section heading.
128
48
            sections = [None]
129
49
            try:
130
50
                # Read file named by ${name_prefix}_template config option, and
131
51
                # extract the preferred section order from that.
132
52
                this_tree = self.merger.this_tree
133
53
                config = this_tree.branch.get_config()
134
54
                config_key = self.name_prefix + '_template'
135
55
                template_path = config.get_user_option(config_key)
136
56
                template_file_id = this_tree.path2id(template_path)
137
57
                template = this_tree.get_file_text(template_file_id)
138
58
                for kind, text in simple_parse(template):
139
59
                    if kind == 'section':
140
60
                        sections.append(text.split('\n', 1)[0])
141
61
            except Exception:
142
62
                trace.mutter('could not read NEWS template')
143
63
                trace.log_exception_quietly()
144
64
            trace.mutter('news merge section order: %r', sections)
145
65
            self.canonical_section_order = sections
146
66
        return self.canonical_section_order
147
67
148
68
    def sort_sections(self, sections):
149
69
        return sorted(sections, key=self.section_sort_key)
150
70
151
71
    def sort_section_names(self, section_names):
152
72
        return sorted(section_names, key=self.section_name_sort_key)
153
73
154
74
    def section_sort_key(self, section):
155
75
        section_name = section.text.split('\n', 1)[0]
156
76
        return self.section_name_sort_key(section_name)
157
77
158
78
    def section_name_sort_key(self, section):
159
79
        canonical_section_order = self.get_section_ordering()
160
80
        try:
161
81
            return canonical_section_order.index(section)
162
82
        except ValueError:
163
83
            # Put unexpected sections last.
164
84
            return Infinity()
165
85
166
32
    def merge_text(self, params):
86
    def merge_text(self, params):
167
33
        """Perform a simple 3-way merge of a bzr NEWS file.
87
        """Perform a simple 3-way merge of a bzr NEWS file.
168
34
        
88
        
169
@@ -36,59 +90,178 @@
170
36
        points, so we can simply take a set of bullet points, determine which
90
        points, so we can simply take a set of bullet points, determine which
171
37
        bullets to add and which to remove, sort, and reserialize.
91
        bullets to add and which to remove, sort, and reserialize.
172
38
        """
92
        """
183
39
        # Transform the different versions of the NEWS file into a bunch of
93
        trace.mutter('news_merge triggered')
184
40
        # text lines where each line matches one part of the overall
94
        this_news_file = canonicalise_news_file(parse_lines_to_structure(params.this_lines), self)
185
41
        # structure, e.g. a heading or bullet.
95
        other_news_file = canonicalise_news_file(parse_lines_to_structure(params.other_lines), self)
186
42
        def munge(lines):
96
        base_news_file = canonicalise_news_file(parse_lines_to_structure(params.base_lines), self)
187
43
            return list(blocks_to_fakelines(simple_parse(''.join(lines))))
97
        m3 = merge3.Merge3(list(base_news_file.flatten()),
188
44
        this_lines = munge(params.this_lines)
98
                list(this_news_file.flatten()),
189
45
        other_lines = munge(params.other_lines)
99
                list(other_news_file.flatten()), allow_objects=True)
190
46
        base_lines = munge(params.base_lines)
100
        result_chunks = []
181
47
        m3 = merge3.Merge3(base_lines, this_lines, other_lines)
182
48
        result_lines = []
191
49
        for group in m3.merge_groups():
101
        for group in m3.merge_groups():
192
50
            if group[0] == 'conflict':
102
            if group[0] == 'conflict':
193
51
                _, base, a, b = group
103
                _, base, a, b = group
214
52
                # Are all the conflicting lines bullets?  If so, we can merge
104
                # Are all the conflicting lines bullets or sections?  If so, we
215
53
                # this.
105
                # can merge this.
216
54
                for line_set in [base, a, b]:
106
                try:
217
55
                    for line in line_set:
107
                    base_sections = chunks_to_section_dict(base)
218
56
                        if not line.startswith('bullet'):
108
                    a_sections = chunks_to_section_dict(a)
219
57
                            # Something else :(
109
                    b_sections = chunks_to_section_dict(b)
220
58
                            # Maybe the default merge can cope.
110
                except MergeTooHard, mth:
221
59
                            return 'not_applicable', None
111
                    # Something else :(
222
60
                # Calculate additions and deletions.
112
                    # Maybe the default merge can cope.
223
61
                new_in_a = set(a).difference(base)
113
                    trace.mutter('news_merge giving up: %s', mth)
224
62
                new_in_b = set(b).difference(base)
114
                    return 'not_applicable', None
225
63
                all_new = new_in_a.union(new_in_b)
115
                    
226
64
                deleted_in_a = set(base).difference(a)
116
                # Basically, for every section present in any version, call
227
65
                deleted_in_b = set(base).difference(b)
117
                # merge_bullets (passing an empty set for versions missing
228
66
                # Combine into the final set of bullet points.
118
                # that section), and if the resulting set of bullets is not
229
67
                final = all_new.difference(deleted_in_a).difference(
119
                # empty, emit the section heading and the sorted set of
230
68
                    deleted_in_b)
120
                # bullets.
231
69
                # Sort, and emit.
121
                all_sections = set(
232
70
                final = sorted(final, key=sort_key)
122
                    base_sections.keys() + a_sections.keys() +
233
71
                result_lines.extend(final)
123
                    b_sections.keys())
234
124
                sections_in_order = self.sort_section_names(all_sections)
235
125
                for section in sections_in_order:
236
126
                    bullets = merge_bullets(
237
127
                        base_sections.get(section, set()),
238
128
                        a_sections.get(section, set()),
239
129
                        b_sections.get(section, set()))
240
130
                    if bullets:
241
131
                        # Emit section heading (if any), then sorted bullets.
242
132
                        if section is not None:
243
133
                            result_chunks.append(
244
134
                                ContainerChunk(
245
135
                                    'section',
246
136
                                    section + '\n' + '*'*len(section)))
247
137
                        final = sorted(bullets, key=sort_key)
248
138
                        result_chunks.extend(final)
249
72
            else:
139
            else:
251
73
                result_lines.extend(group[1])
140
                result_chunks.extend(group[1])
252
74
        # Transform the merged elements back into real blocks of lines.
141
        # Transform the merged elements back into real blocks of lines.
273
75
        return 'success', list(fakelines_to_blocks(result_lines))
142
        trace.mutter('news_merge succeeded.')
274
76
143
        filename = self.merger.this_tree.id2path(params.file_id)
275
77
144
        trace.note('Merged by news_merge: %s', filename)
276
78
def blocks_to_fakelines(blocks):
145
        result_lines = ''.join(chunk.text for chunk in result_chunks)
277
79
    for kind, text in blocks:
146
        return 'success', result_lines
278
80
        yield '%s%s%s' % (kind, magic_marker, text)
147
279
81
148
280
82
149
def merge_bullets(base_bullets, a_bullets, b_bullets):
281
83
def fakelines_to_blocks(fakelines):
150
    # Calculate additions and deletions.
282
84
    fakelines = list(fakelines)
151
    new_in_a = a_bullets.difference(base_bullets)
283
85
    # Strip out the magic_marker, and reinstate the \n\n between blocks
152
    new_in_b = b_bullets.difference(base_bullets)
284
86
    for fakeline in fakelines[:-1]:
153
    all_new = new_in_a.union(new_in_b)
285
87
        yield fakeline.split(magic_marker, 1)[1] + '\n\n'
154
    deleted_in_a = base_bullets.difference(a_bullets)
286
88
    # The final block doesn't have a trailing \n\n.
155
    deleted_in_b = base_bullets.difference(b_bullets)
287
89
    for fakeline in fakelines[-1:]:
156
    # Combine into the final set of bullet points.
288
90
        yield fakeline.split(magic_marker, 1)[1]
157
    final = all_new.difference(deleted_in_a).difference(deleted_in_b)
289
91
158
    return final
290
92
159
291
93
def sort_key(s):
160
292
94
    return s.replace('`', '').lower()
161
class MergeTooHard(Exception):
293
162
    pass
294
163
295
164
296
165
def chunks_to_section_dict(chunks):
297
166
    """Takes a sequence of chunks, and returns a dict mapping section to
298
167
    a set of bullets.
299
168
300
169
    :param chunks: a sequence of chunks
301
170
    :raises MergeTooHard: when chunks contain anything other than sections or
302
171
        bullets
303
172
    :returns: a dict of section name -> set of bullet chunks.  Any
304
173
        bullets encounted before a section will have a name of None.
305
174
    """
306
175
    section_name = None
307
176
    section_dict = {}
308
177
    for chunk in chunks:
309
178
        if chunk.kind == 'section':
310
179
            section_name = chunk.text.split('\n', 1)[0]
311
180
        elif chunk.kind == 'bullet':
312
181
            try:
313
182
                bullets = section_dict[section_name]
314
183
            except KeyError:
315
184
                bullets = section_dict[section_name] = set()
316
185
            bullets.add(chunk)
317
186
        else:
318
187
            raise MergeTooHard(chunk)
319
188
    return section_dict
320
189
321
190
322
191
def sort_key(chunk):
323
192
    return chunk.text.replace('`', '').lower()
324
193
325
194
326
195
def canonicalise_news_file(news_file, merger):
327
196
    new_chunks = []
328
197
    for chunk in news_file.chunks:
329
198
        if chunk.kind == 'release':
330
199
            chunk = canonicalise_release(chunk, merger)
331
200
        new_chunks.append(chunk)
332
201
    news_file = copy.copy(news_file)
333
202
    news_file.chunks = new_chunks
334
203
    return news_file
335
204
336
205
337
206
def canonicalise_release(release, merger):
338
207
    preamble = True
339
208
    new_chunks = []
340
209
    sections = []
341
210
    for chunk in release.chunks:
342
211
        if preamble and chunk.kind != 'section':
343
212
            new_chunks.append(chunk)
344
213
            continue
345
214
        elif chunk.kind == 'section':
346
215
            preamble = False
347
216
            section = canonicalise_section(chunk)
348
217
            sections.append(section)
349
218
        else:
350
219
            # not preamble, not section... must be trailing garbage.  Blah.
351
220
            # XXX: should probably raise an error or something.  For now just
352
221
            # add it to new_chunks, it'll become part of the preamble.
353
222
            new_chunks.append(chunk)
354
223
355
224
    # Sort the sections by name
356
225
    sections = merger.sort_sections(sections)
357
226
    # Combine duplicated sections (which will be adjacent after the sorting)
358
227
    canonical_sections = []
359
228
    for section in sections:
360
229
        if canonical_sections and canonical_sections[-1].text == section.text:
361
230
            # Identical.  Combine them.
362
231
            chunks = canonical_sections[-1].chunks + section.chunks
363
232
            section = copy.copy(section)
364
233
            section.chunks = chunks
365
234
            section = canonicalise_section(section)
366
235
            canonical_sections[-1] = section
367
236
            continue
368
237
        else:
369
238
            canonical_sections.append(section)
370
239
    new_chunks.extend(canonical_sections)
371
240
    release = copy.copy(release)
372
241
    release.chunks = new_chunks
373
242
    return release
374
243
375
244
376
245
def canonicalise_section(section):
377
246
    preamble = True
378
247
    new_chunks = []
379
248
    bullets = set()
380
249
    for chunk in section.chunks:
381
250
        if preamble and chunk.kind != 'bullet':
382
251
            new_chunks.append(chunk)
383
252
            continue
384
253
        elif chunk.kind == 'bullet':
385
254
            preamble = False
386
255
            bullets.add(chunk.text)
387
256
        else:
388
257
            # not preamble, not bullet... must be trailing garbage.  Blah.
389
258
            # XXX: should probably raise an error or something.  For now just
390
259
            # add it to new_chunks, it'll become part of the preamble.
391
260
            new_chunks.append(chunk)
392
261
    new_section = copy.copy(section)
393
262
    new_section.chunks = new_chunks
394
263
    bullets = sorted(bullets, key=sort_key)
395
264
    for bullet in bullets:
396
265
        new_section.add_leaf('bullet', bullet)
397
266
    return new_section
398
267
399
95
268
400
=== modified file 'bzrlib/plugins/news_merge/parser.py'
401
--- bzrlib/plugins/news_merge/parser.py	2010-01-18 07:00:11 +0000
402
+++ bzrlib/plugins/news_merge/parser.py	2010-04-20 13:35:41 +0000
403
@@ -24,6 +24,194 @@
404
24
simple_parse's docstring).
24
simple_parse's docstring).
405
25
"""
25
"""
406
26
26
407
27
# [root]
408
28
# - Heading
409
29
# - Text
410
30
# - Release
411
31
#   - Text
412
32
#   - Section
413
33
#     - Bullet
414
34
#   - Section
415
35
#     - Bullet
416
36
#     - Bullet
417
37
# - Release
418
38
#   - Text
419
39
#   - Section
420
40
#     - Bullet
421
41
#   - Section
422
42
#     - Text
423
43
#     - Bullet
424
44
# - Text
425
45
426
46
class ContainerChunk(object):
427
47
428
48
    def __init__(self, kind, text):
429
49
        self.chunks = []
430
50
        self.kind = kind
431
51
        self.text = text
432
52
433
53
    def __repr__(self):
434
54
        if len(self.text) > 20:
435
55
            abbr_text = self.text[:20] + '...'
436
56
        else:
437
57
            abbr_text = self.text
438
58
        return '<%s kind=%s text=%s>' % (
439
59
            self.__class__.__name__, self.kind, repr(abbr_text))
440
60
441
61
    def __cmp__(self, other):
442
62
        if not isinstance(other, ContainerChunk):
443
63
            return NotImplemented
444
64
        return cmp(
445
65
            (self.kind, self.text, self.chunks),
446
66
            (other.kind, other.text, self.chunks))
447
67
448
68
    def __hash__(self):
449
69
        return hash((self.kind, self.text, tuple(self.chunks)))
450
70
451
71
#    def __eq__(self, other):
452
72
#        return (
453
73
#            self.kind == other.kind and
454
74
#            self.text == other.text and
455
75
#            self.chunks == other.chunks)
456
76
#
457
77
#    def __lt__(self, other):
458
78
#        return (
459
79
#            self.kind < other.kind or
460
80
#            self.text < other.text or
461
81
#            self.chunks < other.chunks)
462
82
#
463
83
    def add_container(self, kind, text):
464
84
        container = ContainerChunk(kind, text)
465
85
        self.chunks.append(container)
466
86
        return container
467
87
468
88
    def add_leaf(self, kind, text):
469
89
        if kind == 'blank':
470
90
            # Attach this blank text to the previous chunk (which might be
471
91
            # self), rather than tracking it as its own leaf.
472
92
            if self.chunks:
473
93
                self.chunks[-1].text += text
474
94
            else:
475
95
                self.text += text
476
96
            return
477
97
        chunk = LeafChunk(kind, text)
478
98
        self.chunks.append(chunk)
479
99
        return chunk
480
100
481
101
    def flatten(self):
482
102
        yield self
483
103
        for chunk in self.chunks:
484
104
            for elem in chunk.flatten():
485
105
                yield elem
486
106
        
487
107
    def as_text_iter(self):
488
108
        yield self.text
489
109
        for chunk in self.chunks:
490
110
            for elem in chunk.as_text_iter():
491
111
                yield elem
492
112
493
113
    def as_text(self):
494
114
        return ''.join(self.as_text_iter())
495
115
496
116
497
117
class NewsFile(ContainerChunk):
498
118
499
119
    def __init__(self):
500
120
        ContainerChunk.__init__(self, '(root)', '')
501
121
502
122
503
123
class LeafChunk(object):
504
124
505
125
    def __init__(self, kind, text):
506
126
        self.kind = kind
507
127
        self.text = text
508
128
509
129
    def __repr__(self):
510
130
        if len(self.text) > 20:
511
131
            abbr_text = self.text[:20] + '...'
512
132
        else:
513
133
            abbr_text = self.text
514
134
        return '<%s kind=%s text=%s>' % (
515
135
            self.__class__.__name__, self.kind, repr(abbr_text))
516
136
517
137
    def __cmp__(self, other):
518
138
        if not isinstance(other, LeafChunk):
519
139
            return NotImplemented
520
140
        return cmp((self.kind, self.text), (other.kind, other.text))
521
141
522
142
    def __hash__(self):
523
143
        return hash((self.kind, self.text))
524
144
#
525
145
#    def __eq__(self, other):
526
146
#        return (self.kind == other.kind and self.text == other.text)
527
147
#
528
148
#    def __lt__(self, other):
529
149
#        return (self.kind < other.kind or self.text < other.text)
530
150
#
531
151
    def flatten(self):
532
152
        yield self
533
153
534
154
    def as_text_iter(self):
535
155
        yield self.text
536
156
537
157
538
158
import re
539
159
540
160
541
161
class ParseState(object):
542
162
    def __init__(self):
543
163
        #self.news_file = NewsFile()
544
164
        self.object_stack = []
545
165
546
166
547
167
class BadNewsFile(Exception):
548
168
    """The NEWS file could not be parsed."""
549
169
550
170
551
171
def parse_lines_to_structure(lines):
552
172
    """Same as parse_to_structure, but takes an iterable of strs rather than a
553
173
    single str.
554
174
    """
555
175
    return parse_to_structure(''.join(lines))
556
176
557
177
558
178
def parse_to_structure(content):
559
179
    news_file = NewsFile()
560
180
    leaf_kinds = ('bullet', 'empty', 'text', 'blank')
561
181
    # There's a strict hierarchy:
562
182
    #   Headings contain releases contain sections
563
183
    # Releases never contain releases, etc.
564
184
    # (Any container may contain a leaf, though.)
565
185
    container_hierarchy = ['(root)', 'heading', 'release', 'section']
566
186
567
187
    stack = [news_file]
568
188
    #import pdb; pdb.set_trace()
569
189
    for kind, text in simple_parse(content):
570
190
        #print kind, repr(text)
571
191
        if kind in leaf_kinds:
572
192
            stack[-1].add_leaf(kind, text)
573
193
        elif kind in container_hierarchy:
574
194
            # Pop the container stack until we find the right level to add this
575
195
            # chunk.
576
196
            new_rank = container_hierarchy.index(kind)
577
197
            while True:
578
198
                old_rank = container_hierarchy.index(stack[-1].kind)
579
199
                if new_rank > old_rank:
580
200
                    break
581
201
                stack.pop()
582
202
            container = stack[-1].add_container(kind, text)
583
203
            stack.append(container)
584
204
        else:
585
205
            raise AssertionError('unexpected chunk kind: %r' % (kind,))
586
206
    return news_file
587
207
588
208
589
209
def simple_parse_lines(lines):
590
210
    """Same as simple_parse, but takes an iterable of strs rather than a single
591
211
    str.
592
212
    """
593
213
    return simple_parse(''.join(lines))
594
214
595
27
215
596
28
def simple_parse(content):
216
def simple_parse(content):
597
29
    """Returns blocks, where each block is a 2-tuple (kind, text).
217
    """Returns blocks, where each block is a 2-tuple (kind, text).
598
@@ -31,8 +219,15 @@
599
31
    :kind: one of 'heading', 'release', 'section', 'empty' or 'text'.
219
    :kind: one of 'heading', 'release', 'section', 'empty' or 'text'.
600
32
    :text: a str, including newlines.
220
    :text: a str, including newlines.
601
33
    """
221
    """
603
34
    blocks = content.split('\n\n')
222
    # Split on blank lines.
604
223
    blankline_re = '(\n *\n)'
605
224
    blocks = re.split(blankline_re, content)
606
35
    for block in blocks:
225
    for block in blocks:
607
226
        match = re.match(blankline_re, block)
608
227
        if match is not None and match.groups()[0] == block:
609
228
            # blank line
610
229
            yield 'blank', block
611
230
            continue
612
36
        if block.startswith('###'):
231
        if block.startswith('###'):
613
37
            # First line is ###...: Top heading
232
            # First line is ###...: Top heading
614
38
            yield 'heading', block
233
            yield 'heading', block
615
39
234
616
=== modified file 'bzrlib/plugins/news_merge/tests/__init__.py'
617
--- bzrlib/plugins/news_merge/tests/__init__.py	2010-01-20 16:05:28 +0000
618
+++ bzrlib/plugins/news_merge/tests/__init__.py	2010-04-20 13:35:41 +0000
619
@@ -16,6 +16,7 @@
620
16
16
621
17
def load_tests(basic_tests, module, loader):
17
def load_tests(basic_tests, module, loader):
622
18
    testmod_names = [
18
    testmod_names = [
623
19
        'test_parser',
624
19
        'test_news_merge',
20
        'test_news_merge',
625
20
        ]
21
        ]
626
21
    basic_tests.addTest(loader.loadTestsFromModuleNames(
22
    basic_tests.addTest(loader.loadTestsFromModuleNames(
627
22
23
628
=== added file 'bzrlib/plugins/news_merge/tests/test_parser.py'
629
--- bzrlib/plugins/news_merge/tests/test_parser.py	1970-01-01 00:00:00 +0000
630
+++ bzrlib/plugins/news_merge/tests/test_parser.py	2010-04-20 13:35:41 +0000
631
@@ -0,0 +1,116 @@
632
1
# Copyright (C) 2010 by Canonical Ltd
633
2
#
634
3
# This program is free software; you can redistribute it and/or modify
635
4
# it under the terms of the GNU General Public License as published by
636
5
# the Free Software Foundation; either version 2 of the License, or
637
6
# (at your option) any later version.
638
7
#
639
8
# This program is distributed in the hope that it will be useful,
640
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
641
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
642
11
# GNU General Public License for more details.
643
12
#
644
13
# You should have received a copy of the GNU General Public License
645
14
# along with this program; if not, write to the Free Software
646
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
647
16
648
17
649
18
from bzrlib.tests import TestCase
650
19
651
20
from bzrlib.plugins.news_merge import parser
652
21
653
22
654
23
# Define an example NEWS file with the following structure:
655
24
# [root]
656
25
# - Heading
657
26
# - Text
658
27
# - Release
659
28
#   - Text
660
29
#   - Section
661
30
#     - Bullet
662
31
#   - Section
663
32
#     - Bullet
664
33
#     - Bullet
665
34
# - Release
666
35
#   - Text
667
36
#   - Section
668
37
#     - Bullet
669
38
#   - Section
670
39
#     - Text
671
40
#     - Bullet
672
41
# - Text
673
42
674
43
example_file = """\
675
44
####################
676
45
Bazaar Release Notes
677
46
####################
678
47
679
48
.. contents:: List of Releases
680
49
   :depth: 1
681
50
682
51
bzr x.y.z (not released yet)
683
52
############################
684
53
685
54
:Codename: template
686
55
:x.y.z: ???
687
56
688
57
Compatibility Breaks
689
58
********************
690
59
691
60
* Bullet
692
61
693
62
New Features
694
63
************
695
64
696
65
* Bullet 1
697
66
698
67
* Bullet 2
699
68
700
69
Bug Fixes
701
70
*********
702
71
703
72
bzr x.y.y
704
73
#########
705
74
706
75
:Codename: previous
707
76
708
77
Compatibility Breaks
709
78
********************
710
79
711
80
* Bullet
712
81
713
82
New Features
714
83
************
715
84
716
85
Preamble text for section.
717
86
718
87
* Bullet, not text.
719
88
720
89
Footnote.
721
90
"""
722
91
723
92
class TestStructuredParseSmokeTests(TestCase):
724
93
    """Smoke tests parse_to_structure using example_file."""
725
94
726
95
    def test_parse(self):
727
96
        """example_file can be parsed without an error."""
728
97
        news_file = parser.parse_to_structure(example_file)
729
98
        
730
99
    def test_roundtrip(self):
731
100
        """The NewsFile object can regenerate the original bytes."""
732
101
        news_file = parser.parse_to_structure(example_file)
733
102
        self.assertEqualDiff(example_file, news_file.as_text())
734
103
        
735
104
    def test_flatten(self):
736
105
        """NewsFile.flatten shows the file has been interpreted as
737
106
        releases/sections/bullets etc.
738
107
        """
739
108
        news_file = parser.parse_to_structure(example_file)
740
109
        expected_kinds = ['(root)', 'heading', 'text', 'release', 'text',
741
110
            'section', 'bullet', 'section', 'bullet', 'bullet', 'section',
742
111
            'release', 'text', 'section', 'bullet', 'section', 'text',
743
112
            'bullet', 'text']
744
113
        kinds = [chunk.kind for chunk in news_file.flatten()
745
114
                 if chunk.kind != 'blank']
746
115
        self.assertEqual(expected_kinds, kinds)
747
116
Reviewer	Review Type	Date Requested	Status
Robert Collins (community)		2010-02-13	Needs Fixing on 2010-02-13
Review via email: mp+19247@code.launchpad.net