mdiff.py
304 lines
| 9.3 KiB
| text/x-python
|
PythonLexer
/ mercurial / mdiff.py
|
r239 | # mdiff.py - diff and patch routines for mercurial | ||
# | ||||
|
r2859 | # Copyright 2005, 2006 Matt Mackall <mpm@selenic.com> | ||
|
r239 | # | ||
|
r8225 | # This software may be used and distributed according to the terms of the | ||
|
r10263 | # GNU General Public License version 2 or any later version. | ||
|
r239 | |||
|
r6467 | from i18n import _ | ||
|
r8312 | import bdiff, mpatch, util | ||
import re, struct | ||||
|
r0 | |||
|
r2251 | def splitnewlines(text): | ||
|
r2248 | '''like str.splitlines, but only split on newlines.''' | ||
|
r2251 | lines = [l + '\n' for l in text.split('\n')] | ||
if lines: | ||||
if lines[-1] == '\n': | ||||
lines.pop() | ||||
else: | ||||
lines[-1] = lines[-1][:-1] | ||||
return lines | ||||
|
r2248 | |||
|
r2874 | class diffopts(object): | ||
'''context is the number of context lines | ||||
text treats all files as text | ||||
showfunc enables diff -p output | ||||
|
r2907 | git enables the git extended patch format | ||
|
r3199 | nodates removes dates from diff headers | ||
|
r2874 | ignorews ignores all whitespace changes in the diff | ||
ignorewsamount ignores changes in the amount of whitespace | ||||
|
r10189 | ignoreblanklines ignores changes whose lines are all blank | ||
upgrade generates git diffs to avoid data loss | ||||
''' | ||||
|
r396 | |||
|
r2874 | defaults = { | ||
'context': 3, | ||||
'text': False, | ||||
|
r5863 | 'showfunc': False, | ||
|
r2907 | 'git': False, | ||
|
r3199 | 'nodates': False, | ||
|
r2874 | 'ignorews': False, | ||
'ignorewsamount': False, | ||||
'ignoreblanklines': False, | ||||
|
r10189 | 'upgrade': False, | ||
|
r2874 | } | ||
__slots__ = defaults.keys() | ||||
def __init__(self, **opts): | ||||
for k in self.__slots__: | ||||
v = opts.get(k) | ||||
if v is None: | ||||
v = self.defaults[k] | ||||
setattr(self, k, v) | ||||
|
r6467 | try: | ||
self.context = int(self.context) | ||||
except ValueError: | ||||
raise util.Abort(_('diff context lines count must be ' | ||||
'an integer, not %r') % self.context) | ||||
|
r10185 | def copy(self, **kwargs): | ||
opts = dict((k, getattr(self, k)) for k in self.defaults) | ||||
opts.update(kwargs) | ||||
return diffopts(**opts) | ||||
|
r2874 | defaultopts = diffopts() | ||
|
r9827 | def wsclean(opts, text, blank=True): | ||
|
r4878 | if opts.ignorews: | ||
|
r12751 | text = re.sub('[ \t\r]+', '', text) | ||
|
r4878 | elif opts.ignorewsamount: | ||
|
r12751 | text = re.sub('[ \t\r]+', ' ', text) | ||
text = text.replace(' \n', '\n') | ||||
|
r9827 | if blank and opts.ignoreblanklines: | ||
|
r15509 | text = re.sub('\n+', '\n', text).strip('\n') | ||
|
r4878 | return text | ||
|
r15525 | def diffblocks(text1, text2, opts=None, lines1=None, lines2=None): | ||
"""Return changed blocks between text1 and text2, the blocks in-between | ||||
those emitted by bdiff.blocks. Take in account the whitespace normalization | ||||
rules defined by opts. | ||||
line1 and line2 are text1 and text2 split with splitnewlines() if they are | ||||
already available. | ||||
""" | ||||
if opts is None: | ||||
opts = defaultopts | ||||
if lines1 is None: | ||||
lines1 = splitnewlines(text1) | ||||
if lines2 is None: | ||||
lines2 = splitnewlines(text2) | ||||
if opts.ignorews or opts.ignorewsamount: | ||||
text1 = wsclean(opts, text1, False) | ||||
text2 = wsclean(opts, text2, False) | ||||
diff = bdiff.blocks(text1, text2) | ||||
for i, s1 in enumerate(diff): | ||||
# The first match is special. | ||||
# we've either found a match starting at line 0 or a match later | ||||
# in the file. If it starts later, old and new below will both be | ||||
# empty and we'll continue to the next match. | ||||
if i > 0: | ||||
s = diff[i - 1] | ||||
else: | ||||
s = [0, 0, 0, 0] | ||||
s = [s[1], s1[0], s[3], s1[2]] | ||||
old = lines1[s[0]:s[1]] | ||||
new = lines2[s[2]:s[3]] | ||||
# bdiff sometimes gives huge matches past eof, this check eats them, | ||||
# and deals with the special first match case described above | ||||
if not old and not new: | ||||
continue | ||||
if opts.ignoreblanklines: | ||||
if wsclean(opts, "".join(old)) == wsclean(opts, "".join(new)): | ||||
continue | ||||
yield s | ||||
|
r7200 | def diffline(revs, a, b, opts): | ||
parts = ['diff'] | ||||
if opts.git: | ||||
parts.append('--git') | ||||
if revs and not opts.git: | ||||
parts.append(' '.join(["-r %s" % rev for rev in revs])) | ||||
if opts.git: | ||||
parts.append('a/%s' % a) | ||||
parts.append('b/%s' % b) | ||||
else: | ||||
parts.append(a) | ||||
return ' '.join(parts) + '\n' | ||||
|
r7204 | |||
|
r5482 | def unidiff(a, ad, b, bd, fn1, fn2, r=None, opts=defaultopts): | ||
|
r4679 | def datetag(date, addtab=True): | ||
if not opts.git and not opts.nodates: | ||||
return '\t%s\n' % date | ||||
|
r5482 | if addtab and ' ' in fn1: | ||
|
r4679 | return '\t\n' | ||
return '\n' | ||||
|
r3026 | |||
|
r10282 | if not a and not b: | ||
return "" | ||||
|
r1379 | epoch = util.datestr((0, 0)) | ||
|
r264 | |||
|
r15437 | fn1 = util.pconvert(fn1) | ||
fn2 = util.pconvert(fn2) | ||||
|
r2874 | if not opts.text and (util.binary(a) or util.binary(b)): | ||
|
r6871 | if a and b and len(a) == len(b) and a == b: | ||
|
r4103 | return "" | ||
|
r5482 | l = ['Binary file %s has changed\n' % fn1] | ||
|
r1723 | elif not a: | ||
|
r2251 | b = splitnewlines(b) | ||
|
r1723 | if a is None: | ||
|
r4679 | l1 = '--- /dev/null%s' % datetag(epoch, False) | ||
|
r1723 | else: | ||
|
r5482 | l1 = "--- %s%s" % ("a/" + fn1, datetag(ad)) | ||
l2 = "+++ %s%s" % ("b/" + fn2, datetag(bd)) | ||||
|
r264 | l3 = "@@ -0,0 +1,%d @@\n" % len(b) | ||
l = [l1, l2, l3] + ["+" + e for e in b] | ||||
|
r1723 | elif not b: | ||
|
r2251 | a = splitnewlines(a) | ||
|
r5482 | l1 = "--- %s%s" % ("a/" + fn1, datetag(ad)) | ||
|
r1723 | if b is None: | ||
|
r4679 | l2 = '+++ /dev/null%s' % datetag(epoch, False) | ||
|
r1723 | else: | ||
|
r5482 | l2 = "+++ %s%s" % ("b/" + fn2, datetag(bd)) | ||
|
r264 | l3 = "@@ -1,%d +0,0 @@\n" % len(a) | ||
l = [l1, l2, l3] + ["-" + e for e in a] | ||||
else: | ||||
|
r2251 | al = splitnewlines(a) | ||
bl = splitnewlines(b) | ||||
|
r10614 | l = list(_unidiff(a, b, al, bl, opts=opts)) | ||
|
r10282 | if not l: | ||
return "" | ||||
|
r10614 | |||
l.insert(0, "--- a/%s%s" % (fn1, datetag(ad))) | ||||
l.insert(1, "+++ b/%s%s" % (fn2, datetag(bd))) | ||||
|
r170 | |||
for ln in xrange(len(l)): | ||||
if l[ln][-1] != '\n': | ||||
l[ln] += "\n\ No newline at end of file\n" | ||||
|
r396 | if r: | ||
|
r7200 | l.insert(0, diffline(r, fn1, fn2, opts)) | ||
|
r396 | |||
|
r0 | return "".join(l) | ||
|
r10614 | # creates a headerless unified diff | ||
|
r1637 | # t1 and t2 are the text to be diffed | ||
# l1 and l2 are the text broken up into lines | ||||
|
r10614 | def _unidiff(t1, t2, l1, l2, opts=defaultopts): | ||
|
r1637 | def contextend(l, len): | ||
|
r2874 | ret = l + opts.context | ||
|
r1637 | if ret > len: | ||
ret = len | ||||
return ret | ||||
def contextstart(l): | ||||
|
r2874 | ret = l - opts.context | ||
|
r1637 | if ret < 0: | ||
return 0 | ||||
return ret | ||||
|
r15141 | lastfunc = [0, ''] | ||
|
r10614 | def yieldhunk(hunk): | ||
|
r1637 | (astart, a2, bstart, b2, delta) = hunk | ||
aend = contextend(a2, len(l1)) | ||||
alen = aend - astart | ||||
blen = b2 - bstart + aend - a2 | ||||
func = "" | ||||
|
r2874 | if opts.showfunc: | ||
|
r15141 | lastpos, func = lastfunc | ||
# walk backwards from the start of the context up to the start of | ||||
# the previous hunk context until we find a line starting with an | ||||
# alphanumeric char. | ||||
for i in xrange(astart - 1, lastpos - 1, -1): | ||||
if l1[i][0].isalnum(): | ||||
func = ' ' + l1[i].rstrip()[:40] | ||||
lastfunc[1] = func | ||||
|
r1637 | break | ||
|
r15141 | # by recording this hunk's starting point as the next place to | ||
# start looking for function lines, we avoid reading any line in | ||||
# the file more than once. | ||||
lastfunc[0] = astart | ||||
|
r1637 | |||
|
r15462 | # zero-length hunk ranges report their start line as one less | ||
if alen: | ||||
astart += 1 | ||||
if blen: | ||||
bstart += 1 | ||||
yield "@@ -%d,%d +%d,%d @@%s\n" % (astart, alen, | ||||
bstart, blen, func) | ||||
|
r1637 | for x in delta: | ||
yield x | ||||
for x in xrange(a2, aend): | ||||
yield ' ' + l1[x] | ||||
# bdiff.blocks gives us the matching sequences in the files. The loop | ||||
# below finds the spaces between those matching sequences and translates | ||||
# them into diff output. | ||||
# | ||||
hunk = None | ||||
|
r15525 | for s in diffblocks(t1, t2, opts, l1, l2): | ||
|
r1637 | delta = [] | ||
|
r15525 | a1, a2, b1, b2 = s | ||
|
r1637 | old = l1[a1:a2] | ||
new = l2[b1:b2] | ||||
astart = contextstart(a1) | ||||
bstart = contextstart(b1) | ||||
prev = None | ||||
if hunk: | ||||
# join with the previous hunk if it falls inside the context | ||||
|
r2874 | if astart < hunk[1] + opts.context + 1: | ||
|
r1637 | prev = hunk | ||
astart = hunk[1] | ||||
bstart = hunk[3] | ||||
else: | ||||
|
r10614 | for x in yieldhunk(hunk): | ||
|
r1637 | yield x | ||
if prev: | ||||
# we've joined the previous hunk, record the new ending points. | ||||
hunk[1] = a2 | ||||
hunk[3] = b2 | ||||
delta = hunk[4] | ||||
else: | ||||
# create a new hunk | ||||
|
r10282 | hunk = [astart, a2, bstart, b2, delta] | ||
|
r1637 | |||
|
r10282 | delta[len(delta):] = [' ' + x for x in l1[astart:a1]] | ||
delta[len(delta):] = ['-' + x for x in old] | ||||
delta[len(delta):] = ['+' + x for x in new] | ||||
|
r1637 | |||
if hunk: | ||||
|
r10614 | for x in yieldhunk(hunk): | ||
|
r1637 | yield x | ||
|
r120 | def patchtext(bin): | ||
pos = 0 | ||||
t = [] | ||||
while pos < len(bin): | ||||
p1, p2, l = struct.unpack(">lll", bin[pos:pos + 12]) | ||||
pos += 12 | ||||
t.append(bin[pos:pos + l]) | ||||
pos += l | ||||
return "".join(t) | ||||
|
r0 | def patch(a, bin): | ||
|
r12025 | if len(a) == 0: | ||
# skip over trivial delta header | ||||
return buffer(bin, 12) | ||||
|
r1379 | return mpatch.patches(a, [bin]) | ||
|
r432 | |||
|
r4361 | # similar to difflib.SequenceMatcher.get_matching_blocks | ||
def get_matching_blocks(a, b): | ||||
return [(d[0], d[2], d[1] - d[0]) for d in bdiff.blocks(a, b)] | ||||
|
r5367 | def trivialdiffheader(length): | ||
return struct.pack(">lll", 0, 0, length) | ||||
|
r1379 | patches = mpatch.patches | ||
|
r2078 | patchedsize = mpatch.patchedsize | ||
|
r432 | textdiff = bdiff.bdiff | ||