1
# Copyright (C) 2004, 2005 Canonical Ltd
1
# Copyright (C) 2004, 2005 by Canonical Ltd
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
5
5
# the Free Software Foundation; either version 2 of the License, or
6
6
# (at your option) any later version.
8
8
# This program is distributed in the hope that it will be useful,
9
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11
11
# GNU General Public License for more details.
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18
18
# mbp: "you know that thing where cvs gives you conflict markers?"
19
19
# s: "i hate that."
22
from difflib import SequenceMatcher
22
24
from bzrlib.errors import CantReprocessAndShowBase
23
import bzrlib.patiencediff
24
25
from bzrlib.textfile import check_text_lines
27
27
def intersect(ra, rb):
28
28
"""Given two ranges return the range where they intersect or None.
66
67
Given BASE, OTHER, THIS, tries to produce a combined text
67
68
incorporating the changes from both BASE->OTHER and BASE->THIS.
68
69
All three will typically be sequences of lines."""
69
def __init__(self, base, a, b, is_cherrypick=False):
70
def __init__(self, base, a, b):
70
71
check_text_lines(base)
71
72
check_text_lines(a)
72
73
check_text_lines(b)
76
self.is_cherrypick = is_cherrypick
78
80
def merge_lines(self,
115
111
for i in range(t[1], t[2]):
117
113
elif what == 'conflict':
118
yield start_marker + newline
114
yield start_marker + '\n'
119
115
for i in range(t[3], t[4]):
121
117
if base_marker is not None:
122
yield base_marker + newline
118
yield base_marker + '\n'
123
119
for i in range(t[1], t[2]):
124
120
yield self.base[i]
125
yield mid_marker + newline
121
yield mid_marker + '\n'
126
122
for i in range(t[5], t[6]):
128
yield end_marker + newline
124
yield end_marker + '\n'
130
126
raise ValueError(what)
132
132
def merge_annotated(self):
133
133
"""Return merge with conflicts, showing origin of lines.
135
Most useful for debugging merge.
135
Most useful for debugging merge.
137
137
for t in self.merge_regions():
220
225
# section a[0:ia] has been disposed of, etc
223
228
for zmatch, zend, amatch, aend, bmatch, bend in self.find_sync_regions():
229
#print 'match base [%d:%d]' % (zmatch, zend)
224
231
matchlen = zend - zmatch
227
# matchlen == (aend - amatch)
228
# matchlen == (bend - bmatch)
233
assert matchlen == (aend - amatch)
234
assert matchlen == (bend - bmatch)
229
236
len_a = amatch - ia
230
237
len_b = bmatch - ib
231
238
len_base = zmatch - iz
235
# assert len_base >= 0
237
243
#print 'unmatched a=%d, b=%d' % (len_a, len_b)
239
245
if len_a or len_b:
240
246
# try to avoid actually slicing the lists
247
equal_a = compare_range(self.a, ia, amatch,
248
self.base, iz, zmatch)
249
equal_b = compare_range(self.b, ib, bmatch,
250
self.base, iz, zmatch)
241
251
same = compare_range(self.a, ia, amatch,
242
252
self.b, ib, bmatch)
245
255
yield 'same', ia, amatch
256
elif equal_a and not equal_b:
257
yield 'b', ib, bmatch
258
elif equal_b and not equal_a:
259
yield 'a', ia, amatch
260
elif not equal_a and not equal_b:
261
yield 'conflict', iz, zmatch, ia, amatch, ib, bmatch
247
equal_a = compare_range(self.a, ia, amatch,
248
self.base, iz, zmatch)
249
equal_b = compare_range(self.b, ib, bmatch,
250
self.base, iz, zmatch)
251
if equal_a and not equal_b:
252
yield 'b', ib, bmatch
253
elif equal_b and not equal_a:
254
yield 'a', ia, amatch
255
elif not equal_a and not equal_b:
256
if self.is_cherrypick:
257
for node in self._refine_cherrypick_conflict(
258
iz, zmatch, ia, amatch,
262
yield 'conflict', iz, zmatch, ia, amatch, ib, bmatch
264
raise AssertionError("can't handle a=b=base but unmatched")
263
raise AssertionError("can't handle a=b=base but unmatched")
270
269
# if the same part of the base was deleted on both sides
271
270
# that's OK, we can just skip it.
275
# assert ia == amatch
276
# assert ib == bmatch
277
# assert iz == zmatch
279
278
yield 'unchanged', zmatch, zend
284
def _refine_cherrypick_conflict(self, zstart, zend, astart, aend, bstart, bend):
285
"""When cherrypicking b => a, ignore matches with b and base."""
286
# Do not emit regions which match, only regions which do not match
287
matches = bzrlib.patiencediff.PatienceSequenceMatcher(None,
288
self.base[zstart:zend], self.b[bstart:bend]).get_matching_blocks()
293
for base_idx, b_idx, match_len in matches:
294
conflict_z_len = base_idx - last_base_idx
295
conflict_b_len = b_idx - last_b_idx
296
if conflict_b_len == 0: # There are no lines in b which conflict,
302
zstart + last_base_idx, zstart + base_idx,
303
aend, aend, bstart + last_b_idx, bstart + b_idx)
305
# The first conflict gets the a-range
307
yield ('conflict', zstart + last_base_idx, zstart +
309
astart, aend, bstart + last_b_idx, bstart + b_idx)
310
last_base_idx = base_idx + match_len
311
last_b_idx = b_idx + match_len
312
if last_base_idx != zend - zstart or last_b_idx != bend - bstart:
314
yield ('conflict', zstart + last_base_idx, zstart + base_idx,
315
aend, aend, bstart + last_b_idx, bstart + b_idx)
317
# The first conflict gets the a-range
319
yield ('conflict', zstart + last_base_idx, zstart + base_idx,
320
astart, aend, bstart + last_b_idx, bstart + b_idx)
322
yield ('conflict', zstart, zend, astart, aend, bstart, bend)
324
284
def reprocess_merge_regions(self, merge_regions):
325
285
"""Where there are conflict regions, remove the agreed lines.
327
Lines where both A and B have made the same changes are
287
Lines where both A and B have made the same changes are
330
290
for region in merge_regions:
334
294
type, iz, zmatch, ia, amatch, ib, bmatch = region
335
295
a_region = self.a[ia:amatch]
336
296
b_region = self.b[ib:bmatch]
337
matches = bzrlib.patiencediff.PatienceSequenceMatcher(
338
None, a_region, b_region).get_matching_blocks()
297
matches = SequenceMatcher(None, a_region,
298
b_region).get_matching_blocks()
341
301
for region_ia, region_ib, region_len in matches[:-1]:
352
312
if reg is not None:
356
317
def mismatch_region(next_a, region_ia, next_b, region_ib):
357
318
if next_a < region_ia or next_b < region_ib:
358
319
return 'conflict', None, None, next_a, region_ia, next_b, region_ib
360
322
def find_sync_regions(self):
361
323
"""Return a list of sync regions, where both descendents match the base.
368
amatches = bzrlib.patiencediff.PatienceSequenceMatcher(
369
None, self.base, self.a).get_matching_blocks()
370
bmatches = bzrlib.patiencediff.PatienceSequenceMatcher(
371
None, self.base, self.b).get_matching_blocks()
330
amatches = SequenceMatcher(None, self.base, self.a).get_matching_blocks()
331
bmatches = SequenceMatcher(None, self.base, self.b).get_matching_blocks()
372
332
len_a = len(amatches)
373
333
len_b = len(bmatches)
389
349
# found a match of base[i[0], i[1]]; this may be less than
390
350
# the region that matches in either one
391
# assert intlen <= alen
392
# assert intlen <= blen
393
# assert abase <= intbase
394
# assert bbase <= intbase
351
assert intlen <= alen
352
assert intlen <= blen
353
assert abase <= intbase
354
assert bbase <= intbase
396
356
asub = amatch + (intbase - abase)
397
357
bsub = bmatch + (intbase - bbase)
398
358
aend = asub + intlen
399
359
bend = bsub + intlen
401
# assert self.base[intbase:intend] == self.a[asub:aend], \
402
# (self.base[intbase:intend], self.a[asub:aend])
403
# assert self.base[intbase:intend] == self.b[bsub:bend]
361
assert self.base[intbase:intend] == self.a[asub:aend], \
362
(self.base[intbase:intend], self.a[asub:aend])
364
assert self.base[intbase:intend] == self.b[bsub:bend]
405
366
sl.append((intbase, intend,
408
370
# advance whichever one ends first in the base text
409
371
if (abase + alen) < (bbase + blen):
414
376
intbase = len(self.base)
415
377
abase = len(self.a)
416
378
bbase = len(self.b)
421
385
def find_unconflicted(self):
422
386
"""Return a list of ranges in base that are not conflicted."""
423
am = bzrlib.patiencediff.PatienceSequenceMatcher(
424
None, self.base, self.a).get_matching_blocks()
425
bm = bzrlib.patiencediff.PatienceSequenceMatcher(
426
None, self.base, self.b).get_matching_blocks()
390
# don't sync-up on lines containing only blanks or pounds
391
junk_re = re.compile(r'^[ \t#]*$')
393
am = SequenceMatcher(junk_re.match, self.base, self.a).get_matching_blocks()
394
bm = SequenceMatcher(junk_re.match, self.base, self.b).get_matching_blocks()