← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/merge3.py

  • Committer: Andrew Bennetts
  • Date: 2008-03-17 17:16:11 UTC
  • mfrom: (3290 +trunk)
  • mto: This revision was merged to the branch mainline in revision 3756.
  • Revision ID: andrew.bennetts@canonical.com-20080317171611-o9wdrnf0m7qwo198
Merge from bzr.dev.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/merge3.py
67
67
    Given BASE, OTHER, THIS, tries to produce a combined text
68
68
    incorporating the changes from both BASE->OTHER and BASE->THIS.
69
69
    All three will typically be sequences of lines."""
70
 
    def __init__(self, base, a, b):
 
70
    def __init__(self, base, a, b, is_cherrypick=False):
71
71
        check_text_lines(base)
72
72
        check_text_lines(a)
73
73
        check_text_lines(b)
74
74
        self.base = base
75
75
        self.a = a
76
76
        self.b = b
77
 
 
78
 
 
 
77
        self.is_cherrypick = is_cherrypick
79
78
 
80
79
    def merge_lines(self,
81
80
                    name_a=None,
130
129
                yield end_marker + newline
131
130
            else:
132
131
                raise ValueError(what)
133
 
        
134
 
        
135
 
 
136
 
 
137
132
 
138
133
    def merge_annotated(self):
139
134
        """Return merge with conflicts, showing origin of lines.
161
156
                yield '>>>>\n'
162
157
            else:
163
158
                raise ValueError(what)
164
 
        
165
 
        
166
 
 
167
 
 
168
159
 
169
160
    def merge_groups(self):
170
161
        """Yield sequence of line groups.  Each one is a tuple:
200
191
            else:
201
192
                raise ValueError(what)
202
193
 
203
 
 
204
194
    def merge_regions(self):
205
195
        """Return sequences of matching and conflicting regions.
206
196
 
250
240
 
251
241
            if len_a or len_b:
252
242
                # try to avoid actually slicing the lists
253
 
                equal_a = compare_range(self.a, ia, amatch,
254
 
                                        self.base, iz, zmatch)
255
 
                equal_b = compare_range(self.b, ib, bmatch,
256
 
                                        self.base, iz, zmatch)
257
243
                same = compare_range(self.a, ia, amatch,
258
244
                                     self.b, ib, bmatch)
259
245
 
260
246
                if same:
261
247
                    yield 'same', ia, amatch
262
 
                elif equal_a and not equal_b:
263
 
                    yield 'b', ib, bmatch
264
 
                elif equal_b and not equal_a:
265
 
                    yield 'a', ia, amatch
266
 
                elif not equal_a and not equal_b:
267
 
                    yield 'conflict', iz, zmatch, ia, amatch, ib, bmatch
268
248
                else:
269
 
                    raise AssertionError("can't handle a=b=base but unmatched")
 
249
                    equal_a = compare_range(self.a, ia, amatch,
 
250
                                            self.base, iz, zmatch)
 
251
                    equal_b = compare_range(self.b, ib, bmatch,
 
252
                                            self.base, iz, zmatch)
 
253
                    if equal_a and not equal_b:
 
254
                        yield 'b', ib, bmatch
 
255
                    elif equal_b and not equal_a:
 
256
                        yield 'a', ia, amatch
 
257
                    elif not equal_a and not equal_b:
 
258
                        if self.is_cherrypick:
 
259
                            for node in self._refine_cherrypick_conflict(
 
260
                                                    iz, zmatch, ia, amatch,
 
261
                                                    ib, bmatch):
 
262
                                yield node
 
263
                        else:
 
264
                            yield 'conflict', iz, zmatch, ia, amatch, ib, bmatch
 
265
                    else:
 
266
                        raise AssertionError("can't handle a=b=base but unmatched")
270
267
 
271
268
                ia = amatch
272
269
                ib = bmatch
275
272
            # if the same part of the base was deleted on both sides
276
273
            # that's OK, we can just skip it.
277
274
 
278
 
                
279
275
            if matchlen > 0:
280
276
                assert ia == amatch
281
277
                assert ib == bmatch
285
281
                iz = zend
286
282
                ia = aend
287
283
                ib = bend
288
 
    
 
284
 
 
285
    def _refine_cherrypick_conflict(self, zstart, zend, astart, aend, bstart, bend):
 
286
        """When cherrypicking b => a, ignore matches with b and base."""
 
287
        # Do not emit regions which match, only regions which do not match
 
288
        matches = bzrlib.patiencediff.PatienceSequenceMatcher(None,
 
289
            self.base[zstart:zend], self.b[bstart:bend]).get_matching_blocks()
 
290
        last_base_idx = 0
 
291
        last_b_idx = 0
 
292
        last_b_idx = 0
 
293
        yielded_a = False
 
294
        for base_idx, b_idx, match_len in matches:
 
295
            conflict_z_len = base_idx - last_base_idx
 
296
            conflict_b_len = b_idx - last_b_idx
 
297
            if conflict_b_len == 0: # There are no lines in b which conflict,
 
298
                                    # so skip it
 
299
                pass
 
300
            else:
 
301
                if yielded_a:
 
302
                    yield ('conflict',
 
303
                           zstart + last_base_idx, zstart + base_idx,
 
304
                           aend, aend, bstart + last_b_idx, bstart + b_idx)
 
305
                else:
 
306
                    # The first conflict gets the a-range
 
307
                    yielded_a = True
 
308
                    yield ('conflict', zstart + last_base_idx, zstart +
 
309
                    base_idx,
 
310
                           astart, aend, bstart + last_b_idx, bstart + b_idx)
 
311
            last_base_idx = base_idx + match_len
 
312
            last_b_idx = b_idx + match_len
 
313
        if last_base_idx != zend - zstart or last_b_idx != bend - bstart:
 
314
            if yielded_a:
 
315
                yield ('conflict', zstart + last_base_idx, zstart + base_idx,
 
316
                       aend, aend, bstart + last_b_idx, bstart + b_idx)
 
317
            else:
 
318
                # The first conflict gets the a-range
 
319
                yielded_a = True
 
320
                yield ('conflict', zstart + last_base_idx, zstart + base_idx,
 
321
                       astart, aend, bstart + last_b_idx, bstart + b_idx)
 
322
        if not yielded_a:
 
323
            yield ('conflict', zstart, zend, astart, aend, bstart, bend)
289
324
 
290
325
    def reprocess_merge_regions(self, merge_regions):
291
326
        """Where there are conflict regions, remove the agreed lines.
318
353
            if reg is not None:
319
354
                yield reg
320
355
 
321
 
 
322
356
    @staticmethod
323
357
    def mismatch_region(next_a, region_ia,  next_b, region_ib):
324
358
        if next_a < region_ia or next_b < region_ib:
325
359
            return 'conflict', None, None, next_a, region_ia, next_b, region_ib
326
 
            
327
360
 
328
361
    def find_sync_regions(self):
329
362
        """Return a list of sync regions, where both descendents match the base.
388
421
 
389
422
        return sl
390
423
 
391
 
 
392
 
 
393
424
    def find_unconflicted(self):
394
425
        """Return a list of ranges in base that are not conflicted."""
395
426
        am = bzrlib.patiencediff.PatienceSequenceMatcher(