mercurial-scm/hg: mercurial/patch.py comparison

comparison mercurial/patch.py @ 37732:35632d392279

patch: implement a new worddiff algorithm The previous worddiff algorithm has many problems. The major problem is it does a "similarity check" that selects a subset of matched lines to do inline diffs. It is a bad idea because: - The "similarity check" is non-obvious to users. For example, a simple change from "long long x" to "int64_t x" will fail the similarity check and won't be diff-ed as expected. - Selecting "lines" to diff won't work as people expect if there are line wrapping changes. - It has a sad time complexity if lines do not match, could be O(N^2)-ish. There are other problems in implementation details. - Lines can match across distant hunks (if the next hunk does not have "-" lines). - "difflib" is slow. The solution would be removing the "similarity check", and just diff all words in a same hunk. So no content will be missed and everything will be diff-ed as expected. This is similar to what code review tool like Phabricator does. This diff implements the word diff algorithm as described above. It also avoids difflib to be faster. Note about colors: To be consistent, "changed inserted" parts and "purely insertion blocks" should have a same color, since they do not exist in the previous version. Instead of highlighting differences, this patch chooses to dim common parts. This is also more consistent with Phabricator or GitHub webpage. That said, the labels are defined in a way that people can still highlight changed parts and leave purely inserted/deleted hunks use the "non-highlighted" color. As one example, running: hg log -pr df50b87d8f736aff8dc281f816bddcd6f306930c mercurial/commands.py \ --config experimental.worddiff=1 --color=debug --config diff.unified=0 The previous algorithm outputs: [diff.file_a|--- a/mercurial/commands.py Fri Mar 09 15:53:41 2018 +0100] [diff.file_b|+++ b/mercurial/commands.py Sat Mar 10 12:33:19 2018 +0530] [diff.hunk|@@ -2039,1 +2039,4 @@] [diff.deleted|-][diff.deleted.highlight|@command('^forget',][diff.deleted| ][diff.deleted.highlight|walkopts,][diff.deleted| _('[OPTION]... FILE...'), inferrepo=True)] [diff.inserted|+@command(] [diff.inserted|+ '^forget',] [diff.inserted|+ walkopts + dryrunopts,] [diff.inserted|+ ][diff.inserted.highlight| ][diff.inserted| _('[OPTION]... FILE...'), inferrepo=True)] [diff.hunk|@@ -2074,1 +2077,3 @@] [diff.deleted|- rejected = cmdutil.forget(ui, repo, m, prefix="",][diff.deleted.highlight| explicitonly=False)[0]] [diff.inserted|+ dryrun = opts.get(r'dry_run')] [diff.inserted|+ rejected = cmdutil.forget(ui, repo, m, prefix="",] [diff.inserted|+ explicitonly=False, dryrun=dryrun)[0]] The new algorithm outputs: [diff.file_a|--- a/mercurial/commands.py Fri Mar 09 15:53:41 2018 +0100] [diff.file_b|+++ b/mercurial/commands.py Sat Mar 10 12:33:19 2018 +0530] [diff.hunk|@@ -2039,1 +2039,4 @@] [diff.deleted|-][diff.deleted.unchanged|@command(][diff.deleted.unchanged|'^forget',][diff.deleted.unchanged| ][diff.deleted.changed|walkopts][diff.deleted.unchanged|,][diff.deleted.changed| ][diff.deleted.unchanged|_('[OPTION]... FILE...'), inferrepo=True)] [diff.inserted|+][diff.inserted.unchanged|@command(] [diff.inserted|+][diff.inserted.changed| ][diff.inserted.unchanged|'^forget',] [diff.inserted|+][diff.inserted.changed| walkopts][diff.inserted.unchanged| ][diff.inserted.changed|+ dryrunopts][diff.inserted.unchanged|,] [diff.inserted|+][diff.inserted.changed| ][diff.inserted.unchanged|_('[OPTION]... FILE...'), inferrepo=True)] [diff.hunk|@@ -2074,1 +2077,3 @@] [diff.deleted|-][diff.deleted.unchanged| rejected = cmdutil.forget(ui, repo, m, prefix="",][diff.deleted.changed| ][diff.deleted.unchanged|explicitonly=False][diff.deleted.unchanged|)[0]] [diff.inserted|+][diff.inserted.changed| dryrun = opts.get(r'dry_run')] [diff.inserted|+][diff.inserted.unchanged| rejected = cmdutil.forget(ui, repo, m, prefix="",] [diff.inserted|+][diff.inserted.changed| ][diff.inserted.unchanged|explicitonly=False][diff.inserted.changed|, dryrun=dryrun][diff.inserted.unchanged|)[0]] Practically, when diffing a 8k line change, the time spent on worddiff reduces from 4 seconds to 0.14 seconds. Differential Revision: https://phab.mercurial-scm.org/D3212

author	Jun Wu <quark@fb.com>
date	Mon, 09 Apr 2018 15:58:30 -0700
parents	5471348921c1
children	5e67c20915a7

comparison

equal deleted inserted replaced

-:5471348921c1
+:35632d392279
 stringio = util.stringio
 gitre = re.compile(br'diff --git a/(.*) b/(.*)')
 tabsplitter = re.compile(br'(\t+|[^\t]+)')
-_nonwordre = re.compile(br'([^a-zA-Z0-9_\x80-\xff])')
+wordsplitter = re.compile(br'(\t+| +|[a-zA-Z0-9_\x80-\xff]+|'
+'[^ \ta-zA-Z0-9_\x80-\xff])')
 PatchError = error.PatchError
 # public functions
 if chompline != stripline:
 yield (chompline[len(stripline):], 'diff.trailingwhitespace')
 if chompline != line:
 yield (line[len(chompline):], '')
+def diffsinglehunkinline(hunklines):
+"""yield tokens for a list of lines in a single hunk, with inline colors"""
+# prepare deleted, and inserted content
+a = ''
+b = ''
+for line in hunklines:
+if line[0] == '-':
+a += line[1:]
+elif line[0] == '+':
+b += line[1:]
+else:
+raise error.ProgrammingError('unexpected hunk line: %s' % line)
+# fast path: if either side is empty, use diffsinglehunk
+if not a or not b:
+for t in diffsinglehunk(hunklines):
+yield t
+return
+# re-split the content into words
+al = wordsplitter.findall(a)
+bl = wordsplitter.findall(b)
+# re-arrange the words to lines since the diff algorithm is line-based
+aln = [s if s == '\n' else s + '\n' for s in al]
+bln = [s if s == '\n' else s + '\n' for s in bl]
+an = ''.join(aln)
+bn = ''.join(bln)
+# run the diff algorithm, prepare atokens and btokens
+atokens = []
+btokens = []
+blocks = mdiff.allblocks(an, bn, lines1=aln, lines2=bln)
+for (a1, a2, b1, b2), btype in blocks:
+changed = btype == '!'
+for token in mdiff.splitnewlines(''.join(al[a1:a2])):
+atokens.append((changed, token))
+for token in mdiff.splitnewlines(''.join(bl[b1:b2])):
+btokens.append((changed, token))
+# yield deleted tokens, then inserted ones
+for prefix, label, tokens in [('-', 'diff.deleted', atokens),
+('+', 'diff.inserted', btokens)]:
+nextisnewline = True
+for changed, token in tokens:
+if nextisnewline:
+yield (prefix, label)
+nextisnewline = False
+# special handling line end
+isendofline = token.endswith('\n')
+if isendofline:
+chomp = token[:-1] # chomp
+token = chomp.rstrip() # detect spaces at the end
+endspaces = chomp[len(token):]
+# scan tabs
+for maybetab in tabsplitter.findall(token):
+if '\t' == maybetab[0]:
+currentlabel = 'diff.tab'
+else:
+if changed:
+currentlabel = label + '.changed'
+else:
+currentlabel = label + '.unchanged'
+yield (maybetab, currentlabel)
+if isendofline:
+if endspaces:
+yield (endspaces, 'diff.trailingwhitespace')
+yield ('\n', '')
+nextisnewline = True
 def difflabel(func, *args, **kw):
 '''yields 2-tuples of (output, label) based on the output of func()'''
+if kw.get(r'opts') and kw[r'opts'].worddiff:
+dodiffhunk = diffsinglehunkinline
+else:
+dodiffhunk = diffsinglehunk
 headprefixes = [('diff', 'diff.diffline'),
 ('copy', 'diff.extended'),
 ('rename', 'diff.extended'),
 ('old', 'diff.extended'),
 ('new', 'diff.extended'),
 # buffers a hunk, i.e. adjacent "-", "+" lines without other changes.
 hunkbuffer = []
 def consumehunkbuffer():
 if hunkbuffer:
-for token in diffsinglehunk(hunkbuffer):
+for token in dodiffhunk(hunkbuffer):
 yield token
 hunkbuffer[:] = []
 for chunk in func(*args, **kw):
 lines = chunk.split('\n')

Mercurial > public > mercurial-scm > hg

comparison mercurial/patch.py @ 37732:35632d392279