This is an archive of the discontinued Mercurial Phabricator instance.

Differential D1941

mdiff: explicitly compute places for the newline marker
ClosedPublic

Authored by joerg.sonnenberger on Jan 25 2018, 8:35 PM.

Details

Reviewers
None
Group Reviewers
hg-reviewers
Commits
rHGa9d07bd8f758: mdiff: explicitly compute places for the newline marker

Diff Detail

Repository
rHG Mercurial
Lint
Lint Skipped
Unit
Unit Tests Skipped

Event Timeline

joerg.sonnenberger added a comment.Jan 25 2018, 8:36 PM

I don't completely trust my numbers here, but it seems to give at least 3-4% for diffing netbsd-7 and netbsd-8.

durin42 added a subscriber: durin42.Jan 26 2018, 12:00 AM

3-4% is in line with what I'm seeing with ./hg perfunidiff mercurial/manifest.py 0 --count 500 --profile, and this looks like a better fix than what I've got. I'm a little weirded out by the change in interface where _unidiff yields a bool and then a sequence of hunks - was that needed for the change to work? I'm having trouble telling.

joerg.sonnenberger added a comment.Jan 26 2018, 5:53 AM

No, the change to yield a bool first is not strictly necessary for the rest of the logic. But it cheaply kills the need for the rewindhunk generator, i.e. it cuts a layer of indirection cheaply.

durin42 added a comment.Jan 26 2018, 10:13 AM

I'd slightly prefer this as two patches: one that does away with the rewindhunks goo (yay!), and then one that does the book-keeping to intelligently emit the "no newline" business. Can you tackle that?

Closed by commit rHGa9d07bd8f758: mdiff: explicitly compute places for the newline marker (authored by joerg.sonnenberger). · Explain WhyFeb 1 2018, 4:47 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

PathPackages
Mmercurial/mdiff.py (63 lines)

Diff 5007

mercurial/mdiff.py

from .i18n import _ from .i18n import _
from . import ( from . import (
error, error,
policy, policy,
pycompat, pycompat,
util, util,
) )
_missing_newline_marker = "\\ No newline at end of file\n"
bdiff = policy.importmod(r'bdiff') bdiff = policy.importmod(r'bdiff')
mpatch = policy.importmod(r'mpatch') mpatch = policy.importmod(r'mpatch')
blocks = bdiff.blocks blocks = bdiff.blocks
fixws = bdiff.fixws fixws = bdiff.fixws
patches = mpatch.patches patches = mpatch.patches
patchedsize = mpatch.patchedsize patchedsize = mpatch.patchedsize
textdiff = bdiff.bdiff textdiff = bdiff.bdiff
aprefix = 'a/' aprefix = 'a/'
bprefix = 'b/' bprefix = 'b/'
epoch = util.datestr((0, 0)) epoch = util.datestr((0, 0))
fn1 = util.pconvert(fn1) fn1 = util.pconvert(fn1)
fn2 = util.pconvert(fn2) fn2 = util.pconvert(fn2)
def checknonewline(lines):
for text in lines:
if text[-1:] != '\n':
text += "\n\ No newline at end of file\n"
yield text
if not opts.text and check_binary and (util.binary(a) or util.binary(b)): if not opts.text and check_binary and (util.binary(a) or util.binary(b)):
if a and b and len(a) == len(b) and a == b: if a and b and len(a) == len(b) and a == b:
return sentinel return sentinel
headerlines = [] headerlines = []
hunks = (None, ['Binary file %s has changed\n' % fn1]), hunks = (None, ['Binary file %s has changed\n' % fn1]),
elif not a: elif not a:
without_newline = b[-1] != '\n'
b = splitnewlines(b) b = splitnewlines(b)
if a is None: if a is None:
l1 = '--- /dev/null%s' % datetag(epoch) l1 = '--- /dev/null%s' % datetag(epoch)
else: else:
l1 = "--- %s%s%s" % (aprefix, fn1, datetag(ad, fn1)) l1 = "--- %s%s%s" % (aprefix, fn1, datetag(ad, fn1))
l2 = "+++ %s%s" % (bprefix + fn2, datetag(bd, fn2)) l2 = "+++ %s%s" % (bprefix + fn2, datetag(bd, fn2))
headerlines = [l1, l2] headerlines = [l1, l2]
size = len(b) size = len(b)
hunkrange = (0, 0, 1, size) hunkrange = (0, 0, 1, size)
hunklines = ["@@ -0,0 +1,%d @@\n" % size] + ["+" + e for e in b] hunklines = ["@@ -0,0 +1,%d @@\n" % size] + ["+" + e for e in b]
hunks = (hunkrange, checknonewline(hunklines)), if without_newline:
hunklines[-1] += '\n'
hunklines.append(_missing_newline_marker)
hunks = (hunkrange, hunklines),
elif not b: elif not b:
without_newline = a[-1] != '\n'
a = splitnewlines(a) a = splitnewlines(a)
l1 = "--- %s%s%s" % (aprefix, fn1, datetag(ad, fn1)) l1 = "--- %s%s%s" % (aprefix, fn1, datetag(ad, fn1))
if b is None: if b is None:
l2 = '+++ /dev/null%s' % datetag(epoch) l2 = '+++ /dev/null%s' % datetag(epoch)
else: else:
l2 = "+++ %s%s%s" % (bprefix, fn2, datetag(bd, fn2)) l2 = "+++ %s%s%s" % (bprefix, fn2, datetag(bd, fn2))
headerlines = [l1, l2] headerlines = [l1, l2]
size = len(a) size = len(a)
hunkrange = (1, size, 0, 0) hunkrange = (1, size, 0, 0)
hunklines = ["@@ -1,%d +0,0 @@\n" % size] + ["-" + e for e in a] hunklines = ["@@ -1,%d +0,0 @@\n" % size] + ["-" + e for e in a]
hunks = (hunkrange, checknonewline(hunklines)), if without_newline:
hunklines[-1] += '\n'
hunklines.append(_missing_newline_marker)
hunks = (hunkrange, hunklines),
else: else:
diffhunks = _unidiff(a, b, opts=opts) hunks = _unidiff(a, b, opts=opts)
try: if not next(hunks):
hunkrange, hunklines = next(diffhunks)
except StopIteration:
return sentinel return sentinel
headerlines = [ headerlines = [
"--- %s%s%s" % (aprefix, fn1, datetag(ad, fn1)), "--- %s%s%s" % (aprefix, fn1, datetag(ad, fn1)),
"+++ %s%s%s" % (bprefix, fn2, datetag(bd, fn2)), "+++ %s%s%s" % (bprefix, fn2, datetag(bd, fn2)),
] ]
def rewindhunks():
yield hunkrange, checknonewline(hunklines)
for hr, hl in diffhunks:
yield hr, checknonewline(hl)
hunks = rewindhunks()
return headerlines, hunks return headerlines, hunks
def _unidiff(t1, t2, opts=defaultopts): def _unidiff(t1, t2, opts=defaultopts):
"""Yield hunks of a headerless unified diff from t1 and t2 texts. """Yield hunks of a headerless unified diff from t1 and t2 texts.
Each hunk consists of a (hunkrange, hunklines) tuple where `hunkrange` is a 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 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 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 of the hunk combining said header followed by line additions and
deletions. deletions.
The hunks are prefixed with a bool.
""" """
l1 = splitnewlines(t1) l1 = splitnewlines(t1)
l2 = splitnewlines(t2) l2 = splitnewlines(t2)
def contextend(l, len): def contextend(l, len):
ret = l + opts.context ret = l + opts.context
if ret > len: if ret > len:
ret = len ret = len
return ret return ret
bstart += 1 bstart += 1
hunkrange = astart, alen, bstart, blen hunkrange = astart, alen, bstart, blen
hunklines = ( hunklines = (
["@@ -%d,%d +%d,%d @@%s\n" % (hunkrange + (func,))] ["@@ -%d,%d +%d,%d @@%s\n" % (hunkrange + (func,))]
+ delta + delta
+ [' ' + l1[x] for x in xrange(a2, aend)] + [' ' + l1[x] for x in xrange(a2, aend)]
) )
# 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
if t1[-1] != '\n' and astart + alen == len(l1) + 1:
for i in xrange(len(hunklines) - 1, -1, -1):
if hunklines[i][0] in ('-', ' '):
if hunklines[i][0] == ' ':
skip = True
hunklines[i] += '\n'
hunklines.insert(i + 1, _missing_newline_marker)
break
if not skip and t2[-1] != '\n' and bstart + blen == len(l2) + 1:
for i in xrange(len(hunklines) - 1, -1, -1):
if hunklines[i][0] == '+':
hunklines[i] += '\n'
hunklines.insert(i + 1, _missing_newline_marker)
break
yield hunkrange, hunklines yield hunkrange, hunklines
# bdiff.blocks gives us the matching sequences in the files. The loop # bdiff.blocks gives us the matching sequences in the files. The loop
# below finds the spaces between those matching sequences and translates # below finds the spaces between those matching sequences and translates
# them into diff output. # them into diff output.
# #
hunk = None hunk = None
ignoredlines = 0 ignoredlines = 0
has_hunks = False
for s, stype in allblocks(t1, t2, opts, l1, l2): for s, stype in allblocks(t1, t2, opts, l1, l2):
a1, a2, b1, b2 = s a1, a2, b1, b2 = s
if stype != '!': if stype != '!':
if stype == '~': if stype == '~':
# The diff context lines are based on t1 content. When # The diff context lines are based on t1 content. When
# blank lines are ignored, the new lines offsets must # blank lines are ignored, the new lines offsets must
# be adjusted as if equivalent blocks ('~') had the # be adjusted as if equivalent blocks ('~') had the
# same sizes on both sides. # same sizes on both sides.
prev = None prev = None
if hunk: if hunk:
# join with the previous hunk if it falls inside the context # join with the previous hunk if it falls inside the context
if astart < hunk[1] + opts.context + 1: if astart < hunk[1] + opts.context + 1:
prev = hunk prev = hunk
astart = hunk[1] astart = hunk[1]
bstart = hunk[3] bstart = hunk[3]
else: else:
if not has_hunks:
has_hunks = True
yield True
for x in yieldhunk(hunk): for x in yieldhunk(hunk):
yield x yield x
if prev: if prev:
# we've joined the previous hunk, record the new ending points. # we've joined the previous hunk, record the new ending points.
hunk[1] = a2 hunk[1] = a2
hunk[3] = b2 hunk[3] = b2
delta = hunk[4] delta = hunk[4]
else: else:
# create a new hunk # create a new hunk
hunk = [astart, a2, bstart, b2, delta] hunk = [astart, a2, bstart, b2, delta]
delta[len(delta):] = [' ' + x for x in l1[astart:a1]] 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 old]
delta[len(delta):] = ['+' + x for x in new] delta[len(delta):] = ['+' + x for x in new]
if hunk: if hunk:
if not has_hunks:
has_hunks = True
yield True
for x in yieldhunk(hunk): for x in yieldhunk(hunk):
yield x yield x
elif not has_hunks:
yield False
def b85diff(to, tn): def b85diff(to, tn):
'''print base85-encoded binary diff''' '''print base85-encoded binary diff'''
def fmtline(line): def fmtline(line):
l = len(line) l = len(line)
if l <= 26: if l <= 26:
l = chr(ord('A') + l - 1) l = chr(ord('A') + l - 1)
else: else: