diff options
Diffstat (limited to 'websdk/mercurial/mdiff.py')
| -rw-r--r--[l---------] | websdk/mercurial/mdiff.py | 288 |
1 files changed, 287 insertions, 1 deletions
diff --git a/websdk/mercurial/mdiff.py b/websdk/mercurial/mdiff.py index 458f756..55ea89a 120000..100644 --- a/websdk/mercurial/mdiff.py +++ b/websdk/mercurial/mdiff.py @@ -1 +1,287 @@ -/usr/share/pyshared/mercurial/mdiff.py
\ No newline at end of file +# mdiff.py - diff and patch routines for mercurial +# +# Copyright 2005, 2006 Matt Mackall <mpm@selenic.com> +# +# This software may be used and distributed according to the terms of the +# GNU General Public License version 2 or any later version. + +from i18n import _ +import bdiff, mpatch, util +import re, struct + +def splitnewlines(text): + '''like str.splitlines, but only split on newlines.''' + 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 + +class diffopts(object): + '''context is the number of context lines + text treats all files as text + showfunc enables diff -p output + git enables the git extended patch format + nodates removes dates from diff headers + ignorews ignores all whitespace changes in the diff + ignorewsamount ignores changes in the amount of whitespace + ignoreblanklines ignores changes whose lines are all blank + upgrade generates git diffs to avoid data loss + ''' + + defaults = { + 'context': 3, + 'text': False, + 'showfunc': False, + 'git': False, + 'nodates': False, + 'ignorews': False, + 'ignorewsamount': False, + 'ignoreblanklines': False, + 'upgrade': False, + } + + __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) + + try: + self.context = int(self.context) + except ValueError: + raise util.Abort(_('diff context lines count must be ' + 'an integer, not %r') % self.context) + + def copy(self, **kwargs): + opts = dict((k, getattr(self, k)) for k in self.defaults) + opts.update(kwargs) + return diffopts(**opts) + +defaultopts = diffopts() + +def wsclean(opts, text, blank=True): + if opts.ignorews: + text = re.sub('[ \t\r]+', '', text) + elif opts.ignorewsamount: + text = re.sub('[ \t\r]+', ' ', text) + text = text.replace(' \n', '\n') + if blank and opts.ignoreblanklines: + text = re.sub('\n+', '\n', text).strip('\n') + return text + +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' + +def unidiff(a, ad, b, bd, fn1, fn2, r=None, opts=defaultopts): + def datetag(date, addtab=True): + if not opts.git and not opts.nodates: + return '\t%s\n' % date + if addtab and ' ' in fn1: + return '\t\n' + return '\n' + + if not a and not b: + return "" + epoch = util.datestr((0, 0)) + + if not opts.text and (util.binary(a) or util.binary(b)): + if a and b and len(a) == len(b) and a == b: + return "" + l = ['Binary file %s has changed\n' % fn1] + elif not a: + b = splitnewlines(b) + if a is None: + l1 = '--- /dev/null%s' % datetag(epoch, False) + else: + l1 = "--- %s%s" % ("a/" + fn1, datetag(ad)) + l2 = "+++ %s%s" % ("b/" + fn2, datetag(bd)) + l3 = "@@ -0,0 +1,%d @@\n" % len(b) + l = [l1, l2, l3] + ["+" + e for e in b] + elif not b: + a = splitnewlines(a) + l1 = "--- %s%s" % ("a/" + fn1, datetag(ad)) + if b is None: + l2 = '+++ /dev/null%s' % datetag(epoch, False) + else: + l2 = "+++ %s%s" % ("b/" + fn2, datetag(bd)) + l3 = "@@ -1,%d +0,0 @@\n" % len(a) + l = [l1, l2, l3] + ["-" + e for e in a] + else: + al = splitnewlines(a) + bl = splitnewlines(b) + l = list(_unidiff(a, b, al, bl, opts=opts)) + if not l: + return "" + + l.insert(0, "--- a/%s%s" % (fn1, datetag(ad))) + l.insert(1, "+++ b/%s%s" % (fn2, datetag(bd))) + + for ln in xrange(len(l)): + if l[ln][-1] != '\n': + l[ln] += "\n\ No newline at end of file\n" + + if r: + l.insert(0, diffline(r, fn1, fn2, opts)) + + return "".join(l) + +# creates a headerless unified diff +# t1 and t2 are the text to be diffed +# l1 and l2 are the text broken up into lines +def _unidiff(t1, t2, l1, l2, opts=defaultopts): + def contextend(l, len): + ret = l + opts.context + if ret > len: + ret = len + return ret + + def contextstart(l): + ret = l - opts.context + if ret < 0: + return 0 + return ret + + lastfunc = [0, ''] + def yieldhunk(hunk): + (astart, a2, bstart, b2, delta) = hunk + aend = contextend(a2, len(l1)) + alen = aend - astart + blen = b2 - bstart + aend - a2 + + func = "" + if opts.showfunc: + 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 + break + # 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 + + # 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) + 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. + # + if opts.ignorews or opts.ignorewsamount: + t1 = wsclean(opts, t1, False) + t2 = wsclean(opts, t2, False) + + diff = bdiff.blocks(t1, t2) + hunk = None + 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] + delta = [] + a1 = s[1] + a2 = s1[0] + b1 = s[3] + b2 = s1[2] + + old = l1[a1:a2] + new = l2[b1:b2] + + # 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 + + astart = contextstart(a1) + bstart = contextstart(b1) + prev = None + if hunk: + # join with the previous hunk if it falls inside the context + if astart < hunk[1] + opts.context + 1: + prev = hunk + astart = hunk[1] + bstart = hunk[3] + else: + for x in yieldhunk(hunk): + 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 + hunk = [astart, a2, bstart, b2, delta] + + 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] + + if hunk: + for x in yieldhunk(hunk): + yield x + +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) + +def patch(a, bin): + if len(a) == 0: + # skip over trivial delta header + return buffer(bin, 12) + return mpatch.patches(a, [bin]) + +# 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)] + +def trivialdiffheader(length): + return struct.pack(">lll", 0, 0, length) + +patches = mpatch.patches +patchedsize = mpatch.patchedsize +textdiff = bdiff.bdiff |