← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/merge3.py

  • Committer: John Arbash Meinel
  • Date: 2008-03-04 14:25:46 UTC
  • mto: This revision was merged to the branch mainline in revision 3279.
  • Revision ID: john@arbash-meinel.com-20080304142546-zuwwy0o9roo14928
Implement cherrypick support for Merge3
When merging a cherrypick, use a slightly different resolve logic.
When encountering a conflict, the new logic does not include lines that
were present in BASE that are conflicting with OTHER.
This is done since a cherrypick is (by definition) avoiding changes that
are present in the base.
(related to bug #151731)

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
        zzcur = 0
 
291
        bbcur = 0
 
292
        yielded_a = False
 
293
        for region_iz, region_ib, region_len in matches:
 
294
            conflict_z_len = region_iz - zzcur
 
295
            conflict_b_len = region_ib - bbcur
 
296
            if conflict_b_len == 0: # There are no lines in b which conflict,
 
297
                                    # so skip it
 
298
                pass
 
299
            else:
 
300
                if yielded_a:
 
301
                    yield ('conflict', zstart + zzcur, zstart + region_iz,
 
302
                           aend, aend, bstart + bbcur, bstart + region_ib)
 
303
                else:
 
304
                    # The first conflict gets the a-range
 
305
                    yielded_a = True
 
306
                    yield ('conflict', zstart + zzcur, zstart + region_iz,
 
307
                           astart, aend, bstart + bbcur, bstart + region_ib)
 
308
            zzcur = region_iz + region_len
 
309
            bbcur = region_ib + region_len
 
310
        if zzcur != zend - zstart or bbcur != bend - bstart:
 
311
            if yielded_a:
 
312
                yield ('conflict', zstart + zzcur, zstart + region_iz,
 
313
                       aend, aend, bstart + bbcur, bstart + region_ib)
 
314
            else:
 
315
                # The first conflict gets the a-range
 
316
                yielded_a = True
 
317
                yield ('conflict', zstart + zzcur, zstart + region_iz,
 
318
                       astart, aend, bstart + bbcur, bstart + region_ib)
 
319
        if not yielded_a:
 
320
            yield ('conflict', zstart, zend, astart, aend, bstart, bend)
289
321
 
290
322
    def reprocess_merge_regions(self, merge_regions):
291
323
        """Where there are conflict regions, remove the agreed lines.
318
350
            if reg is not None:
319
351
                yield reg
320
352
 
321
 
 
322
353
    @staticmethod
323
354
    def mismatch_region(next_a, region_ia,  next_b, region_ib):
324
355
        if next_a < region_ia or next_b < region_ib:
325
356
            return 'conflict', None, None, next_a, region_ia, next_b, region_ib
326
 
            
327
357
 
328
358
    def find_sync_regions(self):
329
359
        """Return a list of sync regions, where both descendents match the base.
366
396
                aend = asub + intlen
367
397
                bend = bsub + intlen
368
398
 
 
399
                # XXX: How much overhead is involved in slicing all of these
 
400
                #      and doing an extra comparison
369
401
                assert self.base[intbase:intend] == self.a[asub:aend], \
370
402
                       (self.base[intbase:intend], self.a[asub:aend])
371
403
 
388
420
 
389
421
        return sl
390
422
 
391
 
 
392
 
 
393
423
    def find_unconflicted(self):
394
424
        """Return a list of ranges in base that are not conflicted."""
395
425
        am = bzrlib.patiencediff.PatienceSequenceMatcher(