mdiff.py
555 lines
| 17.3 KiB
| text/x-python
|
PythonLexer
/ mercurial / mdiff.py
|
r239 | # mdiff.py - diff and patch routines for mercurial | ||
# | ||||
|
r47575 | # Copyright 2005, 2006 Olivia Mackall <olivia@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 | |||
|
r27484 | |||
import re | ||||
import struct | ||||
import zlib | ||||
from .i18n import _ | ||||
|
r43359 | from .pycompat import ( | ||
getattr, | ||||
setattr, | ||||
) | ||||
|
r27484 | from . import ( | ||
|
r45714 | diffhelper, | ||
|
r36432 | encoding, | ||
|
r27484 | error, | ||
|
r32369 | policy, | ||
|
r31631 | pycompat, | ||
|
r27484 | util, | ||
) | ||||
|
r36625 | from .utils import dateutil | ||
|
r0 | |||
|
r43906 | bdiff = policy.importmod('bdiff') | ||
mpatch = policy.importmod('mpatch') | ||||
|
r32369 | |||
|
r32201 | blocks = bdiff.blocks | ||
fixws = bdiff.fixws | ||||
|
r32199 | patches = mpatch.patches | ||
patchedsize = mpatch.patchedsize | ||||
|
r36673 | textdiff = bdiff.bdiff | ||
|
r36163 | splitnewlines = bdiff.splitnewlines | ||
|
r2248 | |||
|
r43346 | |||
|
r43784 | # TODO: this looks like it could be an attrs, which might help pytype | ||
|
r49801 | class diffopts: | ||
|
r46554 | """context is the number of context lines | ||
|
r2874 | 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 | ||
|
r23293 | nobinary ignores binary files | ||
|
r23294 | noprefix disables the 'a/' and 'b/' prefixes (ignored in plain mode) | ||
|
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 | ||||
|
r46554 | """ | ||
|
r396 | |||
|
r43784 | _HAS_DYNAMIC_ATTRIBUTES = True | ||
|
r2874 | defaults = { | ||
|
r43347 | b'context': 3, | ||
b'text': False, | ||||
b'showfunc': False, | ||||
b'git': False, | ||||
b'nodates': False, | ||||
b'nobinary': False, | ||||
b'noprefix': False, | ||||
b'index': 0, | ||||
b'ignorews': False, | ||||
b'ignorewsamount': False, | ||||
b'ignorewseol': False, | ||||
b'ignoreblanklines': False, | ||||
b'upgrade': False, | ||||
b'showsimilarity': False, | ||||
b'worddiff': False, | ||||
b'xdiff': False, | ||||
|
r43346 | } | ||
|
r2874 | |||
def __init__(self, **opts): | ||||
|
r31631 | opts = pycompat.byteskwargs(opts) | ||
|
r29416 | for k in self.defaults.keys(): | ||
|
r2874 | 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: | ||||
|
r49188 | raise error.InputError( | ||
|
r43387 | _(b'diff context lines count must be an integer, not %r') | ||
|
r43346 | % pycompat.bytestr(self.context) | ||
) | ||||
|
r6467 | |||
|
r10185 | def copy(self, **kwargs): | ||
|
r44937 | opts = {k: getattr(self, k) for k in self.defaults} | ||
|
r33102 | opts = pycompat.strkwargs(opts) | ||
|
r10185 | opts.update(kwargs) | ||
return diffopts(**opts) | ||||
|
r43346 | |||
|
r2874 | defaultopts = diffopts() | ||
|
r43346 | |||
|
r9827 | def wsclean(opts, text, blank=True): | ||
|
r4878 | if opts.ignorews: | ||
|
r15530 | text = bdiff.fixws(text, 1) | ||
|
r4878 | elif opts.ignorewsamount: | ||
|
r15530 | text = bdiff.fixws(text, 0) | ||
|
r9827 | if blank and opts.ignoreblanklines: | ||
|
r43347 | text = re.sub(b'\n+', b'\n', text).strip(b'\n') | ||
|
r34015 | if opts.ignorewseol: | ||
|
r37389 | text = re.sub(br'[ \t\r\f]+\n', br'\n', text) | ||
|
r4878 | return text | ||
|
r43346 | |||
|
r15528 | def splitblock(base1, lines1, base2, lines2, opts): | ||
# The input lines matches except for interwoven blank lines. We | ||||
# transform it into a sequence of matching blocks and blank blocks. | ||||
lines1 = [(wsclean(opts, l) and 1 or 0) for l in lines1] | ||||
lines2 = [(wsclean(opts, l) and 1 or 0) for l in lines2] | ||||
s1, e1 = 0, len(lines1) | ||||
s2, e2 = 0, len(lines2) | ||||
while s1 < e1 or s2 < e2: | ||||
|
r43347 | i1, i2, btype = s1, s2, b'=' | ||
|
r43346 | if i1 >= e1 or lines1[i1] == 0 or i2 >= e2 or lines2[i2] == 0: | ||
|
r15528 | # Consume the block of blank lines | ||
|
r43347 | btype = b'~' | ||
|
r15528 | while i1 < e1 and lines1[i1] == 0: | ||
i1 += 1 | ||||
while i2 < e2 and lines2[i2] == 0: | ||||
i2 += 1 | ||||
else: | ||||
# Consume the matching lines | ||||
while i1 < e1 and lines1[i1] == 1 and lines2[i2] == 1: | ||||
i1 += 1 | ||||
i2 += 1 | ||||
yield [base1 + s1, base1 + i1, base2 + s2, base2 + i2], btype | ||||
s1 = i1 | ||||
s2 = i2 | ||||
|
r43346 | |||
|
r31808 | def hunkinrange(hunk, linerange): | ||
"""Return True if `hunk` defined as (start, length) is in `linerange` | ||||
defined as (lowerbound, upperbound). | ||||
>>> hunkinrange((5, 10), (2, 7)) | ||||
True | ||||
>>> hunkinrange((5, 10), (6, 12)) | ||||
True | ||||
>>> hunkinrange((5, 10), (13, 17)) | ||||
True | ||||
>>> hunkinrange((5, 10), (3, 17)) | ||||
True | ||||
>>> hunkinrange((5, 10), (1, 3)) | ||||
False | ||||
>>> hunkinrange((5, 10), (18, 20)) | ||||
False | ||||
>>> hunkinrange((5, 10), (1, 5)) | ||||
False | ||||
>>> hunkinrange((5, 10), (15, 27)) | ||||
False | ||||
""" | ||||
start, length = hunk | ||||
lowerbound, upperbound = linerange | ||||
return lowerbound < start + length and start < upperbound | ||||
|
r43346 | |||
|
r30717 | def blocksinrange(blocks, rangeb): | ||
"""filter `blocks` like (a1, a2, b1, b2) from items outside line range | ||||
`rangeb` from ``(b1, b2)`` point of view. | ||||
Return `filteredblocks, rangea` where: | ||||
* `filteredblocks` is list of ``block = (a1, a2, b1, b2), stype`` items of | ||||
`blocks` that are inside `rangeb` from ``(b1, b2)`` point of view; a | ||||
block ``(b1, b2)`` being inside `rangeb` if | ||||
``rangeb[0] < b2 and b1 < rangeb[1]``; | ||||
* `rangea` is the line range w.r.t. to ``(a1, a2)`` parts of `blocks`. | ||||
""" | ||||
lbb, ubb = rangeb | ||||
lba, uba = None, None | ||||
filteredblocks = [] | ||||
for block in blocks: | ||||
(a1, a2, b1, b2), stype = block | ||||
|
r43347 | if lbb >= b1 and ubb <= b2 and stype == b'=': | ||
|
r30717 | # rangeb is within a single "=" hunk, restrict back linerange1 | ||
# by offsetting rangeb | ||||
lba = lbb - b1 + a1 | ||||
uba = ubb - b1 + a1 | ||||
else: | ||||
if b1 <= lbb < b2: | ||||
|
r43347 | if stype == b'=': | ||
|
r30717 | lba = a2 - (b2 - lbb) | ||
else: | ||||
lba = a1 | ||||
if b1 < ubb <= b2: | ||||
|
r43347 | if stype == b'=': | ||
|
r30717 | uba = a1 + (ubb - b1) | ||
else: | ||||
uba = a2 | ||||
|
r31808 | if hunkinrange((b1, (b2 - b1)), rangeb): | ||
|
r30717 | filteredblocks.append(block) | ||
if lba is None or uba is None or uba < lba: | ||||
|
r46485 | raise error.InputError(_(b'line range exceeds file size')) | ||
|
r30717 | return filteredblocks, (lba, uba) | ||
|
r43346 | |||
|
r36694 | def chooseblocksfunc(opts=None): | ||
|
r43346 | if ( | ||
opts is None | ||||
or not opts.xdiff | ||||
|
r43347 | or not util.safehasattr(bdiff, b'xdiffblocks') | ||
|
r43346 | ): | ||
|
r36694 | return bdiff.blocks | ||
else: | ||||
return bdiff.xdiffblocks | ||||
|
r43346 | |||
|
r30023 | def allblocks(text1, text2, opts=None, lines1=None, lines2=None): | ||
|
r15526 | """Return (block, type) tuples, where block is an mdiff.blocks | ||
line entry. type is '=' for blocks matching exactly one another | ||||
(bdiff blocks), '!' for non-matching blocks and '~' for blocks | ||||
|
r30023 | matching only after having filtered blank lines. | ||
|
r15526 | line1 and line2 are text1 and text2 split with splitnewlines() if | ||
they are already available. | ||||
|
r15525 | """ | ||
if opts is None: | ||||
opts = defaultopts | ||||
|
r34015 | if opts.ignorews or opts.ignorewsamount or opts.ignorewseol: | ||
|
r15525 | text1 = wsclean(opts, text1, False) | ||
text2 = wsclean(opts, text2, False) | ||||
|
r36694 | diff = chooseblocksfunc(opts)(text1, text2) | ||
|
r15525 | 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]] | ||||
# bdiff sometimes gives huge matches past eof, this check eats them, | ||||
# and deals with the special first match case described above | ||||
|
r15529 | if s[0] != s[1] or s[2] != s[3]: | ||
|
r43347 | type = b'!' | ||
|
r15526 | if opts.ignoreblanklines: | ||
|
r15529 | if lines1 is None: | ||
lines1 = splitnewlines(text1) | ||||
if lines2 is None: | ||||
lines2 = splitnewlines(text2) | ||||
|
r43347 | old = wsclean(opts, b"".join(lines1[s[0] : s[1]])) | ||
new = wsclean(opts, b"".join(lines2[s[2] : s[3]])) | ||||
|
r15529 | if old == new: | ||
|
r43347 | type = b'~' | ||
|
r15526 | yield s, type | ||
|
r43347 | yield s1, b'=' | ||
|
r15525 | |||
|
r43346 | |||
|
r35969 | def unidiff(a, ad, b, bd, fn1, fn2, binary, opts=defaultopts): | ||
|
r31273 | """Return a unified diff as a (headers, hunks) tuple. | ||
|
r31271 | |||
If the diff is not null, `headers` is a list with unified diff header | ||||
|
r31273 | lines "--- <original>" and "+++ <new>" and `hunks` is a generator yielding | ||
(hunkrange, hunklines) coming from _unidiff(). | ||||
Otherwise, `headers` and `hunks` are empty. | ||||
|
r35868 | |||
|
r35969 | Set binary=True if either a or b should be taken as a binary file. | ||
|
r31271 | """ | ||
|
r43346 | |||
|
r16362 | def datetag(date, fn=None): | ||
|
r4679 | if not opts.git and not opts.nodates: | ||
|
r43347 | return b'\t%s' % date | ||
if fn and b' ' in fn: | ||||
return b'\t' | ||||
return b'' | ||||
|
r3026 | |||
|
r31273 | sentinel = [], () | ||
|
r10282 | if not a and not b: | ||
|
r31271 | return sentinel | ||
|
r23299 | |||
if opts.noprefix: | ||||
|
r43347 | aprefix = bprefix = b'' | ||
|
r23299 | else: | ||
|
r43347 | aprefix = b'a/' | ||
bprefix = b'b/' | ||||
|
r23299 | |||
|
r36625 | epoch = dateutil.datestr((0, 0)) | ||
|
r264 | |||
|
r15437 | fn1 = util.pconvert(fn1) | ||
fn2 = util.pconvert(fn2) | ||||
|
r35969 | if binary: | ||
|
r6871 | if a and b and len(a) == len(b) and a == b: | ||
|
r31271 | return sentinel | ||
headerlines = [] | ||||
|
r43347 | hunks = ((None, [b'Binary file %s has changed\n' % fn1]),) | ||
|
r1723 | elif not a: | ||
|
r43347 | without_newline = not b.endswith(b'\n') | ||
|
r2251 | b = splitnewlines(b) | ||
|
r1723 | if a is None: | ||
|
r43347 | l1 = b'--- /dev/null%s' % datetag(epoch) | ||
|
r1723 | else: | ||
|
r43347 | l1 = b"--- %s%s%s" % (aprefix, fn1, datetag(ad, fn1)) | ||
l2 = b"+++ %s%s" % (bprefix + fn2, datetag(bd, fn2)) | ||||
|
r31271 | headerlines = [l1, l2] | ||
|
r31273 | size = len(b) | ||
hunkrange = (0, 0, 1, size) | ||||
|
r43347 | hunklines = [b"@@ -0,0 +1,%d @@\n" % size] + [b"+" + e for e in b] | ||
|
r35869 | if without_newline: | ||
|
r43347 | hunklines[-1] += b'\n' | ||
|
r45714 | hunklines.append(diffhelper.MISSING_NEWLINE_MARKER) | ||
|
r43346 | hunks = ((hunkrange, hunklines),) | ||
|
r1723 | elif not b: | ||
|
r43347 | without_newline = not a.endswith(b'\n') | ||
|
r2251 | a = splitnewlines(a) | ||
|
r43347 | l1 = b"--- %s%s%s" % (aprefix, fn1, datetag(ad, fn1)) | ||
|
r1723 | if b is None: | ||
|
r43347 | l2 = b'+++ /dev/null%s' % datetag(epoch) | ||
|
r1723 | else: | ||
|
r43347 | l2 = b"+++ %s%s%s" % (bprefix, fn2, datetag(bd, fn2)) | ||
|
r31271 | headerlines = [l1, l2] | ||
|
r31273 | size = len(a) | ||
hunkrange = (1, size, 0, 0) | ||||
|
r43347 | hunklines = [b"@@ -1,%d +0,0 @@\n" % size] + [b"-" + e for e in a] | ||
|
r35869 | if without_newline: | ||
|
r43347 | hunklines[-1] += b'\n' | ||
|
r45714 | hunklines.append(diffhelper.MISSING_NEWLINE_MARKER) | ||
|
r43346 | hunks = ((hunkrange, hunklines),) | ||
|
r264 | else: | ||
|
r35870 | hunks = _unidiff(a, b, opts=opts) | ||
if not next(hunks): | ||||
|
r31271 | return sentinel | ||
|
r10614 | |||
|
r31271 | headerlines = [ | ||
|
r43347 | b"--- %s%s%s" % (aprefix, fn1, datetag(ad, fn1)), | ||
b"+++ %s%s%s" % (bprefix, fn2, datetag(bd, fn2)), | ||||
|
r31271 | ] | ||
|
r31273 | |||
return headerlines, hunks | ||||
|
r0 | |||
|
r43346 | |||
|
r31267 | def _unidiff(t1, t2, opts=defaultopts): | ||
|
r31269 | """Yield hunks of a headerless unified diff from t1 and t2 texts. | ||
Each hunk consists of a (hunkrange, hunklines) tuple where `hunkrange` is a | ||||
tuple (s1, l1, s2, l2) representing the range information of the hunk to | ||||
form the '@@ -s1,l1 +s2,l2 @@' header and `hunklines` is a list of lines | ||||
of the hunk combining said header followed by line additions and | ||||
deletions. | ||||
|
r35869 | |||
The hunks are prefixed with a bool. | ||||
|
r31269 | """ | ||
|
r31267 | l1 = splitnewlines(t1) | ||
l2 = splitnewlines(t2) | ||||
|
r43346 | |||
|
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 | ||||
|
r43347 | lastfunc = [0, b''] | ||
|
r43346 | |||
|
r10614 | def yieldhunk(hunk): | ||
|
r1637 | (astart, a2, bstart, b2, delta) = hunk | ||
aend = contextend(a2, len(l1)) | ||||
alen = aend - astart | ||||
blen = b2 - bstart + aend - a2 | ||||
|
r43347 | func = b"" | ||
|
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. | ||||
|
r50179 | for i in range(astart - 1, lastpos - 1, -1): | ||
|
r35601 | if l1[i][0:1].isalnum(): | ||
|
r36432 | func = b' ' + l1[i].rstrip() | ||
# split long function name if ASCII. otherwise we have no | ||||
# idea where the multi-byte boundary is, so just leave it. | ||||
if encoding.isasciistr(func): | ||||
func = func[:41] | ||||
|
r15141 | 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 | ||||
|
r31269 | hunkrange = astart, alen, bstart, blen | ||
hunklines = ( | ||||
|
r43347 | [b"@@ -%d,%d +%d,%d @@%s\n" % (hunkrange + (func,))] | ||
|
r31269 | + delta | ||
|
r50179 | + [b' ' + l1[x] for x in range(a2, aend)] | ||
|
r31269 | ) | ||
|
r35869 | # If either file ends without a newline and the last line of | ||
# that file is part of a hunk, a marker is printed. If the | ||||
# last line of both files is identical and neither ends in | ||||
# a newline, print only one marker. That's the only case in | ||||
# which the hunk can end in a shared line without a newline. | ||||
skip = False | ||||
|
r43347 | if not t1.endswith(b'\n') and astart + alen == len(l1) + 1: | ||
|
r50179 | for i in range(len(hunklines) - 1, -1, -1): | ||
|
r43347 | if hunklines[i].startswith((b'-', b' ')): | ||
if hunklines[i].startswith(b' '): | ||||
|
r35869 | skip = True | ||
|
r43347 | hunklines[i] += b'\n' | ||
|
r45714 | hunklines.insert(i + 1, diffhelper.MISSING_NEWLINE_MARKER) | ||
|
r35869 | break | ||
|
r43347 | if not skip and not t2.endswith(b'\n') and bstart + blen == len(l2) + 1: | ||
|
r50179 | for i in range(len(hunklines) - 1, -1, -1): | ||
|
r43347 | if hunklines[i].startswith(b'+'): | ||
hunklines[i] += b'\n' | ||||
|
r45714 | hunklines.insert(i + 1, diffhelper.MISSING_NEWLINE_MARKER) | ||
|
r35869 | break | ||
|
r31269 | yield hunkrange, hunklines | ||
|
r1637 | |||
# 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 | ||||
|
r16089 | ignoredlines = 0 | ||
|
r35870 | has_hunks = False | ||
|
r15526 | for s, stype in allblocks(t1, t2, opts, l1, l2): | ||
|
r16089 | a1, a2, b1, b2 = s | ||
|
r43347 | if stype != b'!': | ||
if stype == b'~': | ||||
|
r16089 | # The diff context lines are based on t1 content. When | ||
# blank lines are ignored, the new lines offsets must | ||||
# be adjusted as if equivalent blocks ('~') had the | ||||
# same sizes on both sides. | ||||
ignoredlines += (b2 - b1) - (a2 - a1) | ||||
|
r15526 | continue | ||
|
r1637 | delta = [] | ||
old = l1[a1:a2] | ||||
new = l2[b1:b2] | ||||
|
r16089 | b1 -= ignoredlines | ||
b2 -= ignoredlines | ||||
|
r1637 | 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: | ||||
|
r35870 | if not has_hunks: | ||
has_hunks = True | ||||
yield True | ||||
|
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 | |||
|
r43347 | delta[len(delta) :] = [b' ' + x for x in l1[astart:a1]] | ||
delta[len(delta) :] = [b'-' + x for x in old] | ||||
delta[len(delta) :] = [b'+' + x for x in new] | ||||
|
r1637 | |||
if hunk: | ||||
|
r35870 | if not has_hunks: | ||
has_hunks = True | ||||
yield True | ||||
|
r10614 | for x in yieldhunk(hunk): | ||
|
r1637 | yield x | ||
|
r35870 | elif not has_hunks: | ||
yield False | ||||
|
r1637 | |||
|
r43346 | |||
|
r17939 | def b85diff(to, tn): | ||
'''print base85-encoded binary diff''' | ||||
|
r43346 | |||
|
r17939 | def fmtline(line): | ||
l = len(line) | ||||
if l <= 26: | ||||
|
r43347 | l = pycompat.bytechr(ord(b'A') + l - 1) | ||
|
r17939 | else: | ||
|
r43347 | l = pycompat.bytechr(l - 26 + ord(b'a') - 1) | ||
return b'%c%s\n' % (l, util.b85encode(line, True)) | ||||
|
r17939 | |||
def chunk(text, csize=52): | ||||
l = len(text) | ||||
i = 0 | ||||
while i < l: | ||||
|
r43346 | yield text[i : i + csize] | ||
|
r17939 | i += csize | ||
|
r17946 | if to is None: | ||
|
r43347 | to = b'' | ||
|
r17946 | if tn is None: | ||
|
r43347 | tn = b'' | ||
|
r17946 | |||
if to == tn: | ||||
|
r43347 | return b'' | ||
|
r17939 | |||
# TODO: deltas | ||||
|
r17946 | ret = [] | ||
|
r43347 | ret.append(b'GIT binary patch\n') | ||
ret.append(b'literal %d\n' % len(tn)) | ||||
|
r17939 | for l in chunk(zlib.compress(tn)): | ||
ret.append(fmtline(l)) | ||||
|
r43347 | ret.append(b'\n') | ||
|
r17946 | |||
|
r43347 | return b''.join(ret) | ||
|
r17939 | |||
|
r43346 | |||
|
r120 | def patchtext(bin): | ||
pos = 0 | ||||
t = [] | ||||
while pos < len(bin): | ||||
|
r43347 | p1, p2, l = struct.unpack(b">lll", bin[pos : pos + 12]) | ||
|
r120 | pos += 12 | ||
|
r43346 | t.append(bin[pos : pos + l]) | ||
|
r120 | pos += l | ||
|
r43347 | return b"".join(t) | ||
|
r120 | |||
|
r43346 | |||
|
r0 | def patch(a, bin): | ||
|
r12025 | if len(a) == 0: | ||
# skip over trivial delta header | ||||
|
r15657 | return util.buffer(bin, 12) | ||
|
r1379 | return mpatch.patches(a, [bin]) | ||
|
r432 | |||
|
r43346 | |||
|
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)] | ||||
|
r43346 | |||
|
r5367 | def trivialdiffheader(length): | ||
|
r43347 | return struct.pack(b">lll", 0, 0, length) if length else b'' | ||
|
r5367 | |||
|
r43346 | |||
|
r24119 | def replacediffheader(oldlen, newlen): | ||
|
r43347 | return struct.pack(b">lll", 0, oldlen, newlen) | ||