patch.py
2914 lines
| 99.9 KiB
| text/x-python
|
PythonLexer
/ mercurial / patch.py
|
r2861 | # patch.py - patch file parsing routines | ||
# | ||||
|
r2865 | # Copyright 2006 Brendan Cully <brendan@kublai.com> | ||
|
r4897 | # Copyright 2007 Chris Mason <chris.mason@oracle.com> | ||
|
r2865 | # | ||
|
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. | ||
|
r2861 | |||
|
r34139 | from __future__ import absolute_import, print_function | ||
|
r27485 | |||
|
r25113 | import collections | ||
|
r27485 | import copy | ||
|
r35278 | import difflib | ||
|
r27485 | import email | ||
import errno | ||||
|
r29341 | import hashlib | ||
|
r27485 | import os | ||
import posixpath | ||||
import re | ||||
import shutil | ||||
import tempfile | ||||
import zlib | ||||
|
r10965 | |||
|
r27485 | from .i18n import _ | ||
from .node import ( | ||||
hex, | ||||
short, | ||||
) | ||||
from . import ( | ||||
copies, | ||||
encoding, | ||||
error, | ||||
|
r28341 | mail, | ||
|
r27485 | mdiff, | ||
pathutil, | ||||
|
r32370 | policy, | ||
|
r30924 | pycompat, | ||
|
r27485 | scmutil, | ||
|
r30807 | similar, | ||
|
r27485 | util, | ||
|
r31233 | vfs as vfsmod, | ||
|
r27485 | ) | ||
|
r37102 | from .utils import ( | ||
dateutil, | ||||
|
r37138 | procutil, | ||
|
r37102 | stringutil, | ||
) | ||||
|
r32370 | |||
diffhelpers = policy.importmod(r'diffhelpers') | ||||
|
r28861 | stringio = util.stringio | ||
|
r2866 | |||
|
r31630 | gitre = re.compile(br'diff --git a/(.*) b/(.*)') | ||
tabsplitter = re.compile(br'(\t+|[^\t]+)') | ||||
|
r35384 | _nonwordre = re.compile(br'([^a-zA-Z0-9_\x80-\xff])') | ||
|
r7199 | |||
|
r34252 | PatchError = error.PatchError | ||
|
r2933 | |||
# public functions | ||||
|
r10384 | def split(stream): | ||
'''return an iterator of individual patches from a stream''' | ||||
def isheader(line, inheader): | ||||
|
r37489 | if inheader and line.startswith((' ', '\t')): | ||
|
r10384 | # continuation | ||
return True | ||||
|
r37489 | if line.startswith((' ', '-', '+')): | ||
|
r10883 | # diff line - don't check for header pattern in there | ||
return False | ||||
|
r10384 | l = line.split(': ', 1) | ||
return len(l) == 2 and ' ' not in l[0] | ||||
def chunk(lines): | ||||
|
r28861 | return stringio(''.join(lines)) | ||
|
r10384 | |||
def hgsplit(stream, cur): | ||||
inheader = True | ||||
for line in stream: | ||||
if not line.strip(): | ||||
inheader = False | ||||
if not inheader and line.startswith('# HG changeset patch'): | ||||
yield chunk(cur) | ||||
cur = [] | ||||
inheader = True | ||||
cur.append(line) | ||||
if cur: | ||||
yield chunk(cur) | ||||
def mboxsplit(stream, cur): | ||||
for line in stream: | ||||
if line.startswith('From '): | ||||
for c in split(chunk(cur[1:])): | ||||
yield c | ||||
cur = [] | ||||
cur.append(line) | ||||
if cur: | ||||
for c in split(chunk(cur[1:])): | ||||
yield c | ||||
def mimesplit(stream, cur): | ||||
def msgfp(m): | ||||
|
r28861 | fp = stringio() | ||
|
r10384 | g = email.Generator.Generator(fp, mangle_from_=False) | ||
g.flatten(m) | ||||
fp.seek(0) | ||||
return fp | ||||
for line in stream: | ||||
cur.append(line) | ||||
c = chunk(cur) | ||||
|
r36062 | m = pycompat.emailparser().parse(c) | ||
|
r10384 | if not m.is_multipart(): | ||
yield msgfp(m) | ||||
else: | ||||
ok_types = ('text/plain', 'text/x-diff', 'text/x-patch') | ||||
for part in m.walk(): | ||||
ct = part.get_content_type() | ||||
if ct not in ok_types: | ||||
continue | ||||
yield msgfp(part) | ||||
def headersplit(stream, cur): | ||||
inheader = False | ||||
for line in stream: | ||||
if not inheader and isheader(line, inheader): | ||||
yield chunk(cur) | ||||
cur = [] | ||||
inheader = True | ||||
if inheader and not isheader(line, inheader): | ||||
inheader = False | ||||
cur.append(line) | ||||
if cur: | ||||
yield chunk(cur) | ||||
def remainder(cur): | ||||
yield chunk(cur) | ||||
class fiter(object): | ||||
def __init__(self, fp): | ||||
self.fp = fp | ||||
def __iter__(self): | ||||
return self | ||||
def next(self): | ||||
l = self.fp.readline() | ||||
if not l: | ||||
raise StopIteration | ||||
return l | ||||
|
r35192 | __next__ = next | ||
|
r10384 | inheader = False | ||
cur = [] | ||||
mimeheaders = ['content-type'] | ||||
|
r14966 | if not util.safehasattr(stream, 'next'): | ||
|
r10384 | # http responses, for example, have readline but not next | ||
stream = fiter(stream) | ||||
for line in stream: | ||||
cur.append(line) | ||||
if line.startswith('# HG changeset patch'): | ||||
return hgsplit(stream, cur) | ||||
elif line.startswith('From '): | ||||
return mboxsplit(stream, cur) | ||||
elif isheader(line, inheader): | ||||
inheader = True | ||||
if line.split(':', 1)[0].lower() in mimeheaders: | ||||
# let email parser handle this | ||||
return mimesplit(stream, cur) | ||||
|
r10501 | elif line.startswith('--- ') and inheader: | ||
# No evil headers seen by diff start, split by hand | ||||
|
r10384 | return headersplit(stream, cur) | ||
# Not enough info, keep reading | ||||
# if we are here, we have a very plain patch | ||||
return remainder(cur) | ||||
|
r26557 | ## Some facility for extensible patch parsing: | ||
# list of pairs ("header to match", "data key") | ||||
|
r26559 | patchheadermap = [('Date', 'date'), | ||
('Branch', 'branch'), | ||||
|
r26560 | ('Node ID', 'nodeid'), | ||
|
r26559 | ] | ||
|
r26557 | |||
|
r2866 | def extract(ui, fileobj): | ||
'''extract patch from data read from fileobj. | ||||
|
r4263 | patch can be a normal patch or contained in an email message. | ||
|
r2866 | |||
|
r26781 | return a dictionary. Standard keys are: | ||
|
r26547 | - filename, | ||
- message, | ||||
- user, | ||||
- date, | ||||
- branch, | ||||
- node, | ||||
- p1, | ||||
- p2. | ||||
|
r26781 | Any item can be missing from the dictionary. If filename is missing, | ||
|
r4263 | fileobj did not contain a patch. Caller must unlink filename when done.''' | ||
|
r2866 | |||
# attempt to detect the start of a patch | ||||
# (this heuristic is borrowed from quilt) | ||||
|
r34965 | diffre = re.compile(br'^(?:Index:[ \t]|diff[ \t]-|RCS file: |' | ||
|
r34068 | br'retrieving revision [0-9]+(\.[0-9]+)*$|' | ||
br'---[ \t].*?^\+\+\+[ \t]|' | ||||
br'\*\*\*[ \t].*?^---[ \t])', | ||||
re.MULTILINE | re.DOTALL) | ||||
|
r2866 | |||
|
r26547 | data = {} | ||
|
r2866 | fd, tmpname = tempfile.mkstemp(prefix='hg-patch-') | ||
|
r36853 | tmpfp = os.fdopen(fd, r'wb') | ||
|
r2866 | try: | ||
|
r36062 | msg = pycompat.emailparser().parse(fileobj) | ||
|
r2866 | |||
|
r37486 | subject = msg[r'Subject'] and mail.headdecode(msg[r'Subject']) | ||
data['user'] = msg[r'From'] and mail.headdecode(msg[r'From']) | ||||
|
r26556 | if not subject and not data['user']: | ||
|
r9573 | # Not an email, restore parsed headers if any | ||
|
r37474 | subject = '\n'.join(': '.join(map(encoding.strtolocal, h)) | ||
for h in msg.items()) + '\n' | ||||
|
r9573 | |||
|
r2866 | # should try to parse msg['Date'] | ||
|
r4263 | parents = [] | ||
|
r2866 | |||
|
r4777 | if subject: | ||
if subject.startswith('[PATCH'): | ||||
pend = subject.find(']') | ||||
|
r4208 | if pend >= 0: | ||
|
r10282 | subject = subject[pend + 1:].lstrip() | ||
|
r34068 | subject = re.sub(br'\n[ \t]+', ' ', subject) | ||
|
r4777 | ui.debug('Subject: %s\n' % subject) | ||
|
r26556 | if data['user']: | ||
ui.debug('From: %s\n' % data['user']) | ||||
|
r2866 | diffs_seen = 0 | ||
ok_types = ('text/plain', 'text/x-diff', 'text/x-patch') | ||||
|
r4900 | message = '' | ||
|
r2866 | for part in msg.walk(): | ||
|
r36052 | content_type = pycompat.bytestr(part.get_content_type()) | ||
|
r2866 | ui.debug('Content-Type: %s\n' % content_type) | ||
if content_type not in ok_types: | ||||
continue | ||||
payload = part.get_payload(decode=True) | ||||
m = diffre.search(payload) | ||||
if m: | ||||
|
r4220 | hgpatch = False | ||
|
r12645 | hgpatchheader = False | ||
|
r4220 | ignoretext = False | ||
|
r9467 | ui.debug('found patch at byte %d\n' % m.start(0)) | ||
|
r2866 | diffs_seen += 1 | ||
|
r28861 | cfp = stringio() | ||
|
r2866 | for line in payload[:m.start(0)].splitlines(): | ||
|
r12728 | if line.startswith('# HG changeset patch') and not hgpatch: | ||
|
r9467 | ui.debug('patch generated by hg export\n') | ||
|
r12728 | hgpatch = True | ||
|
r12645 | hgpatchheader = True | ||
|
r2866 | # drop earlier commit message content | ||
cfp.seek(0) | ||||
cfp.truncate() | ||||
|
r4778 | subject = None | ||
|
r12645 | elif hgpatchheader: | ||
|
r2866 | if line.startswith('# User '): | ||
|
r26556 | data['user'] = line[7:] | ||
ui.debug('From: %s\n' % data['user']) | ||||
|
r4263 | elif line.startswith("# Parent "): | ||
|
r16475 | parents.append(line[9:].lstrip()) | ||
|
r26557 | elif line.startswith("# "): | ||
for header, key in patchheadermap: | ||||
prefix = '# %s ' % header | ||||
if line.startswith(prefix): | ||||
data[key] = line[len(prefix):] | ||||
else: | ||||
|
r12645 | hgpatchheader = False | ||
|
r19513 | elif line == '---': | ||
|
r4220 | ignoretext = True | ||
|
r12645 | if not hgpatchheader and not ignoretext: | ||
|
r2866 | cfp.write(line) | ||
cfp.write('\n') | ||||
message = cfp.getvalue() | ||||
if tmpfp: | ||||
tmpfp.write(payload) | ||||
if not payload.endswith('\n'): | ||||
tmpfp.write('\n') | ||||
elif not diffs_seen and message and content_type == 'text/plain': | ||||
message += '\n' + payload | ||||
|
r16705 | except: # re-raises | ||
|
r2866 | tmpfp.close() | ||
os.unlink(tmpname) | ||||
raise | ||||
|
r4777 | if subject and not message.startswith(subject): | ||
message = '%s\n%s' % (subject, message) | ||||
|
r26549 | data['message'] = message | ||
|
r2866 | tmpfp.close() | ||
|
r24306 | if parents: | ||
|
r26550 | data['p1'] = parents.pop(0) | ||
|
r26548 | if parents: | ||
|
r26550 | data['p2'] = parents.pop(0) | ||
|
r24306 | |||
|
r26555 | if diffs_seen: | ||
data['filename'] = tmpname | ||||
else: | ||||
os.unlink(tmpname) | ||||
|
r26547 | return data | ||
|
r2861 | |||
|
r8778 | class patchmeta(object): | ||
|
r7148 | """Patched file metadata | ||
'op' is the performed operation within ADD, DELETE, RENAME, MODIFY | ||||
or COPY. 'path' is patched file path. 'oldpath' is set to the | ||||
|
r7149 | origin file when 'op' is either COPY or RENAME, None otherwise. If | ||
file mode is changed, 'mode' is a tuple (islink, isexec) where | ||||
'islink' is True if the file is a symlink and 'isexec' is True if | ||||
the file is executable. Otherwise, 'mode' is None. | ||||
|
r7148 | """ | ||
def __init__(self, path): | ||||
self.path = path | ||||
self.oldpath = None | ||||
self.mode = None | ||||
self.op = 'MODIFY' | ||||
self.binary = False | ||||
|
r7149 | def setmode(self, mode): | ||
|
r25658 | islink = mode & 0o20000 | ||
isexec = mode & 0o100 | ||||
|
r7149 | self.mode = (islink, isexec) | ||
|
r14566 | def copy(self): | ||
other = patchmeta(self.path) | ||||
other.oldpath = self.oldpath | ||||
other.mode = self.mode | ||||
other.op = self.op | ||||
other.binary = self.binary | ||||
return other | ||||
|
r16506 | def _ispatchinga(self, afile): | ||
if afile == '/dev/null': | ||||
return self.op == 'ADD' | ||||
return afile == 'a/' + (self.oldpath or self.path) | ||||
def _ispatchingb(self, bfile): | ||||
if bfile == '/dev/null': | ||||
return self.op == 'DELETE' | ||||
return bfile == 'b/' + self.path | ||||
def ispatching(self, afile, bfile): | ||||
return self._ispatchinga(afile) and self._ispatchingb(bfile) | ||||
|
r11018 | def __repr__(self): | ||
return "<patchmeta %s %r>" % (self.op, self.path) | ||||
|
r7152 | def readgitpatch(lr): | ||
|
r2861 | """extract git-style metadata about patches from <patchname>""" | ||
|
r3223 | |||
|
r2861 | # Filter patch for git information | ||
gp = None | ||||
gitpatches = [] | ||||
|
r7152 | for line in lr: | ||
|
r9243 | line = line.rstrip(' \r\n') | ||
|
r18830 | if line.startswith('diff --git a/'): | ||
|
r2861 | m = gitre.match(line) | ||
if m: | ||||
if gp: | ||||
gitpatches.append(gp) | ||||
|
r9392 | dst = m.group(2) | ||
|
r7148 | gp = patchmeta(dst) | ||
|
r2861 | elif gp: | ||
if line.startswith('--- '): | ||||
gitpatches.append(gp) | ||||
gp = None | ||||
continue | ||||
if line.startswith('rename from '): | ||||
gp.op = 'RENAME' | ||||
|
r9243 | gp.oldpath = line[12:] | ||
|
r2861 | elif line.startswith('rename to '): | ||
|
r9243 | gp.path = line[10:] | ||
|
r2861 | elif line.startswith('copy from '): | ||
gp.op = 'COPY' | ||||
|
r9243 | gp.oldpath = line[10:] | ||
|
r2861 | elif line.startswith('copy to '): | ||
|
r9243 | gp.path = line[8:] | ||
|
r2861 | elif line.startswith('deleted file'): | ||
gp.op = 'DELETE' | ||||
elif line.startswith('new file mode '): | ||||
gp.op = 'ADD' | ||||
|
r9243 | gp.setmode(int(line[-6:], 8)) | ||
|
r2861 | elif line.startswith('new mode '): | ||
|
r9243 | gp.setmode(int(line[-6:], 8)) | ||
|
r3367 | elif line.startswith('GIT binary patch'): | ||
gp.binary = True | ||||
|
r2861 | if gp: | ||
gitpatches.append(gp) | ||||
|
r12669 | return gitpatches | ||
|
r2861 | |||
|
r8891 | class linereader(object): | ||
|
r8810 | # simple class to allow pushing lines back into the input stream | ||
|
r14418 | def __init__(self, fp): | ||
|
r8810 | self.fp = fp | ||
self.buf = [] | ||||
def push(self, line): | ||||
if line is not None: | ||||
self.buf.append(line) | ||||
def readline(self): | ||||
if self.buf: | ||||
l = self.buf[0] | ||||
del self.buf[0] | ||||
return l | ||||
|
r14418 | return self.fp.readline() | ||
|
r8810 | |||
def __iter__(self): | ||||
|
r29726 | return iter(self.readline, '') | ||
|
r8810 | |||
|
r14348 | class abstractbackend(object): | ||
def __init__(self, ui): | ||||
|
r4897 | self.ui = ui | ||
|
r14348 | |||
|
r14391 | def getfile(self, fname): | ||
"""Return target file data and flags as a (data, (islink, | ||||
|
r22296 | isexec)) tuple. Data is None if file is missing/deleted. | ||
|
r14348 | """ | ||
raise NotImplementedError | ||||
|
r14452 | def setfile(self, fname, data, mode, copysource): | ||
|
r14391 | """Write data to target file fname and set its mode. mode is a | ||
(islink, isexec) tuple. If data is None, the file content should | ||||
|
r14452 | be left unchanged. If the file is modified after being copied, | ||
copysource is set to the original file name. | ||||
|
r14367 | """ | ||
|
r14348 | raise NotImplementedError | ||
|
r5652 | |||
|
r14348 | def unlink(self, fname): | ||
"""Unlink target file.""" | ||||
raise NotImplementedError | ||||
def writerej(self, fname, failed, total, lines): | ||||
"""Write rejected lines for fname. total is the number of hunks | ||||
which failed to apply and total the total number of hunks for this | ||||
files. | ||||
""" | ||||
|
r14351 | def exists(self, fname): | ||
raise NotImplementedError | ||||
|
r33156 | def close(self): | ||
raise NotImplementedError | ||||
|
r14348 | class fsbackend(abstractbackend): | ||
|
r14350 | def __init__(self, ui, basedir): | ||
|
r14348 | super(fsbackend, self).__init__(ui) | ||
|
r31233 | self.opener = vfsmod.vfs(basedir) | ||
|
r4897 | |||
|
r14391 | def getfile(self, fname): | ||
|
r21717 | if self.opener.islink(fname): | ||
return (self.opener.readlink(fname), (True, False)) | ||||
|
r14531 | isexec = False | ||
|
r7392 | try: | ||
|
r25658 | isexec = self.opener.lstat(fname).st_mode & 0o100 != 0 | ||
|
r25660 | except OSError as e: | ||
|
r14391 | if e.errno != errno.ENOENT: | ||
raise | ||||
|
r22296 | try: | ||
return (self.opener.read(fname), (False, isexec)) | ||||
|
r25660 | except IOError as e: | ||
|
r22296 | if e.errno != errno.ENOENT: | ||
raise | ||||
return None, None | ||||
|
r7392 | |||
|
r14452 | def setfile(self, fname, data, mode, copysource): | ||
|
r14391 | islink, isexec = mode | ||
if data is None: | ||||
|
r21717 | self.opener.setflags(fname, islink, isexec) | ||
|
r14390 | return | ||
|
r14391 | if islink: | ||
self.opener.symlink(data, fname) | ||||
|
r14367 | else: | ||
|
r14391 | self.opener.write(fname, data) | ||
|
r14367 | if isexec: | ||
|
r21717 | self.opener.setflags(fname, False, True) | ||
|
r7392 | |||
def unlink(self, fname): | ||||
|
r21717 | self.opener.unlinkpath(fname, ignoremissing=True) | ||
|
r7392 | |||
|
r14348 | def writerej(self, fname, failed, total, lines): | ||
fname = fname + ".rej" | ||||
self.ui.warn( | ||||
_("%d out of %d hunks FAILED -- saving rejects to file %s\n") % | ||||
(failed, total, fname)) | ||||
fp = self.opener(fname, 'w') | ||||
fp.writelines(lines) | ||||
fp.close() | ||||
|
r14351 | def exists(self, fname): | ||
|
r21717 | return self.opener.lexists(fname) | ||
|
r14351 | |||
|
r14370 | class workingbackend(fsbackend): | ||
def __init__(self, ui, repo, similarity): | ||||
super(workingbackend, self).__init__(ui, repo.root) | ||||
self.repo = repo | ||||
self.similarity = similarity | ||||
self.removed = set() | ||||
self.changed = set() | ||||
self.copied = [] | ||||
|
r14453 | def _checkknown(self, fname): | ||
if self.repo.dirstate[fname] == '?' and self.exists(fname): | ||||
raise PatchError(_('cannot patch %s: file is not tracked') % fname) | ||||
|
r14452 | def setfile(self, fname, data, mode, copysource): | ||
|
r14453 | self._checkknown(fname) | ||
|
r14452 | super(workingbackend, self).setfile(fname, data, mode, copysource) | ||
if copysource is not None: | ||||
self.copied.append((copysource, fname)) | ||||
|
r14370 | self.changed.add(fname) | ||
def unlink(self, fname): | ||||
|
r14453 | self._checkknown(fname) | ||
|
r14370 | super(workingbackend, self).unlink(fname) | ||
self.removed.add(fname) | ||||
self.changed.add(fname) | ||||
def close(self): | ||||
wctx = self.repo[None] | ||||
|
r19155 | changed = set(self.changed) | ||
|
r14370 | for src, dst in self.copied: | ||
scmutil.dirstatecopy(self.ui, self.repo, wctx, src, dst) | ||||
|
r16112 | if self.removed: | ||
|
r14435 | wctx.forget(sorted(self.removed)) | ||
|
r16112 | for f in self.removed: | ||
if f not in self.repo.dirstate: | ||||
# File was deleted and no longer belongs to the | ||||
# dirstate, it was probably marked added then | ||||
# deleted, and should not be considered by | ||||
|
r19155 | # marktouched(). | ||
changed.discard(f) | ||||
if changed: | ||||
scmutil.marktouched(self.repo, changed, self.similarity) | ||||
|
r14370 | return sorted(self.changed) | ||
|
r14452 | class filestore(object): | ||
|
r14658 | def __init__(self, maxsize=None): | ||
|
r14452 | self.opener = None | ||
self.files = {} | ||||
self.created = 0 | ||||
|
r14658 | self.maxsize = maxsize | ||
if self.maxsize is None: | ||||
self.maxsize = 4*(2**20) | ||||
self.size = 0 | ||||
self.data = {} | ||||
|
r14452 | |||
|
r14609 | def setfile(self, fname, data, mode, copied=None): | ||
|
r14658 | if self.maxsize < 0 or (len(data) + self.size) <= self.maxsize: | ||
self.data[fname] = (data, mode, copied) | ||||
self.size += len(data) | ||||
else: | ||||
if self.opener is None: | ||||
root = tempfile.mkdtemp(prefix='hg-patch-') | ||||
|
r31233 | self.opener = vfsmod.vfs(root) | ||
|
r14658 | # Avoid filename issues with these simple names | ||
|
r36441 | fn = '%d' % self.created | ||
|
r14658 | self.opener.write(fn, data) | ||
self.created += 1 | ||||
self.files[fname] = (fn, mode, copied) | ||||
|
r14452 | |||
def getfile(self, fname): | ||||
|
r14658 | if fname in self.data: | ||
return self.data[fname] | ||||
if not self.opener or fname not in self.files: | ||||
|
r22296 | return None, None, None | ||
|
r14609 | fn, mode, copied = self.files[fname] | ||
return self.opener.read(fn), mode, copied | ||||
|
r14452 | |||
def close(self): | ||||
if self.opener: | ||||
shutil.rmtree(self.opener.base) | ||||
|
r14611 | class repobackend(abstractbackend): | ||
def __init__(self, ui, repo, ctx, store): | ||||
super(repobackend, self).__init__(ui) | ||||
self.repo = repo | ||||
self.ctx = ctx | ||||
self.store = store | ||||
self.changed = set() | ||||
self.removed = set() | ||||
self.copied = {} | ||||
def _checkknown(self, fname): | ||||
if fname not in self.ctx: | ||||
raise PatchError(_('cannot patch %s: file is not tracked') % fname) | ||||
def getfile(self, fname): | ||||
try: | ||||
fctx = self.ctx[fname] | ||||
except error.LookupError: | ||||
|
r22296 | return None, None | ||
|
r14611 | flags = fctx.flags() | ||
return fctx.data(), ('l' in flags, 'x' in flags) | ||||
def setfile(self, fname, data, mode, copysource): | ||||
if copysource: | ||||
self._checkknown(copysource) | ||||
if data is None: | ||||
data = self.ctx[fname].data() | ||||
self.store.setfile(fname, data, mode, copysource) | ||||
self.changed.add(fname) | ||||
if copysource: | ||||
self.copied[fname] = copysource | ||||
def unlink(self, fname): | ||||
self._checkknown(fname) | ||||
self.removed.add(fname) | ||||
def exists(self, fname): | ||||
return fname in self.ctx | ||||
def close(self): | ||||
return self.changed | self.removed | ||||
|
r14348 | # @@ -start,len +start,len @@ or @@ -start +start @@ if len is 1 | ||
|
r15510 | unidesc = re.compile('@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@') | ||
contextdesc = re.compile('(?:---|\*\*\*) (\d+)(?:,(\d+))? (?:---|\*\*\*)') | ||||
|
r14348 | eolmodes = ['strict', 'crlf', 'lf', 'auto'] | ||
class patchfile(object): | ||||
|
r14566 | def __init__(self, ui, gp, backend, store, eolmode='strict'): | ||
self.fname = gp.path | ||||
|
r14348 | self.eolmode = eolmode | ||
self.eol = None | ||||
self.backend = backend | ||||
self.ui = ui | ||||
self.lines = [] | ||||
self.exists = False | ||||
|
r14452 | self.missing = True | ||
|
r14566 | self.mode = gp.mode | ||
self.copysource = gp.oldpath | ||||
self.create = gp.op in ('ADD', 'COPY', 'RENAME') | ||||
self.remove = gp.op == 'DELETE' | ||||
|
r22296 | if self.copysource is None: | ||
data, mode = backend.getfile(self.fname) | ||||
else: | ||||
data, mode = store.getfile(self.copysource)[:2] | ||||
if data is not None: | ||||
self.exists = self.copysource is None or backend.exists(self.fname) | ||||
|
r14452 | self.missing = False | ||
if data: | ||||
|
r14832 | self.lines = mdiff.splitnewlines(data) | ||
|
r14452 | if self.mode is None: | ||
self.mode = mode | ||||
if self.lines: | ||||
# Normalize line endings | ||||
if self.lines[0].endswith('\r\n'): | ||||
self.eol = '\r\n' | ||||
elif self.lines[0].endswith('\n'): | ||||
self.eol = '\n' | ||||
if eolmode != 'strict': | ||||
nlines = [] | ||||
for l in self.lines: | ||||
if l.endswith('\r\n'): | ||||
l = l[:-2] + '\n' | ||||
nlines.append(l) | ||||
self.lines = nlines | ||||
|
r22296 | else: | ||
|
r14566 | if self.create: | ||
|
r14452 | self.missing = False | ||
if self.mode is None: | ||||
self.mode = (False, False) | ||||
if self.missing: | ||||
|
r17299 | self.ui.warn(_("unable to find '%s' for patching\n") % self.fname) | ||
|
r29900 | self.ui.warn(_("(use '--prefix' to apply patch relative to the " | ||
"current directory)\n")) | ||||
|
r14348 | |||
self.hash = {} | ||||
self.dirty = 0 | ||||
self.offset = 0 | ||||
self.skew = 0 | ||||
self.rej = [] | ||||
self.fileprinted = False | ||||
self.printfile(False) | ||||
self.hunks = 0 | ||||
|
r14367 | def writelines(self, fname, lines, mode): | ||
|
r14348 | if self.eolmode == 'auto': | ||
eol = self.eol | ||||
elif self.eolmode == 'crlf': | ||||
eol = '\r\n' | ||||
else: | ||||
eol = '\n' | ||||
if self.eolmode != 'strict' and eol and eol != '\n': | ||||
rawlines = [] | ||||
for l in lines: | ||||
if l and l[-1] == '\n': | ||||
l = l[:-1] + eol | ||||
rawlines.append(l) | ||||
lines = rawlines | ||||
|
r14452 | self.backend.setfile(fname, ''.join(lines), mode, self.copysource) | ||
|
r14348 | |||
|
r4897 | def printfile(self, warn): | ||
if self.fileprinted: | ||||
return | ||||
if warn or self.ui.verbose: | ||||
self.fileprinted = True | ||||
|
r4898 | s = _("patching file %s\n") % self.fname | ||
|
r4897 | if warn: | ||
self.ui.warn(s) | ||||
else: | ||||
self.ui.note(s) | ||||
def findlines(self, l, linenum): | ||||
# looks through the hash and finds candidate lines. The | ||||
# result is a list of line numbers sorted based on distance | ||||
# from linenum | ||||
|
r5143 | |||
|
r9681 | cand = self.hash.get(l, []) | ||
|
r4897 | if len(cand) > 1: | ||
# resort our list of potentials forward then back. | ||||
|
r9032 | cand.sort(key=lambda x: abs(x - linenum)) | ||
|
r4897 | return cand | ||
def write_rej(self): | ||||
# our rejects are a little different from patch(1). This always | ||||
# creates rejects in the same form as the original patch. A file | ||||
# header is inserted so that you can run the reject through patch again | ||||
# without having to type the filename. | ||||
if not self.rej: | ||||
return | ||||
|
r14349 | base = os.path.basename(self.fname) | ||
lines = ["--- %s\n+++ %s\n" % (base, base)] | ||||
for x in self.rej: | ||||
for l in x.hunk: | ||||
lines.append(l) | ||||
|
r31715 | if l[-1:] != '\n': | ||
|
r14349 | lines.append("\n\ No newline at end of file\n") | ||
self.backend.writerej(self.fname, len(self.rej), self.hunks, lines) | ||||
|
r4897 | |||
|
r9393 | def apply(self, h): | ||
|
r4897 | if not h.complete(): | ||
|
r4898 | raise PatchError(_("bad hunk #%d %s (%d %d %d %d)") % | ||
|
r4897 | (h.number, h.desc, len(h.a), h.lena, len(h.b), | ||
h.lenb)) | ||||
self.hunks += 1 | ||||
|
r5652 | if self.missing: | ||
self.rej.append(h) | ||||
return -1 | ||||
|
r14451 | if self.exists and self.create: | ||
|
r14452 | if self.copysource: | ||
self.ui.warn(_("cannot create %s: destination already " | ||||
|
r20869 | "exists\n") % self.fname) | ||
|
r14452 | else: | ||
self.ui.warn(_("file %s already exists\n") % self.fname) | ||||
|
r4897 | self.rej.append(h) | ||
return -1 | ||||
|
r9585 | if isinstance(h, binhunk): | ||
|
r14451 | if self.remove: | ||
|
r14348 | self.backend.unlink(self.fname) | ||
|
r4897 | else: | ||
|
r20137 | l = h.new(self.lines) | ||
self.lines[:] = l | ||||
self.offset += len(l) | ||||
|
r14217 | self.dirty = True | ||
|
r4897 | return 0 | ||
|
r10127 | horig = h | ||
|
r10128 | if (self.eolmode in ('crlf', 'lf') | ||
or self.eolmode == 'auto' and self.eol): | ||||
# If new eols are going to be normalized, then normalize | ||||
# hunk data before patching. Otherwise, preserve input | ||||
# line-endings. | ||||
|
r10127 | h = h.getnormalized() | ||
|
r4897 | # fast case first, no offsets, no fuzz | ||
|
r16122 | old, oldstart, new, newstart = h.fuzzit(0, False) | ||
oldstart += self.offset | ||||
orig_start = oldstart | ||||
|
r10135 | # if there's skew we want to emit the "(offset %d lines)" even | ||
# when the hunk cleanly applies at start + skew, so skip the | ||||
# fast case code | ||||
|
r16122 | if (self.skew == 0 and | ||
diffhelpers.testhunk(old, self.lines, oldstart) == 0): | ||||
|
r14451 | if self.remove: | ||
|
r14348 | self.backend.unlink(self.fname) | ||
|
r4897 | else: | ||
|
r16122 | self.lines[oldstart:oldstart + len(old)] = new | ||
self.offset += len(new) - len(old) | ||||
|
r14217 | self.dirty = True | ||
|
r4897 | return 0 | ||
|
r13700 | # ok, we couldn't match the hunk. Lets look for offsets and fuzz it | ||
self.hash = {} | ||||
for x, s in enumerate(self.lines): | ||||
self.hash.setdefault(s, []).append(x) | ||||
|
r4897 | |||
r32988 | for fuzzlen in xrange(self.ui.configint("patch", "fuzz") + 1): | |||
|
r10282 | for toponly in [True, False]: | ||
|
r16122 | old, oldstart, new, newstart = h.fuzzit(fuzzlen, toponly) | ||
|
r16123 | oldstart = oldstart + self.offset + self.skew | ||
oldstart = min(oldstart, len(self.lines)) | ||||
if old: | ||||
cand = self.findlines(old[0][1:], oldstart) | ||||
else: | ||||
# Only adding lines with no or fuzzed context, just | ||||
# take the skew in account | ||||
cand = [oldstart] | ||||
|
r4897 | |||
for l in cand: | ||||
|
r16123 | if not old or diffhelpers.testhunk(old, self.lines, l) == 0: | ||
|
r16121 | self.lines[l : l + len(old)] = new | ||
self.offset += len(new) - len(old) | ||||
|
r10135 | self.skew = l - orig_start | ||
|
r14217 | self.dirty = True | ||
|
r10518 | offset = l - orig_start - fuzzlen | ||
|
r4897 | if fuzzlen: | ||
|
r10518 | msg = _("Hunk #%d succeeded at %d " | ||
"with fuzz %d " | ||||
"(offset %d lines).\n") | ||||
|
r4897 | self.printfile(True) | ||
|
r10518 | self.ui.warn(msg % | ||
(h.number, l + 1, fuzzlen, offset)) | ||||
|
r4897 | else: | ||
|
r10518 | msg = _("Hunk #%d succeeded at %d " | ||
|
r8090 | "(offset %d lines).\n") | ||
|
r10518 | self.ui.note(msg % (h.number, l + 1, offset)) | ||
|
r4897 | return fuzzlen | ||
self.printfile(True) | ||||
|
r4898 | self.ui.warn(_("Hunk #%d FAILED at %d\n") % (h.number, orig_start)) | ||
|
r10127 | self.rej.append(horig) | ||
|
r4897 | return -1 | ||
|
r13701 | def close(self): | ||
if self.dirty: | ||||
|
r14367 | self.writelines(self.fname, self.lines, self.mode) | ||
|
r13701 | self.write_rej() | ||
return len(self.rej) | ||||
|
r24261 | class header(object): | ||
"""patch header | ||||
""" | ||||
diffgit_re = re.compile('diff --git a/(.*) b/(.*)$') | ||||
diff_re = re.compile('diff -r .* (.*)$') | ||||
|
r24845 | allhunks_re = re.compile('(?:index|deleted file) ') | ||
|
r24261 | pretty_re = re.compile('(?:new file|deleted file) ') | ||
|
r24845 | special_re = re.compile('(?:index|deleted|copy|rename) ') | ||
newfile_re = re.compile('(?:new file)') | ||||
|
r24261 | |||
def __init__(self, header): | ||||
self.header = header | ||||
self.hunks = [] | ||||
def binary(self): | ||||
|
r25149 | return any(h.startswith('index ') for h in self.header) | ||
|
r24261 | |||
def pretty(self, fp): | ||||
for h in self.header: | ||||
if h.startswith('index '): | ||||
fp.write(_('this modifies a binary file (all or nothing)\n')) | ||||
break | ||||
if self.pretty_re.match(h): | ||||
fp.write(h) | ||||
if self.binary(): | ||||
fp.write(_('this is a binary file\n')) | ||||
break | ||||
if h.startswith('---'): | ||||
fp.write(_('%d hunks, %d lines changed\n') % | ||||
(len(self.hunks), | ||||
sum([max(h.added, h.removed) for h in self.hunks]))) | ||||
break | ||||
fp.write(h) | ||||
def write(self, fp): | ||||
fp.write(''.join(self.header)) | ||||
def allhunks(self): | ||||
|
r25149 | return any(self.allhunks_re.match(h) for h in self.header) | ||
|
r24261 | |||
def files(self): | ||||
match = self.diffgit_re.match(self.header[0]) | ||||
if match: | ||||
fromfile, tofile = match.groups() | ||||
if fromfile == tofile: | ||||
return [fromfile] | ||||
return [fromfile, tofile] | ||||
else: | ||||
return self.diff_re.match(self.header[0]).groups() | ||||
def filename(self): | ||||
return self.files()[-1] | ||||
def __repr__(self): | ||||
return '<header %s>' % (' '.join(map(repr, self.files()))) | ||||
|
r24845 | def isnewfile(self): | ||
|
r25149 | return any(self.newfile_re.match(h) for h in self.header) | ||
|
r24845 | |||
|
r24261 | def special(self): | ||
|
r24845 | # Special files are shown only at the header level and not at the hunk | ||
# level for example a file that has been deleted is a special file. | ||||
# The user cannot change the content of the operation, in the case of | ||||
# the deleted file he has to take the deletion or not take it, he | ||||
# cannot take some of it. | ||||
# Newly added files are special if they are empty, they are not special | ||||
# if they have some content as we want to be able to change it | ||||
nocontent = len(self.header) == 2 | ||||
emptynewfile = self.isnewfile() and nocontent | ||||
return emptynewfile or \ | ||||
|
r25149 | any(self.special_re.match(h) for h in self.header) | ||
|
r24261 | |||
|
r24263 | class recordhunk(object): | ||
"""patch hunk | ||||
XXX shouldn't we merge this with the other hunk class? | ||||
""" | ||||
|
r33270 | def __init__(self, header, fromline, toline, proc, before, hunk, after, | ||
maxcontext=None): | ||||
def trimcontext(lines, reverse=False): | ||||
if maxcontext is not None: | ||||
delta = len(lines) - maxcontext | ||||
if delta > 0: | ||||
if reverse: | ||||
return delta, lines[delta:] | ||||
else: | ||||
return delta, lines[:maxcontext] | ||||
return 0, lines | ||||
|
r24263 | |||
self.header = header | ||||
|
r33270 | trimedbefore, self.before = trimcontext(before, True) | ||
self.fromline = fromline + trimedbefore | ||||
self.toline = toline + trimedbefore | ||||
_trimedafter, self.after = trimcontext(after, False) | ||||
|
r24263 | self.proc = proc | ||
self.hunk = hunk | ||||
self.added, self.removed = self.countchanges(self.hunk) | ||||
|
r24346 | def __eq__(self, v): | ||
if not isinstance(v, recordhunk): | ||||
return False | ||||
return ((v.hunk == self.hunk) and | ||||
(v.proc == self.proc) and | ||||
(self.fromline == v.fromline) and | ||||
(self.header.files() == v.header.files())) | ||||
def __hash__(self): | ||||
return hash((tuple(self.hunk), | ||||
tuple(self.header.files()), | ||||
self.fromline, | ||||
self.proc)) | ||||
|
r24263 | def countchanges(self, hunk): | ||
"""hunk -> (n+,n-)""" | ||||
|
r34253 | add = len([h for h in hunk if h.startswith('+')]) | ||
rem = len([h for h in hunk if h.startswith('-')]) | ||||
|
r24263 | return add, rem | ||
|
r32979 | def reversehunk(self): | ||
"""return another recordhunk which is the reverse of the hunk | ||||
If this hunk is diff(A, B), the returned hunk is diff(B, A). To do | ||||
that, swap fromline/toline and +/- signs while keep other things | ||||
unchanged. | ||||
""" | ||||
|
r33941 | m = {'+': '-', '-': '+', '\\': '\\'} | ||
|
r34253 | hunk = ['%s%s' % (m[l[0:1]], l[1:]) for l in self.hunk] | ||
|
r32979 | return recordhunk(self.header, self.toline, self.fromline, self.proc, | ||
self.before, hunk, self.after) | ||||
|
r24263 | def write(self, fp): | ||
delta = len(self.before) + len(self.after) | ||||
if self.after and self.after[-1] == '\\ No newline at end of file\n': | ||||
delta -= 1 | ||||
fromlen = delta + self.removed | ||||
tolen = delta + self.added | ||||
fp.write('@@ -%d,%d +%d,%d @@%s\n' % | ||||
(self.fromline, fromlen, self.toline, tolen, | ||||
self.proc and (' ' + self.proc))) | ||||
fp.write(''.join(self.before + self.hunk + self.after)) | ||||
pretty = write | ||||
def filename(self): | ||||
return self.header.filename() | ||||
def __repr__(self): | ||||
return '<hunk %r@%d>' % (self.filename(), self.fromline) | ||||
|
r34567 | def getmessages(): | ||
return { | ||||
'multiple': { | ||||
|
r34969 | 'apply': _("apply change %d/%d to '%s'?"), | ||
|
r34567 | 'discard': _("discard change %d/%d to '%s'?"), | ||
'record': _("record change %d/%d to '%s'?"), | ||||
}, | ||||
'single': { | ||||
|
r34969 | 'apply': _("apply this change to '%s'?"), | ||
|
r34567 | 'discard': _("discard this change to '%s'?"), | ||
'record': _("record this change to '%s'?"), | ||||
}, | ||||
'help': { | ||||
|
r34969 | 'apply': _('[Ynesfdaq?]' | ||
'$$ &Yes, apply this change' | ||||
'$$ &No, skip this change' | ||||
'$$ &Edit this change manually' | ||||
'$$ &Skip remaining changes to this file' | ||||
'$$ Apply remaining changes to this &file' | ||||
'$$ &Done, skip remaining changes and files' | ||||
'$$ Apply &all changes to all remaining files' | ||||
'$$ &Quit, applying no changes' | ||||
'$$ &? (display help)'), | ||||
|
r34567 | 'discard': _('[Ynesfdaq?]' | ||
'$$ &Yes, discard this change' | ||||
'$$ &No, skip this change' | ||||
'$$ &Edit this change manually' | ||||
'$$ &Skip remaining changes to this file' | ||||
'$$ Discard remaining changes to this &file' | ||||
'$$ &Done, skip remaining changes and files' | ||||
'$$ Discard &all changes to all remaining files' | ||||
'$$ &Quit, discarding no changes' | ||||
'$$ &? (display help)'), | ||||
'record': _('[Ynesfdaq?]' | ||||
'$$ &Yes, record this change' | ||||
'$$ &No, skip this change' | ||||
'$$ &Edit this change manually' | ||||
'$$ &Skip remaining changes to this file' | ||||
'$$ Record remaining changes to this &file' | ||||
'$$ &Done, skip remaining changes and files' | ||||
'$$ Record &all changes to all remaining files' | ||||
'$$ &Quit, recording no changes' | ||||
'$$ &? (display help)'), | ||||
} | ||||
|
r34044 | } | ||
|
r25310 | def filterpatch(ui, headers, operation=None): | ||
|
r24269 | """Interactively filter patch chunks into applied-only chunks""" | ||
|
r34567 | messages = getmessages() | ||
|
r25359 | if operation is None: | ||
|
r29326 | operation = 'record' | ||
|
r24269 | |||
def prompt(skipfile, skipall, query, chunk): | ||||
"""prompt query, and process base inputs | ||||
- y/n for the rest of file | ||||
- y/n for the rest | ||||
- ? (help) | ||||
- q (quit) | ||||
Return True/False and possibly updated skipfile and skipall. | ||||
""" | ||||
newpatches = None | ||||
if skipall is not None: | ||||
return skipall, skipfile, skipall, newpatches | ||||
if skipfile is not None: | ||||
return skipfile, skipfile, skipall, newpatches | ||||
while True: | ||||
|
r34044 | resps = messages['help'][operation] | ||
|
r24269 | r = ui.promptchoice("%s %s" % (query, resps)) | ||
ui.write("\n") | ||||
if r == 8: # ? | ||||
for c, t in ui.extractchoices(resps)[1]: | ||||
|
r29154 | ui.write('%s - %s\n' % (c, encoding.lower(t))) | ||
|
r24269 | continue | ||
elif r == 0: # yes | ||||
ret = True | ||||
elif r == 1: # no | ||||
ret = False | ||||
elif r == 2: # Edit patch | ||||
if chunk is None: | ||||
ui.write(_('cannot edit patch for whole file')) | ||||
ui.write("\n") | ||||
continue | ||||
if chunk.header.binary(): | ||||
ui.write(_('cannot edit patch for binary file')) | ||||
ui.write("\n") | ||||
continue | ||||
# Patch comment based on the Git one (based on comment at end of | ||||
|
r26421 | # https://mercurial-scm.org/wiki/RecordExtension) | ||
|
r24269 | phelp = '---' + _(""" | ||
To remove '-' lines, make them ' ' lines (context). | ||||
To remove '+' lines, delete them. | ||||
Lines starting with # will be removed from the patch. | ||||
If the patch applies cleanly, the edited hunk will immediately be | ||||
added to the record list. If it does not apply cleanly, a rejects | ||||
file will be generated: you can use that when you try again. If | ||||
all lines of the hunk are removed, then the edit is aborted and | ||||
the hunk is left unchanged. | ||||
""") | ||||
(patchfd, patchfn) = tempfile.mkstemp(prefix="hg-editor-", | ||||
|
r36855 | suffix=".diff") | ||
|
r24269 | ncpatchfp = None | ||
try: | ||||
# Write the initial patch | ||||
|
r36855 | f = util.nativeeolwriter(os.fdopen(patchfd, r'wb')) | ||
|
r24269 | chunk.header.write(f) | ||
chunk.write(f) | ||||
f.write('\n'.join(['# ' + i for i in phelp.splitlines()])) | ||||
f.close() | ||||
# Start the editor and wait for it to complete | ||||
editor = ui.geteditor() | ||||
|
r25483 | ret = ui.system("%s \"%s\"" % (editor, patchfn), | ||
|
r31198 | environ={'HGUSER': ui.username()}, | ||
blockedtag='filterpatch') | ||||
|
r25483 | if ret != 0: | ||
ui.warn(_("editor exited with exit code %d\n") % ret) | ||||
continue | ||||
|
r24269 | # Remove comment lines | ||
|
r36856 | patchfp = open(patchfn, r'rb') | ||
|
r28861 | ncpatchfp = stringio() | ||
|
r30397 | for line in util.iterfile(patchfp): | ||
|
r36856 | line = util.fromnativeeol(line) | ||
|
r24269 | if not line.startswith('#'): | ||
ncpatchfp.write(line) | ||||
patchfp.close() | ||||
ncpatchfp.seek(0) | ||||
newpatches = parsepatch(ncpatchfp) | ||||
finally: | ||||
os.unlink(patchfn) | ||||
del ncpatchfp | ||||
# Signal that the chunk shouldn't be applied as-is, but | ||||
# provide the new patch to be used instead. | ||||
ret = False | ||||
elif r == 3: # Skip | ||||
ret = skipfile = False | ||||
elif r == 4: # file (Record remaining) | ||||
ret = skipfile = True | ||||
elif r == 5: # done, skip remaining | ||||
ret = skipall = False | ||||
elif r == 6: # all | ||||
ret = skipall = True | ||||
elif r == 7: # quit | ||||
|
r26587 | raise error.Abort(_('user quit')) | ||
|
r24269 | return ret, skipfile, skipall, newpatches | ||
seen = set() | ||||
applied = {} # 'filename' -> [] of chunks | ||||
skipfile, skipall = None, None | ||||
pos, total = 1, sum(len(h.hunks) for h in headers) | ||||
for h in headers: | ||||
pos += len(h.hunks) | ||||
skipfile = None | ||||
fixoffset = 0 | ||||
hdr = ''.join(h.header) | ||||
if hdr in seen: | ||||
continue | ||||
seen.add(hdr) | ||||
if skipall is None: | ||||
h.pretty(ui) | ||||
msg = (_('examine changes to %s?') % | ||||
_(' and ').join("'%s'" % f for f in h.files())) | ||||
r, skipfile, skipall, np = prompt(skipfile, skipall, msg, None) | ||||
if not r: | ||||
continue | ||||
applied[h.filename()] = [h] | ||||
if h.allhunks(): | ||||
applied[h.filename()] += h.hunks | ||||
continue | ||||
for i, chunk in enumerate(h.hunks): | ||||
if skipfile is None and skipall is None: | ||||
chunk.pretty(ui) | ||||
if total == 1: | ||||
|
r34044 | msg = messages['single'][operation] % chunk.filename() | ||
|
r24269 | else: | ||
idx = pos - len(h.hunks) + i | ||||
|
r34044 | msg = messages['multiple'][operation] % (idx, total, | ||
chunk.filename()) | ||||
|
r24269 | r, skipfile, skipall, newpatches = prompt(skipfile, | ||
skipall, msg, chunk) | ||||
if r: | ||||
if fixoffset: | ||||
chunk = copy.copy(chunk) | ||||
chunk.toline += fixoffset | ||||
applied[chunk.filename()].append(chunk) | ||||
elif newpatches is not None: | ||||
for newpatch in newpatches: | ||||
for newhunk in newpatch.hunks: | ||||
if fixoffset: | ||||
newhunk.toline += fixoffset | ||||
applied[newhunk.filename()].append(newhunk) | ||||
else: | ||||
fixoffset += chunk.removed - chunk.added | ||||
|
r27155 | return (sum([h for h in applied.itervalues() | ||
if h[0].special() or len(h) > 1], []), {}) | ||||
|
r8778 | class hunk(object): | ||
|
r14451 | def __init__(self, desc, num, lr, context): | ||
|
r4897 | self.number = num | ||
self.desc = desc | ||||
|
r10282 | self.hunk = [desc] | ||
|
r4897 | self.a = [] | ||
self.b = [] | ||||
|
r9682 | self.starta = self.lena = None | ||
self.startb = self.lenb = None | ||||
|
r10127 | if lr is not None: | ||
if context: | ||||
self.read_context_hunk(lr) | ||||
else: | ||||
self.read_unified_hunk(lr) | ||||
|
r4897 | |||
|
r10127 | def getnormalized(self): | ||
"""Return a copy with line endings normalized to LF.""" | ||||
def normalize(lines): | ||||
nlines = [] | ||||
for line in lines: | ||||
if line.endswith('\r\n'): | ||||
line = line[:-2] + '\n' | ||||
nlines.append(line) | ||||
return nlines | ||||
# Dummy object, it is rebuilt manually | ||||
|
r14451 | nh = hunk(self.desc, self.number, None, None) | ||
|
r10127 | nh.number = self.number | ||
nh.desc = self.desc | ||||
|
r10524 | nh.hunk = self.hunk | ||
|
r10127 | nh.a = normalize(self.a) | ||
nh.b = normalize(self.b) | ||||
nh.starta = self.starta | ||||
nh.startb = self.startb | ||||
nh.lena = self.lena | ||||
nh.lenb = self.lenb | ||||
return nh | ||||
|
r4897 | def read_unified_hunk(self, lr): | ||
m = unidesc.match(self.desc) | ||||
if not m: | ||||
|
r4898 | raise PatchError(_("bad hunk #%d") % self.number) | ||
|
r15510 | self.starta, self.lena, self.startb, self.lenb = m.groups() | ||
|
r8527 | if self.lena is None: | ||
|
r4897 | self.lena = 1 | ||
else: | ||||
self.lena = int(self.lena) | ||||
|
r8527 | if self.lenb is None: | ||
|
r4897 | self.lenb = 1 | ||
else: | ||||
self.lenb = int(self.lenb) | ||||
self.starta = int(self.starta) | ||||
self.startb = int(self.startb) | ||||
|
r16683 | diffhelpers.addlines(lr, self.hunk, self.lena, self.lenb, self.a, | ||
self.b) | ||||
|
r4897 | # if we hit eof before finishing out the hunk, the last line will | ||
# be zero length. Lets try to fix it up. | ||||
while len(self.hunk[-1]) == 0: | ||||
|
r6948 | del self.hunk[-1] | ||
del self.a[-1] | ||||
del self.b[-1] | ||||
self.lena -= 1 | ||||
self.lenb -= 1 | ||||
|
r13699 | self._fixnewline(lr) | ||
|
r4897 | |||
def read_context_hunk(self, lr): | ||||
self.desc = lr.readline() | ||||
m = contextdesc.match(self.desc) | ||||
if not m: | ||||
|
r4898 | raise PatchError(_("bad hunk #%d") % self.number) | ||
|
r15510 | self.starta, aend = m.groups() | ||
|
r4897 | self.starta = int(self.starta) | ||
|
r8527 | if aend is None: | ||
|
r4897 | aend = self.starta | ||
self.lena = int(aend) - self.starta | ||||
if self.starta: | ||||
self.lena += 1 | ||||
for x in xrange(self.lena): | ||||
l = lr.readline() | ||||
if l.startswith('---'): | ||||
|
r12825 | # lines addition, old block is empty | ||
|
r4897 | lr.push(l) | ||
break | ||||
s = l[2:] | ||||
if l.startswith('- ') or l.startswith('! '): | ||||
u = '-' + s | ||||
elif l.startswith(' '): | ||||
u = ' ' + s | ||||
else: | ||||
|
r4898 | raise PatchError(_("bad hunk #%d old text line %d") % | ||
(self.number, x)) | ||||
|
r4897 | self.a.append(u) | ||
self.hunk.append(u) | ||||
l = lr.readline() | ||||
if l.startswith('\ '): | ||||
s = self.a[-1][:-1] | ||||
self.a[-1] = s | ||||
self.hunk[-1] = s | ||||
l = lr.readline() | ||||
m = contextdesc.match(l) | ||||
if not m: | ||||
|
r4898 | raise PatchError(_("bad hunk #%d") % self.number) | ||
|
r15510 | self.startb, bend = m.groups() | ||
|
r4897 | self.startb = int(self.startb) | ||
|
r8527 | if bend is None: | ||
|
r4897 | bend = self.startb | ||
self.lenb = int(bend) - self.startb | ||||
if self.startb: | ||||
self.lenb += 1 | ||||
hunki = 1 | ||||
for x in xrange(self.lenb): | ||||
l = lr.readline() | ||||
if l.startswith('\ '): | ||||
|
r12825 | # XXX: the only way to hit this is with an invalid line range. | ||
# The no-eol marker is not counted in the line range, but I | ||||
# guess there are diff(1) out there which behave differently. | ||||
|
r4897 | s = self.b[-1][:-1] | ||
self.b[-1] = s | ||||
|
r10282 | self.hunk[hunki - 1] = s | ||
|
r4897 | continue | ||
if not l: | ||||
|
r12825 | # line deletions, new block is empty and we hit EOF | ||
|
r4897 | lr.push(l) | ||
break | ||||
s = l[2:] | ||||
if l.startswith('+ ') or l.startswith('! '): | ||||
u = '+' + s | ||||
elif l.startswith(' '): | ||||
u = ' ' + s | ||||
elif len(self.b) == 0: | ||||
|
r12825 | # line deletions, new block is empty | ||
|
r4897 | lr.push(l) | ||
break | ||||
else: | ||||
|
r4898 | raise PatchError(_("bad hunk #%d old text line %d") % | ||
(self.number, x)) | ||||
|
r4897 | self.b.append(s) | ||
while True: | ||||
if hunki >= len(self.hunk): | ||||
h = "" | ||||
else: | ||||
h = self.hunk[hunki] | ||||
hunki += 1 | ||||
if h == u: | ||||
break | ||||
elif h.startswith('-'): | ||||
continue | ||||
else: | ||||
|
r10282 | self.hunk.insert(hunki - 1, u) | ||
|
r4897 | break | ||
if not self.a: | ||||
# this happens when lines were only added to the hunk | ||||
for x in self.hunk: | ||||
if x.startswith('-') or x.startswith(' '): | ||||
self.a.append(x) | ||||
if not self.b: | ||||
# this happens when lines were only deleted from the hunk | ||||
for x in self.hunk: | ||||
if x.startswith('+') or x.startswith(' '): | ||||
self.b.append(x[1:]) | ||||
# @@ -start,len +start,len @@ | ||||
self.desc = "@@ -%d,%d +%d,%d @@\n" % (self.starta, self.lena, | ||||
self.startb, self.lenb) | ||||
self.hunk[0] = self.desc | ||||
|
r13699 | self._fixnewline(lr) | ||
|
r4897 | |||
|
r13699 | def _fixnewline(self, lr): | ||
l = lr.readline() | ||||
if l.startswith('\ '): | ||||
diffhelpers.fix_newline(self.hunk, self.a, self.b) | ||||
else: | ||||
lr.push(l) | ||||
|
r4897 | |||
def complete(self): | ||||
return len(self.a) == self.lena and len(self.b) == self.lenb | ||||
|
r16121 | def _fuzzit(self, old, new, fuzz, toponly): | ||
|
r4897 | # this removes context lines from the top and bottom of list 'l'. It | ||
# checks the hunk to make sure only context lines are removed, and then | ||||
# returns a new shortened list of lines. | ||||
|
r16124 | fuzz = min(fuzz, len(old)) | ||
|
r4897 | if fuzz: | ||
top = 0 | ||||
bot = 0 | ||||
hlen = len(self.hunk) | ||||
|
r10282 | for x in xrange(hlen - 1): | ||
|
r4897 | # the hunk starts with the @@ line, so use x+1 | ||
|
r37489 | if self.hunk[x + 1].startswith(' '): | ||
|
r4897 | top += 1 | ||
else: | ||||
break | ||||
if not toponly: | ||||
|
r10282 | for x in xrange(hlen - 1): | ||
|
r37489 | if self.hunk[hlen - bot - 1].startswith(' '): | ||
|
r4897 | bot += 1 | ||
else: | ||||
break | ||||
|
r16124 | bot = min(fuzz, bot) | ||
top = min(fuzz, top) | ||||
|
r18054 | return old[top:len(old) - bot], new[top:len(new) - bot], top | ||
|
r16122 | return old, new, 0 | ||
|
r4897 | |||
|
r16121 | def fuzzit(self, fuzz, toponly): | ||
|
r16122 | old, new, top = self._fuzzit(self.a, self.b, fuzz, toponly) | ||
oldstart = self.starta + top | ||||
newstart = self.startb + top | ||||
# zero length hunk ranges already have their start decremented | ||||
|
r16650 | if self.lena and oldstart > 0: | ||
|
r16122 | oldstart -= 1 | ||
|
r16650 | if self.lenb and newstart > 0: | ||
|
r16122 | newstart -= 1 | ||
return old, oldstart, new, newstart | ||||
|
r4897 | |||
|
r14764 | class binhunk(object): | ||
|
r20137 | 'A binary patch file.' | ||
|
r16523 | def __init__(self, lr, fname): | ||
|
r4897 | self.text = None | ||
|
r20137 | self.delta = False | ||
|
r9585 | self.hunk = ['GIT binary patch\n'] | ||
|
r16523 | self._fname = fname | ||
|
r14384 | self._read(lr) | ||
|
r4897 | |||
def complete(self): | ||||
return self.text is not None | ||||
|
r20137 | def new(self, lines): | ||
if self.delta: | ||||
return [applybindelta(self.text, ''.join(lines))] | ||||
|
r4897 | return [self.text] | ||
|
r14384 | def _read(self, lr): | ||
|
r16524 | def getline(lr, hunk): | ||
l = lr.readline() | ||||
hunk.append(l) | ||||
return l.rstrip('\r\n') | ||||
|
r20137 | size = 0 | ||
|
r16567 | while True: | ||
|
r16524 | line = getline(lr, self.hunk) | ||
|
r16567 | if not line: | ||
raise PatchError(_('could not extract "%s" binary data') | ||||
% self._fname) | ||||
if line.startswith('literal '): | ||||
|
r20137 | size = int(line[8:].rstrip()) | ||
|
r16567 | break | ||
|
r20137 | if line.startswith('delta '): | ||
size = int(line[6:].rstrip()) | ||||
self.delta = True | ||||
break | ||||
|
r3367 | dec = [] | ||
|
r16524 | line = getline(lr, self.hunk) | ||
|
r4897 | while len(line) > 1: | ||
|
r36210 | l = line[0:1] | ||
|
r3374 | if l <= 'Z' and l >= 'A': | ||
l = ord(l) - ord('A') + 1 | ||||
else: | ||||
l = ord(l) - ord('a') + 27 | ||||
|
r16522 | try: | ||
|
r32200 | dec.append(util.b85decode(line[1:])[:l]) | ||
|
r25660 | except ValueError as e: | ||
|
r16523 | raise PatchError(_('could not decode "%s" binary patch: %s') | ||
|
r37102 | % (self._fname, stringutil.forcebytestr(e))) | ||
|
r16524 | line = getline(lr, self.hunk) | ||
|
r3367 | text = zlib.decompress(''.join(dec)) | ||
if len(text) != size: | ||||
|
r16523 | raise PatchError(_('"%s" length is %d bytes, should be %d') | ||
% (self._fname, len(text), size)) | ||||
|
r4897 | self.text = text | ||
|
r3367 | |||
|
r4897 | def parsefilename(str): | ||
# --- filename \t|space stuff | ||||
|
r5851 | s = str[4:].rstrip('\r\n') | ||
|
r4897 | i = s.find('\t') | ||
if i < 0: | ||||
i = s.find(' ') | ||||
if i < 0: | ||||
return s | ||||
return s[:i] | ||||
|
r2861 | |||
|
r25424 | def reversehunks(hunks): | ||
'''reverse the signs in the hunks given as argument | ||||
This function operates on hunks coming out of patch.filterpatch, that is | ||||
a list of the form: [header1, hunk1, hunk2, header2...]. Example usage: | ||||
|
r34133 | >>> rawpatch = b"""diff --git a/folder1/g b/folder1/g | ||
|
r25424 | ... --- a/folder1/g | ||
... +++ b/folder1/g | ||||
... @@ -1,7 +1,7 @@ | ||||
... +firstline | ||||
... c | ||||
... 1 | ||||
... 2 | ||||
... + 3 | ||||
... -4 | ||||
... 5 | ||||
... d | ||||
... +lastline""" | ||||
|
r34254 | >>> hunks = parsepatch([rawpatch]) | ||
|
r25424 | >>> hunkscomingfromfilterpatch = [] | ||
>>> for h in hunks: | ||||
... hunkscomingfromfilterpatch.append(h) | ||||
... hunkscomingfromfilterpatch.extend(h.hunks) | ||||
>>> reversedhunks = reversehunks(hunkscomingfromfilterpatch) | ||||
|
r28861 | >>> from . import util | ||
>>> fp = util.stringio() | ||||
|
r25424 | >>> for c in reversedhunks: | ||
... c.write(fp) | ||||
|
r34254 | >>> fp.seek(0) or None | ||
|
r25424 | >>> reversedpatch = fp.read() | ||
|
r34139 | >>> print(pycompat.sysstr(reversedpatch)) | ||
|
r25424 | diff --git a/folder1/g b/folder1/g | ||
--- a/folder1/g | ||||
+++ b/folder1/g | ||||
@@ -1,4 +1,3 @@ | ||||
-firstline | ||||
c | ||||
1 | ||||
2 | ||||
|
r32979 | @@ -2,6 +1,6 @@ | ||
|
r25424 | c | ||
1 | ||||
2 | ||||
- 3 | ||||
+4 | ||||
5 | ||||
d | ||||
|
r32979 | @@ -6,3 +5,2 @@ | ||
|
r25424 | 5 | ||
d | ||||
-lastline | ||||
''' | ||||
newhunks = [] | ||||
for c in hunks: | ||||
|
r32979 | if util.safehasattr(c, 'reversehunk'): | ||
c = c.reversehunk() | ||||
|
r25424 | newhunks.append(c) | ||
return newhunks | ||||
|
r33270 | def parsepatch(originalchunks, maxcontext=None): | ||
"""patch -> [] of headers -> [] of hunks | ||||
If maxcontext is not None, trim context lines if necessary. | ||||
|
r34133 | >>> rawpatch = b'''diff --git a/folder1/g b/folder1/g | ||
|
r33270 | ... --- a/folder1/g | ||
... +++ b/folder1/g | ||||
... @@ -1,8 +1,10 @@ | ||||
... 1 | ||||
... 2 | ||||
... -3 | ||||
... 4 | ||||
... 5 | ||||
... 6 | ||||
... +6.1 | ||||
... +6.2 | ||||
... 7 | ||||
... 8 | ||||
... +9''' | ||||
>>> out = util.stringio() | ||||
>>> headers = parsepatch([rawpatch], maxcontext=1) | ||||
>>> for header in headers: | ||||
... header.write(out) | ||||
... for hunk in header.hunks: | ||||
... hunk.write(out) | ||||
|
r34139 | >>> print(pycompat.sysstr(out.getvalue())) | ||
|
r33270 | diff --git a/folder1/g b/folder1/g | ||
--- a/folder1/g | ||||
+++ b/folder1/g | ||||
@@ -2,3 +2,2 @@ | ||||
2 | ||||
-3 | ||||
4 | ||||
@@ -6,2 +5,4 @@ | ||||
6 | ||||
+6.1 | ||||
+6.2 | ||||
7 | ||||
@@ -8,1 +9,2 @@ | ||||
8 | ||||
+9 | ||||
""" | ||||
|
r24265 | class parser(object): | ||
"""patch parsing state machine""" | ||||
def __init__(self): | ||||
self.fromline = 0 | ||||
self.toline = 0 | ||||
self.proc = '' | ||||
self.header = None | ||||
self.context = [] | ||||
self.before = [] | ||||
self.hunk = [] | ||||
self.headers = [] | ||||
def addrange(self, limits): | ||||
fromstart, fromend, tostart, toend, proc = limits | ||||
self.fromline = int(fromstart) | ||||
self.toline = int(tostart) | ||||
self.proc = proc | ||||
def addcontext(self, context): | ||||
if self.hunk: | ||||
h = recordhunk(self.header, self.fromline, self.toline, | ||||
|
r33270 | self.proc, self.before, self.hunk, context, maxcontext) | ||
|
r24265 | self.header.hunks.append(h) | ||
self.fromline += len(self.before) + h.removed | ||||
self.toline += len(self.before) + h.added | ||||
self.before = [] | ||||
self.hunk = [] | ||||
self.context = context | ||||
def addhunk(self, hunk): | ||||
if self.context: | ||||
self.before = self.context | ||||
self.context = [] | ||||
self.hunk = hunk | ||||
def newfile(self, hdr): | ||||
self.addcontext([]) | ||||
h = header(hdr) | ||||
self.headers.append(h) | ||||
self.header = h | ||||
def addother(self, line): | ||||
pass # 'other' lines are ignored | ||||
def finished(self): | ||||
self.addcontext([]) | ||||
return self.headers | ||||
transitions = { | ||||
'file': {'context': addcontext, | ||||
'file': newfile, | ||||
'hunk': addhunk, | ||||
'range': addrange}, | ||||
'context': {'file': newfile, | ||||
'hunk': addhunk, | ||||
'range': addrange, | ||||
'other': addother}, | ||||
'hunk': {'context': addcontext, | ||||
'file': newfile, | ||||
'range': addrange}, | ||||
'range': {'context': addcontext, | ||||
'hunk': addhunk}, | ||||
'other': {'other': addother}, | ||||
} | ||||
p = parser() | ||||
|
r28861 | fp = stringio() | ||
|
r24341 | fp.write(''.join(originalchunks)) | ||
fp.seek(0) | ||||
|
r24265 | |||
state = 'context' | ||||
for newstate, data in scanpatch(fp): | ||||
try: | ||||
p.transitions[state][newstate](p, data) | ||||
except KeyError: | ||||
raise PatchError('unhandled transition: %s -> %s' % | ||||
(state, newstate)) | ||||
state = newstate | ||||
|
r24341 | del fp | ||
|
r24265 | return p.finished() | ||
|
r24244 | def pathtransform(path, strip, prefix): | ||
|
r24243 | '''turn a path from a patch into a path suitable for the repository | ||
|
r24244 | prefix, if not empty, is expected to be normalized with a / at the end. | ||
|
r24243 | Returns (stripped components, path in repository). | ||
|
r34133 | >>> pathtransform(b'a/b/c', 0, b'') | ||
|
r24243 | ('', 'a/b/c') | ||
|
r34133 | >>> pathtransform(b' a/b/c ', 0, b'') | ||
|
r24243 | ('', ' a/b/c') | ||
|
r34133 | >>> pathtransform(b' a/b/c ', 2, b'') | ||
|
r24243 | ('a/b/', 'c') | ||
|
r34133 | >>> pathtransform(b'a/b/c', 0, b'd/e/') | ||
|
r24385 | ('', 'd/e/a/b/c') | ||
|
r34133 | >>> pathtransform(b' a//b/c ', 2, b'd/e/') | ||
|
r24244 | ('a//b/', 'd/e/c') | ||
|
r34133 | >>> pathtransform(b'a/b/c', 3, b'') | ||
|
r24243 | Traceback (most recent call last): | ||
PatchError: unable to strip away 1 of 3 dirs from a/b/c | ||||
''' | ||||
|
r11022 | pathlen = len(path) | ||
i = 0 | ||||
if strip == 0: | ||||
|
r24385 | return '', prefix + path.rstrip() | ||
|
r11022 | count = strip | ||
while count > 0: | ||||
i = path.find('/', i) | ||||
if i == -1: | ||||
raise PatchError(_("unable to strip away %d of %d dirs from %s") % | ||||
(count, strip, path)) | ||||
i += 1 | ||||
# consume '//' in the path | ||||
|
r34069 | while i < pathlen - 1 and path[i:i + 1] == '/': | ||
|
r11022 | i += 1 | ||
count -= 1 | ||||
|
r24244 | return path[:i].lstrip(), prefix + path[i:].rstrip() | ||
|
r11022 | |||
|
r24245 | def makepatchmeta(backend, afile_orig, bfile_orig, hunk, strip, prefix): | ||
|
r4897 | nulla = afile_orig == "/dev/null" | ||
nullb = bfile_orig == "/dev/null" | ||||
|
r14451 | create = nulla and hunk.starta == 0 and hunk.lena == 0 | ||
remove = nullb and hunk.startb == 0 and hunk.lenb == 0 | ||||
|
r24245 | abase, afile = pathtransform(afile_orig, strip, prefix) | ||
|
r14351 | gooda = not nulla and backend.exists(afile) | ||
|
r24245 | bbase, bfile = pathtransform(bfile_orig, strip, prefix) | ||
|
r4897 | if afile == bfile: | ||
goodb = gooda | ||||
else: | ||||
|
r14351 | goodb = not nullb and backend.exists(bfile) | ||
|
r14451 | missing = not goodb and not gooda and not create | ||
|
r9328 | |||
|
r11820 | # some diff programs apparently produce patches where the afile is | ||
# not /dev/null, but afile starts with bfile | ||||
|
r10745 | abasedir = afile[:afile.rfind('/') + 1] | ||
bbasedir = bfile[:bfile.rfind('/') + 1] | ||||
|
r14451 | if (missing and abasedir == bbasedir and afile.startswith(bfile) | ||
and hunk.starta == 0 and hunk.lena == 0): | ||||
create = True | ||||
missing = False | ||||
|
r9328 | |||
|
r6295 | # If afile is "a/b/foo" and bfile is "a/b/foo.orig" we assume the | ||
# diff is between a file and its backup. In this case, the original | ||||
# file should be patched (see original mpatch code). | ||||
isbackup = (abase == bbase and bfile.startswith(afile)) | ||||
|
r5652 | fname = None | ||
if not missing: | ||||
if gooda and goodb: | ||||
|
r24306 | if isbackup: | ||
fname = afile | ||||
else: | ||||
fname = bfile | ||||
|
r5652 | elif gooda: | ||
|
r4897 | fname = afile | ||
|
r5760 | |||
|
r5652 | if not fname: | ||
if not nullb: | ||||
|
r24306 | if isbackup: | ||
fname = afile | ||||
else: | ||||
fname = bfile | ||||
|
r5652 | elif not nulla: | ||
|
r4897 | fname = afile | ||
|
r5652 | else: | ||
raise PatchError(_("undefined source and destination files")) | ||||
|
r5760 | |||
|
r14566 | gp = patchmeta(fname) | ||
if create: | ||||
gp.op = 'ADD' | ||||
elif remove: | ||||
gp.op = 'DELETE' | ||||
return gp | ||||
|
r4897 | |||
|
r24264 | def scanpatch(fp): | ||
"""like patch.iterhunks, but yield different events | ||||
- ('file', [header_lines + fromfile + tofile]) | ||||
- ('context', [context_lines]) | ||||
- ('hunk', [hunk_lines]) | ||||
- ('range', (-start,len, +start,len, proc)) | ||||
""" | ||||
|
r34068 | lines_re = re.compile(br'@@ -(\d+),(\d+) \+(\d+),(\d+) @@\s*(.*)') | ||
|
r24264 | lr = linereader(fp) | ||
def scanwhile(first, p): | ||||
"""scan lr while predicate holds""" | ||||
lines = [first] | ||||
|
r29726 | for line in iter(lr.readline, ''): | ||
|
r24264 | if p(line): | ||
lines.append(line) | ||||
else: | ||||
lr.push(line) | ||||
break | ||||
return lines | ||||
|
r29726 | for line in iter(lr.readline, ''): | ||
|
r24264 | if line.startswith('diff --git a/') or line.startswith('diff -r '): | ||
def notheader(line): | ||||
s = line.split(None, 1) | ||||
return not s or s[0] not in ('---', 'diff') | ||||
header = scanwhile(line, notheader) | ||||
fromfile = lr.readline() | ||||
if fromfile.startswith('---'): | ||||
tofile = lr.readline() | ||||
header += [fromfile, tofile] | ||||
else: | ||||
lr.push(fromfile) | ||||
yield 'file', header | ||||
|
r37489 | elif line.startswith(' '): | ||
cs = (' ', '\\') | ||||
yield 'context', scanwhile(line, lambda l: l.startswith(cs)) | ||||
elif line.startswith(('-', '+')): | ||||
cs = ('-', '+', '\\') | ||||
yield 'hunk', scanwhile(line, lambda l: l.startswith(cs)) | ||||
|
r24264 | else: | ||
m = lines_re.match(line) | ||||
if m: | ||||
yield 'range', m.groups() | ||||
else: | ||||
yield 'other', line | ||||
|
r7152 | def scangitpatch(lr, firstline): | ||
|
r7186 | """ | ||
|
r7152 | Git patches can emit: | ||
- rename a to b | ||||
- change b | ||||
- copy a to c | ||||
- change c | ||||
|
r7186 | |||
|
r7152 | We cannot apply this sequence as-is, the renamed 'a' could not be | ||
found for it would have been renamed already. And we cannot copy | ||||
from 'b' instead because 'b' would have been changed already. So | ||||
we scan the git patch for copy and rename commands so we can | ||||
perform the copies ahead of time. | ||||
""" | ||||
pos = 0 | ||||
try: | ||||
pos = lr.fp.tell() | ||||
fp = lr.fp | ||||
except IOError: | ||||
|
r28861 | fp = stringio(lr.fp.read()) | ||
|
r14418 | gitlr = linereader(fp) | ||
|
r7152 | gitlr.push(firstline) | ||
|
r12669 | gitpatches = readgitpatch(gitlr) | ||
|
r7152 | fp.seek(pos) | ||
|
r12669 | return gitpatches | ||
|
r7152 | |||
|
r14240 | def iterhunks(fp): | ||
|
r5650 | """Read a patch and yield the following events: | ||
- ("file", afile, bfile, firsthunk): select a new target file. | ||||
- ("hunk", hunk): a new hunk is ready to be applied, follows a | ||||
"file" event. | ||||
- ("git", gitchanges): current diff is in git format, gitchanges | ||||
maps filenames to gitpatch records. Unique event. | ||||
""" | ||||
|
r4897 | afile = "" | ||
bfile = "" | ||||
state = None | ||||
hunknum = 0 | ||||
|
r14017 | emitfile = newfile = False | ||
|
r14388 | gitpatches = None | ||
|
r2861 | |||
|
r4897 | # our states | ||
BFILE = 1 | ||||
context = None | ||||
|
r10128 | lr = linereader(fp) | ||
|
r2861 | |||
|
r29726 | for x in iter(lr.readline, ''): | ||
|
r14383 | if state == BFILE and ( | ||
|
r36664 | (not context and x.startswith('@')) | ||
|
r14383 | or (context is not False and x.startswith('***************')) | ||
or x.startswith('GIT binary patch')): | ||||
|
r14388 | gp = None | ||
|
r14534 | if (gitpatches and | ||
|
r16506 | gitpatches[-1].ispatching(afile, bfile)): | ||
gp = gitpatches.pop() | ||||
|
r14383 | if x.startswith('GIT binary patch'): | ||
|
r16523 | h = binhunk(lr, gp.path) | ||
|
r14383 | else: | ||
if context is None and x.startswith('***************'): | ||||
context = True | ||||
|
r14451 | h = hunk(x, hunknum + 1, lr, context) | ||
|
r4897 | hunknum += 1 | ||
|
r5650 | if emitfile: | ||
emitfile = False | ||||
|
r14566 | yield 'file', (afile, bfile, h, gp and gp.copy() or None) | ||
|
r13699 | yield 'hunk', h | ||
|
r18830 | elif x.startswith('diff --git a/'): | ||
|
r16524 | m = gitre.match(x.rstrip(' \r\n')) | ||
|
r14387 | if not m: | ||
continue | ||||
|
r16506 | if gitpatches is None: | ||
|
r14387 | # scan whole input for git metadata | ||
|
r16506 | gitpatches = scangitpatch(lr, x) | ||
yield 'git', [g.copy() for g in gitpatches | ||||
if g.op in ('COPY', 'RENAME')] | ||||
|
r14388 | gitpatches.reverse() | ||
|
r14387 | afile = 'a/' + m.group(1) | ||
bfile = 'b/' + m.group(2) | ||||
|
r16506 | while gitpatches and not gitpatches[-1].ispatching(afile, bfile): | ||
gp = gitpatches.pop() | ||||
|
r14566 | yield 'file', ('a/' + gp.path, 'b/' + gp.path, None, gp.copy()) | ||
|
r16506 | if not gitpatches: | ||
raise PatchError(_('failed to synchronize metadata for "%s"') | ||||
% afile[2:]) | ||||
gp = gitpatches[-1] | ||||
|
r14387 | newfile = True | ||
|
r4897 | elif x.startswith('---'): | ||
# check for a unified diff | ||||
l2 = lr.readline() | ||||
if not l2.startswith('+++'): | ||||
lr.push(l2) | ||||
continue | ||||
newfile = True | ||||
context = False | ||||
afile = parsefilename(x) | ||||
bfile = parsefilename(l2) | ||||
elif x.startswith('***'): | ||||
# check for a context diff | ||||
l2 = lr.readline() | ||||
if not l2.startswith('---'): | ||||
lr.push(l2) | ||||
continue | ||||
l3 = lr.readline() | ||||
lr.push(l3) | ||||
if not l3.startswith("***************"): | ||||
lr.push(l2) | ||||
continue | ||||
newfile = True | ||||
context = True | ||||
afile = parsefilename(x) | ||||
bfile = parsefilename(l2) | ||||
|
r3057 | |||
|
r14017 | if newfile: | ||
newfile = False | ||||
|
r5650 | emitfile = True | ||
|
r4897 | state = BFILE | ||
hunknum = 0 | ||||
|
r5650 | |||
|
r14388 | while gitpatches: | ||
|
r16506 | gp = gitpatches.pop() | ||
|
r14566 | yield 'file', ('a/' + gp.path, 'b/' + gp.path, None, gp.copy()) | ||
|
r14388 | |||
|
r20137 | def applybindelta(binchunk, data): | ||
"""Apply a binary delta hunk | ||||
The algorithm used is the algorithm from git's patch-delta.c | ||||
""" | ||||
def deltahead(binchunk): | ||||
i = 0 | ||||
for c in binchunk: | ||||
i += 1 | ||||
if not (ord(c) & 0x80): | ||||
return i | ||||
return i | ||||
out = "" | ||||
s = deltahead(binchunk) | ||||
binchunk = binchunk[s:] | ||||
s = deltahead(binchunk) | ||||
binchunk = binchunk[s:] | ||||
i = 0 | ||||
while i < len(binchunk): | ||||
cmd = ord(binchunk[i]) | ||||
i += 1 | ||||
if (cmd & 0x80): | ||||
offset = 0 | ||||
size = 0 | ||||
if (cmd & 0x01): | ||||
offset = ord(binchunk[i]) | ||||
i += 1 | ||||
if (cmd & 0x02): | ||||
offset |= ord(binchunk[i]) << 8 | ||||
i += 1 | ||||
if (cmd & 0x04): | ||||
offset |= ord(binchunk[i]) << 16 | ||||
i += 1 | ||||
if (cmd & 0x08): | ||||
offset |= ord(binchunk[i]) << 24 | ||||
i += 1 | ||||
if (cmd & 0x10): | ||||
size = ord(binchunk[i]) | ||||
i += 1 | ||||
if (cmd & 0x20): | ||||
size |= ord(binchunk[i]) << 8 | ||||
i += 1 | ||||
if (cmd & 0x40): | ||||
size |= ord(binchunk[i]) << 16 | ||||
i += 1 | ||||
if size == 0: | ||||
size = 0x10000 | ||||
offset_end = offset + size | ||||
out += data[offset:offset_end] | ||||
elif cmd != 0: | ||||
offset_end = i + cmd | ||||
out += binchunk[i:offset_end] | ||||
i += cmd | ||||
else: | ||||
raise PatchError(_('unexpected delta opcode 0')) | ||||
return out | ||||
|
r24247 | def applydiff(ui, fp, backend, store, strip=1, prefix='', eolmode='strict'): | ||
|
r10966 | """Reads a patch from fp and tries to apply it. | ||
|
r5650 | |||
|
r14565 | Returns 0 for a clean patch, -1 if any rejects were found and 1 if | ||
there was any fuzz. | ||||
|
r8810 | |||
|
r10101 | If 'eolmode' is 'strict', the patch content and patched file are | ||
read in binary mode. Otherwise, line endings are ignored when | ||||
patching then normalized according to 'eolmode'. | ||||
|
r8810 | """ | ||
|
r14565 | return _applydiff(ui, fp, patchfile, backend, store, strip=strip, | ||
|
r24247 | prefix=prefix, eolmode=eolmode) | ||
|
r10966 | |||
|
r35053 | def _canonprefix(repo, prefix): | ||
if prefix: | ||||
prefix = pathutil.canonpath(repo.root, repo.getcwd(), prefix) | ||||
if prefix != '': | ||||
prefix += '/' | ||||
return prefix | ||||
|
r24246 | def _applydiff(ui, fp, patcher, backend, store, strip=1, prefix='', | ||
|
r14452 | eolmode='strict'): | ||
|
r35053 | prefix = _canonprefix(backend.repo, prefix) | ||
|
r14389 | def pstrip(p): | ||
|
r24246 | return pathtransform(p, strip - 1, prefix)[1] | ||
|
r14389 | |||
|
r5650 | rejects = 0 | ||
err = 0 | ||||
current_file = None | ||||
|
r14240 | for state, values in iterhunks(fp): | ||
|
r5650 | if state == 'hunk': | ||
if not current_file: | ||||
continue | ||||
|
r11021 | ret = current_file.apply(values) | ||
|
r14565 | if ret > 0: | ||
err = 1 | ||||
|
r5650 | elif state == 'file': | ||
|
r13701 | if current_file: | ||
rejects += current_file.close() | ||||
|
r14388 | current_file = None | ||
afile, bfile, first_hunk, gp = values | ||||
if gp: | ||||
|
r14566 | gp.path = pstrip(gp.path) | ||
|
r14452 | if gp.oldpath: | ||
|
r14566 | gp.oldpath = pstrip(gp.oldpath) | ||
else: | ||||
|
r24246 | gp = makepatchmeta(backend, afile, bfile, first_hunk, strip, | ||
prefix) | ||||
|
r14566 | if gp.op == 'RENAME': | ||
backend.unlink(gp.oldpath) | ||||
|
r14388 | if not first_hunk: | ||
|
r14566 | if gp.op == 'DELETE': | ||
backend.unlink(gp.path) | ||||
continue | ||||
data, mode = None, None | ||||
if gp.op in ('RENAME', 'COPY'): | ||||
|
r14609 | data, mode = store.getfile(gp.oldpath)[:2] | ||
|
r30078 | if data is None: | ||
# This means that the old path does not exist | ||||
raise PatchError(_("source file '%s' does not exist") | ||||
% gp.oldpath) | ||||
|
r14566 | if gp.mode: | ||
mode = gp.mode | ||||
if gp.op == 'ADD': | ||||
# Added files without content have no hunk and | ||||
# must be created | ||||
data = '' | ||||
if data or mode: | ||||
if (gp.op in ('ADD', 'RENAME', 'COPY') | ||||
and backend.exists(gp.path)): | ||||
raise PatchError(_("cannot create %s: destination " | ||||
"already exists") % gp.path) | ||||
backend.setfile(gp.path, data, mode, gp.oldpath) | ||||
|
r14388 | continue | ||
|
r5650 | try: | ||
|
r14566 | current_file = patcher(ui, gp, backend, store, | ||
eolmode=eolmode) | ||||
|
r25660 | except PatchError as inst: | ||
|
r14218 | ui.warn(str(inst) + '\n') | ||
|
r11021 | current_file = None | ||
|
r5650 | rejects += 1 | ||
continue | ||||
elif state == 'git': | ||||
|
r11021 | for gp in values: | ||
|
r14452 | path = pstrip(gp.oldpath) | ||
|
r22296 | data, mode = backend.getfile(path) | ||
if data is None: | ||||
|
r16813 | # The error ignored here will trigger a getfile() | ||
# error in a place more appropriate for error | ||||
# handling, and will not interrupt the patching | ||||
# process. | ||||
|
r22296 | pass | ||
|
r16813 | else: | ||
store.setfile(path, data, mode) | ||||
|
r4897 | else: | ||
|
r26587 | raise error.Abort(_('unsupported parser state: %s') % state) | ||
|
r5649 | |||
|
r13701 | if current_file: | ||
rejects += current_file.close() | ||||
|
r5650 | |||
|
r4897 | if rejects: | ||
return -1 | ||||
return err | ||||
|
r2874 | |||
|
r14382 | def _externalpatch(ui, repo, patcher, patchname, strip, files, | ||
|
r14381 | similarity): | ||
|
r7151 | """use <patcher> to apply <patchname> to the working directory. | ||
returns whether patch was applied with fuzz factor.""" | ||||
fuzz = False | ||||
|
r12673 | args = [] | ||
|
r14382 | cwd = repo.root | ||
|
r7151 | if cwd: | ||
|
r37138 | args.append('-d %s' % procutil.shellquote(cwd)) | ||
|
r37476 | cmd = ('%s %s -p%d < %s' | ||
% (patcher, ' '.join(args), strip, procutil.shellquote(patchname))) | ||||
fp = procutil.popen(cmd, 'rb') | ||||
|
r14381 | try: | ||
|
r30397 | for line in util.iterfile(fp): | ||
|
r14381 | line = line.rstrip() | ||
ui.note(line + '\n') | ||||
if line.startswith('patching file '): | ||||
pf = util.parsepatchoutput(line) | ||||
printed_file = False | ||||
|
r14564 | files.add(pf) | ||
|
r14381 | elif line.find('with fuzz') >= 0: | ||
fuzz = True | ||||
if not printed_file: | ||||
ui.warn(pf + '\n') | ||||
printed_file = True | ||||
ui.warn(line + '\n') | ||||
elif line.find('saving rejects to file') >= 0: | ||||
ui.warn(line + '\n') | ||||
elif line.find('FAILED') >= 0: | ||||
if not printed_file: | ||||
ui.warn(pf + '\n') | ||||
printed_file = True | ||||
ui.warn(line + '\n') | ||||
finally: | ||||
if files: | ||||
|
r19155 | scmutil.marktouched(repo, files, similarity) | ||
|
r7151 | code = fp.close() | ||
if code: | ||||
raise PatchError(_("patch command failed: %s") % | ||||
|
r37481 | procutil.explainexit(code)) | ||
|
r7151 | return fuzz | ||
|
r24253 | def patchbackend(ui, backend, patchobj, strip, prefix, files=None, | ||
eolmode='strict'): | ||||
|
r9683 | if files is None: | ||
|
r14564 | files = set() | ||
|
r8810 | if eolmode is None: | ||
r33226 | eolmode = ui.config('patch', 'eol') | |||
|
r10101 | if eolmode.lower() not in eolmodes: | ||
|
r26587 | raise error.Abort(_('unsupported line endings type: %s') % eolmode) | ||
|
r10101 | eolmode = eolmode.lower() | ||
|
r8843 | |||
|
r14452 | store = filestore() | ||
|
r7151 | try: | ||
|
r9031 | fp = open(patchobj, 'rb') | ||
|
r7151 | except TypeError: | ||
fp = patchobj | ||||
try: | ||||
|
r24253 | ret = applydiff(ui, fp, backend, store, strip=strip, prefix=prefix, | ||
|
r14452 | eolmode=eolmode) | ||
|
r7151 | finally: | ||
|
r10203 | if fp != patchobj: | ||
fp.close() | ||||
|
r14564 | files.update(backend.close()) | ||
|
r14452 | store.close() | ||
|
r7151 | if ret < 0: | ||
|
r12674 | raise PatchError(_('patch failed to apply')) | ||
|
r7151 | return ret > 0 | ||
|
r24268 | def internalpatch(ui, repo, patchobj, strip, prefix='', files=None, | ||
|
r24254 | eolmode='strict', similarity=0): | ||
|
r14611 | """use builtin patch to apply <patchobj> to the working directory. | ||
returns whether patch was applied with fuzz factor.""" | ||||
backend = workingbackend(ui, repo, similarity) | ||||
|
r24254 | return patchbackend(ui, backend, patchobj, strip, prefix, files, eolmode) | ||
|
r14611 | |||
|
r24260 | def patchrepo(ui, repo, ctx, store, patchobj, strip, prefix, files=None, | ||
|
r14611 | eolmode='strict'): | ||
backend = repobackend(ui, repo, ctx, store) | ||||
|
r24260 | return patchbackend(ui, backend, patchobj, strip, prefix, files, eolmode) | ||
|
r14611 | |||
|
r24259 | def patch(ui, repo, patchname, strip=1, prefix='', files=None, eolmode='strict', | ||
|
r14260 | similarity=0): | ||
|
r8810 | """Apply <patchname> to the working directory. | ||
'eolmode' specifies how end of lines should be handled. It can be: | ||||
- 'strict': inputs are read in binary mode, EOLs are preserved | ||||
- 'crlf': EOLs are ignored when patching and reset to CRLF | ||||
- 'lf': EOLs are ignored when patching and reset to LF | ||||
- None: get it from user settings, default to 'strict' | ||||
'eolmode' is ignored when using an external patcher program. | ||||
Returns whether patch was applied with fuzz factor. | ||||
""" | ||||
|
r7151 | patcher = ui.config('ui', 'patch') | ||
|
r9683 | if files is None: | ||
|
r14564 | files = set() | ||
|
r21553 | if patcher: | ||
return _externalpatch(ui, repo, patcher, patchname, strip, | ||||
files, similarity) | ||||
|
r24259 | return internalpatch(ui, repo, patchname, strip, prefix, files, eolmode, | ||
|
r21553 | similarity) | ||
|
r7151 | |||
|
r35053 | def changedfiles(ui, repo, patchpath, strip=1, prefix=''): | ||
|
r14351 | backend = fsbackend(ui, repo.root) | ||
|
r35053 | prefix = _canonprefix(repo, prefix) | ||
|
r27796 | with open(patchpath, 'rb') as fp: | ||
|
r14255 | changed = set() | ||
for state, values in iterhunks(fp): | ||||
|
r14389 | if state == 'file': | ||
|
r14388 | afile, bfile, first_hunk, gp = values | ||
if gp: | ||||
|
r35053 | gp.path = pathtransform(gp.path, strip - 1, prefix)[1] | ||
|
r14566 | if gp.oldpath: | ||
|
r35053 | gp.oldpath = pathtransform(gp.oldpath, strip - 1, | ||
prefix)[1] | ||||
|
r14566 | else: | ||
|
r24245 | gp = makepatchmeta(backend, afile, bfile, first_hunk, strip, | ||
|
r35053 | prefix) | ||
|
r14566 | changed.add(gp.path) | ||
if gp.op == 'RENAME': | ||||
changed.add(gp.oldpath) | ||||
|
r14389 | elif state not in ('hunk', 'git'): | ||
|
r26587 | raise error.Abort(_('unsupported parser state: %s') % state) | ||
|
r14255 | return changed | ||
|
r10189 | class GitDiffRequired(Exception): | ||
pass | ||||
|
r7198 | |||
|
r23431 | def diffallopts(ui, opts=None, untrusted=False, section='diff'): | ||
|
r23430 | '''return diffopts with all features supported and parsed''' | ||
|
r23433 | return difffeatureopts(ui, opts=opts, untrusted=untrusted, section=section, | ||
|
r23434 | git=True, whitespace=True, formatchanging=True) | ||
|
r23430 | |||
|
r23431 | diffopts = diffallopts | ||
|
r23433 | def difffeatureopts(ui, opts=None, untrusted=False, section='diff', git=False, | ||
|
r23434 | whitespace=False, formatchanging=False): | ||
|
r23432 | '''return diffopts with only opted-in features parsed | ||
Features: | ||||
- git: git-style diffs | ||||
|
r23433 | - whitespace: whitespace options like ignoreblanklines and ignorews | ||
|
r23434 | - formatchanging: options that will likely break or cause correctness issues | ||
with most diff parsers | ||||
|
r23432 | ''' | ||
|
r23295 | def get(key, name=None, getter=ui.configbool, forceplain=None): | ||
if opts: | ||||
v = opts.get(key) | ||||
|
r29948 | # diffopts flags are either None-default (which is passed | ||
# through unchanged, so we can identify unset values), or | ||||
# some other falsey default (eg --unified, which defaults | ||||
# to an empty string). We only want to override the config | ||||
# entries from hgrc with command line values if they | ||||
# appear to have been set, which is any truthy value, | ||||
# True, or False. | ||||
if v or isinstance(v, bool): | ||||
|
r23295 | return v | ||
|
r23296 | if forceplain is not None and ui.plain(): | ||
return forceplain | ||||
|
r34522 | return getter(section, name or key, untrusted=untrusted) | ||
|
r23295 | |||
|
r23434 | # core options, expected to be understood by every diff parser | ||
|
r23429 | buildopts = { | ||
'nodates': get('nodates'), | ||||
'showfunc': get('show_function', 'showfunc'), | ||||
'context': get('unified', getter=ui.config), | ||||
} | ||||
|
r35278 | buildopts['worddiff'] = ui.configbool('experimental', 'worddiff') | ||
|
r36694 | buildopts['xdiff'] = ui.configbool('experimental', 'xdiff') | ||
|
r23429 | |||
|
r23432 | if git: | ||
buildopts['git'] = get('git') | ||||
|
r30788 | |||
|
r30806 | # since this is in the experimental section, we need to call | ||
# ui.configbool directory | ||||
buildopts['showsimilarity'] = ui.configbool('experimental', | ||||
'extendedheader.similarity') | ||||
|
r30788 | # need to inspect the ui object instead of using get() since we want to | ||
# test for an int | ||||
hconf = ui.config('experimental', 'extendedheader.index') | ||||
if hconf is not None: | ||||
hlen = None | ||||
try: | ||||
# the hash config could be an integer (for length of hash) or a | ||||
# word (e.g. short, full, none) | ||||
hlen = int(hconf) | ||||
|
r30819 | if hlen < 0 or hlen > 40: | ||
msg = _("invalid length for extendedheader.index: '%d'\n") | ||||
ui.warn(msg % hlen) | ||||
|
r30788 | except ValueError: | ||
# default value | ||||
if hconf == 'short' or hconf == '': | ||||
hlen = 12 | ||||
elif hconf == 'full': | ||||
hlen = 40 | ||||
elif hconf != 'none': | ||||
msg = _("invalid value for extendedheader.index: '%s'\n") | ||||
ui.warn(msg % hconf) | ||||
finally: | ||||
buildopts['index'] = hlen | ||||
|
r23433 | if whitespace: | ||
buildopts['ignorews'] = get('ignore_all_space', 'ignorews') | ||||
buildopts['ignorewsamount'] = get('ignore_space_change', | ||||
'ignorewsamount') | ||||
buildopts['ignoreblanklines'] = get('ignore_blank_lines', | ||||
'ignoreblanklines') | ||||
|
r34015 | buildopts['ignorewseol'] = get('ignore_space_at_eol', 'ignorewseol') | ||
|
r23434 | if formatchanging: | ||
buildopts['text'] = opts and opts.get('text') | ||||
|
r31822 | binary = None if opts is None else opts.get('binary') | ||
buildopts['nobinary'] = (not binary if binary is not None | ||||
else get('nobinary', forceplain=False)) | ||||
|
r23434 | buildopts['noprefix'] = get('noprefix', forceplain=False) | ||
|
r23432 | |||
|
r31631 | return mdiff.diffopts(**pycompat.strkwargs(buildopts)) | ||
|
r10615 | |||
|
r31274 | def diff(repo, node1=None, node2=None, match=None, changes=None, | ||
|
r34857 | opts=None, losedatafn=None, prefix='', relroot='', copy=None, | ||
hunksfilterfn=None): | ||||
|
r7308 | '''yields diff of changes to files between two nodes, or node and | ||
|
r2874 | working directory. | ||
if node1 is None, use first dirstate parent instead. | ||||
|
r10189 | if node2 is None, compare node1 with working directory. | ||
losedatafn(**kwarg) is a callable run when opts.upgrade=True and | ||||
every time some change cannot be represented with the current | ||||
patch format. Return False to upgrade to git patch format, True to | ||||
accept the loss or raise an exception to abort the diff. It is | ||||
called with the name of current file being diffed as 'fn'. If set | ||||
to None, patches will always be upgraded to git format when | ||||
necessary. | ||||
|
r12167 | |||
prefix is a filename prefix that is prepended to all filenames on | ||||
display (used for subrepos). | ||||
|
r24417 | |||
relroot, if not empty, must be normalized with a trailing /. Any match | ||||
|
r29422 | patterns that fall outside it will be ignored. | ||
copy, if not empty, should contain mappings {dst@y: src@x} of copy | ||||
|
r34857 | information. | ||
hunksfilterfn, if not None, should be a function taking a filectx and | ||||
hunks generator that may yield filtered hunks. | ||||
''' | ||||
|
r34856 | for fctx1, fctx2, hdr, hunks in diffhunks( | ||
repo, node1=node1, node2=node2, | ||||
match=match, changes=changes, opts=opts, | ||||
losedatafn=losedatafn, prefix=prefix, relroot=relroot, copy=copy, | ||||
): | ||||
|
r34857 | if hunksfilterfn is not None: | ||
|
r34909 | # If the file has been removed, fctx2 is None; but this should | ||
# not occur here since we catch removed files early in | ||||
|
r35906 | # logcmdutil.getlinerangerevs() for 'hg log -L'. | ||
|
r34909 | assert fctx2 is not None, \ | ||
'fctx2 unexpectly None in diff hunks filtering' | ||||
|
r34857 | hunks = hunksfilterfn(fctx2, hunks) | ||
|
r31274 | text = ''.join(sum((list(hlines) for hrange, hlines in hunks), [])) | ||
|
r34562 | if hdr and (text or len(hdr) > 1): | ||
yield '\n'.join(hdr) + '\n' | ||||
|
r31274 | if text: | ||
yield text | ||||
def diffhunks(repo, node1=None, node2=None, match=None, changes=None, | ||||
opts=None, losedatafn=None, prefix='', relroot='', copy=None): | ||||
"""Yield diff of changes to files in the form of (`header`, `hunks`) tuples | ||||
where `header` is a list of diff headers and `hunks` is an iterable of | ||||
(`hunkrange`, `hunklines`) tuples. | ||||
See diff() for the meaning of parameters. | ||||
""" | ||||
|
r2874 | |||
if opts is None: | ||||
opts = mdiff.defaultopts | ||||
|
r9725 | if not node1 and not node2: | ||
|
r13878 | node1 = repo.dirstate.p1() | ||
|
r2934 | |||
|
r9123 | def lrugetfilectx(): | ||
cache = {} | ||||
|
r25113 | order = collections.deque() | ||
|
r9123 | def getfilectx(f, ctx): | ||
fctx = ctx.filectx(f, filelog=cache.get(f)) | ||||
if f not in cache: | ||||
if len(cache) > 20: | ||||
|
r16803 | del cache[order.popleft()] | ||
|
r9684 | cache[f] = fctx.filelog() | ||
|
r9123 | else: | ||
order.remove(f) | ||||
order.append(f) | ||||
return fctx | ||||
return getfilectx | ||||
getfilectx = lrugetfilectx() | ||||
|
r2934 | |||
|
r6747 | ctx1 = repo[node1] | ||
|
r7090 | ctx2 = repo[node2] | ||
|
r2874 | |||
|
r24433 | relfiltered = False | ||
if relroot != '' and match.always(): | ||||
# as a special case, create a new matcher with just the relroot | ||||
pats = [relroot] | ||||
match = scmutil.match(ctx2, pats, default='path') | ||||
relfiltered = True | ||||
|
r2874 | if not changes: | ||
|
r7090 | changes = repo.status(ctx1, ctx2, match=match) | ||
|
r6760 | modified, added, removed = changes[:3] | ||
|
r2874 | |||
if not modified and not added and not removed: | ||||
|
r10189 | return [] | ||
|
r24306 | if repo.ui.debugflag: | ||
hexfunc = hex | ||||
else: | ||||
hexfunc = short | ||||
|
r21833 | revs = [hexfunc(node) for node in [ctx1.node(), ctx2.node()] if node] | ||
|
r10189 | |||
|
r29422 | if copy is None: | ||
copy = {} | ||||
if opts.git or opts.upgrade: | ||||
copy = copies.pathcopies(ctx1, ctx2, match=match) | ||||
|
r10189 | |||
|
r24417 | if relroot is not None: | ||
|
r24433 | if not relfiltered: | ||
# XXX this would ideally be done in the matcher, but that is | ||||
# generally meant to 'or' patterns, not 'and' them. In this case we | ||||
# need to 'and' all the patterns from the matcher with relroot. | ||||
def filterrel(l): | ||||
return [f for f in l if f.startswith(relroot)] | ||||
modified = filterrel(modified) | ||||
added = filterrel(added) | ||||
removed = filterrel(removed) | ||||
relfiltered = True | ||||
|
r24417 | # filter out copies where either side isn't inside the relative root | ||
copy = dict(((dst, src) for (dst, src) in copy.iteritems() | ||||
if dst.startswith(relroot) | ||||
and src.startswith(relroot))) | ||||
|
r27900 | modifiedset = set(modified) | ||
addedset = set(added) | ||||
|
r27901 | removedset = set(removed) | ||
|
r27900 | for f in modified: | ||
if f not in ctx1: | ||||
# Fix up added, since merged-in additions appear as | ||||
# modifications during merges | ||||
modifiedset.remove(f) | ||||
addedset.add(f) | ||||
|
r27901 | for f in removed: | ||
if f not in ctx1: | ||||
# Merged-in additions that are then removed are reported as removed. | ||||
# They are not in ctx1, so We don't want to show them in the diff. | ||||
removedset.remove(f) | ||||
|
r27900 | modified = sorted(modifiedset) | ||
added = sorted(addedset) | ||||
|
r27901 | removed = sorted(removedset) | ||
|
r35607 | for dst, src in list(copy.items()): | ||
|
r27902 | if src not in ctx1: | ||
# Files merged in during a merge and then copied/renamed are | ||||
# reported as copies. We want to show them in the diff as additions. | ||||
del copy[dst] | ||||
|
r27900 | |||
|
r17299 | def difffn(opts, losedata): | ||
return trydiff(repo, revs, ctx1, ctx2, modified, added, removed, | ||||
|
r24417 | copy, getfilectx, opts, losedata, prefix, relroot) | ||
|
r10189 | if opts.upgrade and not opts.git: | ||
try: | ||||
def losedata(fn): | ||||
if not losedatafn or not losedatafn(fn=fn): | ||||
|
r16687 | raise GitDiffRequired | ||
|
r10189 | # Buffer the whole output until we are sure it can be generated | ||
return list(difffn(opts.copy(git=False), losedata)) | ||||
except GitDiffRequired: | ||||
return difffn(opts.copy(git=True), None) | ||||
else: | ||||
return difffn(opts, None) | ||||
|
r10818 | def difflabel(func, *args, **kw): | ||
'''yields 2-tuples of (output, label) based on the output of func()''' | ||||
|
r35278 | inlinecolor = False | ||
|
r35367 | if kw.get(r'opts'): | ||
inlinecolor = kw[r'opts'].worddiff | ||||
|
r15201 | headprefixes = [('diff', 'diff.diffline'), | ||
('copy', 'diff.extended'), | ||||
('rename', 'diff.extended'), | ||||
('old', 'diff.extended'), | ||||
('new', 'diff.extended'), | ||||
('deleted', 'diff.extended'), | ||||
|
r30790 | ('index', 'diff.extended'), | ||
|
r30808 | ('similarity', 'diff.extended'), | ||
|
r15201 | ('---', 'diff.file_a'), | ||
('+++', 'diff.file_b')] | ||||
textprefixes = [('@', 'diff.hunk'), | ||||
('-', 'diff.deleted'), | ||||
('+', 'diff.inserted')] | ||||
head = False | ||||
|
r10818 | for chunk in func(*args, **kw): | ||
lines = chunk.split('\n') | ||||
|
r35278 | matches = {} | ||
if inlinecolor: | ||||
matches = _findmatches(lines) | ||||
|
r10818 | for i, line in enumerate(lines): | ||
if i != 0: | ||||
yield ('\n', '') | ||||
|
r15201 | if head: | ||
if line.startswith('@'): | ||||
head = False | ||||
else: | ||||
|
r37489 | if line and not line.startswith((' ', '+', '-', '@', '\\')): | ||
|
r15201 | head = True | ||
|
r10818 | stripline = line | ||
|
r22460 | diffline = False | ||
|
r37489 | if not head and line and line.startswith(('+', '-')): | ||
|
r22460 | # highlight tabs and trailing whitespace, but only in | ||
# changed lines | ||||
|
r10818 | stripline = line.rstrip() | ||
|
r22460 | diffline = True | ||
|
r15201 | prefixes = textprefixes | ||
if head: | ||||
prefixes = headprefixes | ||||
|
r10818 | for prefix, label in prefixes: | ||
if stripline.startswith(prefix): | ||||
|
r22460 | if diffline: | ||
|
r35329 | if i in matches: | ||
for t, l in _inlinediff(lines[i].rstrip(), | ||||
lines[matches[i]].rstrip(), | ||||
label): | ||||
yield (t, l) | ||||
else: | ||||
for token in tabsplitter.findall(stripline): | ||||
|
r36465 | if token.startswith('\t'): | ||
|
r35329 | yield (token, 'diff.tab') | ||
|
r35278 | else: | ||
yield (token, label) | ||||
|
r22460 | else: | ||
yield (stripline, label) | ||||
|
r10818 | break | ||
else: | ||||
yield (line, '') | ||||
if line != stripline: | ||||
yield (line[len(stripline):], 'diff.trailingwhitespace') | ||||
|
r35278 | def _findmatches(slist): | ||
'''Look for insertion matches to deletion and returns a dict of | ||||
correspondences. | ||||
''' | ||||
lastmatch = 0 | ||||
matches = {} | ||||
for i, line in enumerate(slist): | ||||
if line == '': | ||||
continue | ||||
|
r37489 | if line.startswith('-'): | ||
|
r35278 | lastmatch = max(lastmatch, i) | ||
newgroup = False | ||||
for j, newline in enumerate(slist[lastmatch + 1:]): | ||||
if newline == '': | ||||
continue | ||||
|
r37489 | if newline.startswith('-') and newgroup: # too far, no match | ||
|
r35278 | break | ||
|
r37489 | if newline.startswith('+'): # potential match | ||
|
r35278 | newgroup = True | ||
sim = difflib.SequenceMatcher(None, line, newline).ratio() | ||||
if sim > 0.7: | ||||
lastmatch = lastmatch + 1 + j | ||||
matches[i] = lastmatch | ||||
matches[lastmatch] = i | ||||
break | ||||
return matches | ||||
def _inlinediff(s1, s2, operation): | ||||
'''Perform string diff to highlight specific changes.''' | ||||
|
r37489 | operation_skip = ('+', '?') if operation == 'diff.deleted' else ('-', '?') | ||
|
r35278 | if operation == 'diff.deleted': | ||
s2, s1 = s1, s2 | ||||
buff = [] | ||||
# we never want to higlight the leading +- | ||||
if operation == 'diff.deleted' and s2.startswith('-'): | ||||
label = operation | ||||
token = '-' | ||||
s2 = s2[1:] | ||||
s1 = s1[1:] | ||||
elif operation == 'diff.inserted' and s1.startswith('+'): | ||||
label = operation | ||||
token = '+' | ||||
s2 = s2[1:] | ||||
s1 = s1[1:] | ||||
|
r35312 | else: | ||
raise error.ProgrammingError("Case not expected, operation = %s" % | ||||
operation) | ||||
|
r35278 | |||
|
r35384 | s = difflib.ndiff(_nonwordre.split(s2), _nonwordre.split(s1)) | ||
|
r35278 | for part in s: | ||
|
r37489 | if part.startswith(operation_skip) or len(part) == 2: | ||
|
r35278 | continue | ||
l = operation + '.highlight' | ||||
|
r37489 | if part.startswith(' '): | ||
|
r35278 | l = operation | ||
|
r35329 | if part[2:] == '\t': | ||
l = 'diff.tab' | ||||
|
r35278 | if l == label: # contiguous token with same label | ||
token += part[2:] | ||||
continue | ||||
else: | ||||
|
r35311 | buff.append((token, label)) | ||
|
r35278 | label = l | ||
token = part[2:] | ||||
|
r35311 | buff.append((token, label)) | ||
|
r35278 | |||
return buff | ||||
|
r10818 | def diffui(*args, **kw): | ||
'''like diff(), but yields 2-tuples of (output, label) for ui.write()''' | ||||
return difflabel(diff, *args, **kw) | ||||
|
r27900 | def _filepairs(modified, added, removed, copy, opts): | ||
|
r24106 | '''generates tuples (f1, f2, copyop), where f1 is the name of the file | ||
before and f2 is the the name after. For added files, f1 will be None, | ||||
and for removed files, f2 will be None. copyop may be set to None, 'copy' | ||||
or 'rename' (the latter two only if opts.git is set).''' | ||||
gone = set() | ||||
copyto = dict([(v, k) for k, v in copy.items()]) | ||||
addedset, removedset = set(added), set(removed) | ||||
for f in sorted(modified + added + removed): | ||||
copyop = None | ||||
f1, f2 = f, f | ||||
if f in addedset: | ||||
f1 = None | ||||
if f in copy: | ||||
if opts.git: | ||||
f1 = copy[f] | ||||
if f1 in removedset and f1 not in gone: | ||||
copyop = 'rename' | ||||
gone.add(f1) | ||||
else: | ||||
copyop = 'copy' | ||||
elif f in removedset: | ||||
f2 = None | ||||
if opts.git: | ||||
# have we already reported a copy above? | ||||
if (f in copyto and copyto[f] in addedset | ||||
and copy[copyto[f]] == f): | ||||
continue | ||||
yield f1, f2, copyop | ||||
|
r10189 | def trydiff(repo, revs, ctx1, ctx2, modified, added, removed, | ||
|
r24416 | copy, getfilectx, opts, losedatafn, prefix, relroot): | ||
|
r24371 | '''given input data, generate a diff and yield it in blocks | ||
If generating a diff would lose data like flags or binary data and | ||||
losedatafn is not None, it will be called. | ||||
|
r24416 | relroot is removed and prefix is added to every path in the diff output. | ||
If relroot is not empty, this function expects every path in modified, | ||||
added, removed and copy to start with it.''' | ||||
|
r12167 | |||
|
r17946 | def gitindex(text): | ||
if not text: | ||||
|
r19875 | text = "" | ||
|
r17946 | l = len(text) | ||
|
r29341 | s = hashlib.sha1('blob %d\0' % l) | ||
|
r17946 | s.update(text) | ||
|
r35600 | return hex(s.digest()) | ||
|
r17946 | |||
|
r23300 | if opts.noprefix: | ||
aprefix = bprefix = '' | ||||
else: | ||||
aprefix = 'a/' | ||||
bprefix = 'b/' | ||||
|
r24021 | def diffline(f, revs): | ||
|
r24024 | revinfo = ' '.join(["-r %s" % rev for rev in revs]) | ||
|
r24025 | return 'diff %s %s' % (revinfo, f) | ||
|
r17941 | |||
|
r32188 | def isempty(fctx): | ||
return fctx is None or fctx.size() == 0 | ||||
|
r36625 | date1 = dateutil.datestr(ctx1.date()) | ||
date2 = dateutil.datestr(ctx2.date()) | ||||
|
r3967 | |||
|
r10189 | gitmode = {'l': '120000', 'x': '100755', '': '100644'} | ||
|
r2874 | |||
|
r33495 | if relroot != '' and (repo.ui.configbool('devel', 'all-warnings') | ||
|
r24416 | or repo.ui.configbool('devel', 'check-relroot')): | ||
|
r33585 | for f in modified + added + removed + list(copy) + list(copy.values()): | ||
|
r24416 | if f is not None and not f.startswith(relroot): | ||
raise AssertionError( | ||||
"file %s doesn't start with relroot %s" % (f, relroot)) | ||||
|
r27900 | for f1, f2, copyop in _filepairs(modified, added, removed, copy, opts): | ||
|
r24105 | content1 = None | ||
content2 = None | ||||
|
r32187 | fctx1 = None | ||
fctx2 = None | ||||
|
r24103 | flag1 = None | ||
flag2 = None | ||||
|
r24107 | if f1: | ||
|
r32187 | fctx1 = getfilectx(f1, ctx1) | ||
|
r24107 | if opts.git or losedatafn: | ||
flag1 = ctx1.flags(f1) | ||||
if f2: | ||||
|
r32187 | fctx2 = getfilectx(f2, ctx2) | ||
|
r24107 | if opts.git or losedatafn: | ||
flag2 = ctx2.flags(f2) | ||||
|
r32190 | # if binary is True, output "summary" or "base85", but not "text diff" | ||
|
r35868 | if opts.text: | ||
binary = False | ||||
else: | ||||
|
r35969 | binary = any(f.isbinary() for f in [fctx1, fctx2] if f is not None) | ||
|
r24057 | |||
if losedatafn and not opts.git: | ||||
if (binary or | ||||
# copy/rename | ||||
|
r24106 | f2 in copy or | ||
|
r24057 | # empty file creation | ||
|
r32188 | (not f1 and isempty(fctx2)) or | ||
|
r24057 | # empty file deletion | ||
|
r32188 | (isempty(fctx1) and not f2) or | ||
|
r24057 | # create with flags | ||
|
r24101 | (not f1 and flag2) or | ||
|
r24057 | # change flags | ||
|
r24101 | (f1 and f2 and flag1 != flag2)): | ||
|
r24106 | losedatafn(f2 or f1) | ||
|
r10189 | |||
|
r24416 | path1 = f1 or f2 | ||
path2 = f2 or f1 | ||||
path1 = posixpath.join(prefix, path1[len(relroot):]) | ||||
path2 = posixpath.join(prefix, path2[len(relroot):]) | ||||
|
r23998 | header = [] | ||
|
r24022 | if opts.git: | ||
|
r24025 | header.append('diff --git %s%s %s%s' % | ||
|
r24020 | (aprefix, path1, bprefix, path2)) | ||
|
r24101 | if not f1: # added | ||
|
r24025 | header.append('new file mode %s' % gitmode[flag2]) | ||
|
r24101 | elif not f2: # removed | ||
|
r24025 | header.append('deleted file mode %s' % gitmode[flag1]) | ||
|
r23998 | else: # modified/copied/renamed | ||
|
r24000 | mode1, mode2 = gitmode[flag1], gitmode[flag2] | ||
if mode1 != mode2: | ||||
|
r24025 | header.append('old mode %s' % mode1) | ||
header.append('new mode %s' % mode2) | ||||
|
r24055 | if copyop is not None: | ||
|
r30807 | if opts.showsimilarity: | ||
sim = similar.score(ctx1[path1], ctx2[path2]) * 100 | ||||
header.append('similarity index %d%%' % sim) | ||||
|
r24055 | header.append('%s from %s' % (copyop, path1)) | ||
header.append('%s to %s' % (copyop, path2)) | ||||
|
r24024 | elif revs and not repo.ui.quiet: | ||
|
r24022 | header.append(diffline(path1, revs)) | ||
|
r23998 | |||
|
r32189 | # fctx.is | diffopts | what to | is fctx.data() | ||
# binary() | text nobinary git index | output? | outputted? | ||||
# ------------------------------------|---------------------------- | ||||
# yes | no no no * | summary | no | ||||
# yes | no no yes * | base85 | yes | ||||
# yes | no yes no * | summary | no | ||||
# yes | no yes yes 0 | summary | no | ||||
# yes | no yes yes >0 | summary | semi [1] | ||||
# yes | yes * * * | text diff | yes | ||||
# no | * * * * | text diff | yes | ||||
# [1]: hash(fctx.data()) is outputted. so fctx.data() cannot be faked | ||||
|
r32191 | if binary and (not opts.git or (opts.git and opts.nobinary and not | ||
opts.index)): | ||||
# fast path: no binary content will be displayed, content1 and | ||||
# content2 are only used for equivalent test. cmp() could have a | ||||
# fast path. | ||||
if fctx1 is not None: | ||||
content1 = b'\0' | ||||
if fctx2 is not None: | ||||
if fctx1 is not None and not fctx1.cmp(fctx2): | ||||
content2 = b'\0' # not different | ||||
else: | ||||
content2 = b'\0\0' | ||||
else: | ||||
# normal path: load contents | ||||
if fctx1 is not None: | ||||
content1 = fctx1.data() | ||||
if fctx2 is not None: | ||||
content2 = fctx2.data() | ||||
|
r32190 | if binary and opts.git and not opts.nobinary: | ||
|
r23997 | text = mdiff.b85diff(content1, content2) | ||
|
r24056 | if text: | ||
|
r24025 | header.append('index %s..%s' % | ||
|
r24005 | (gitindex(content1), gitindex(content2))) | ||
|
r31274 | hunks = (None, [text]), | ||
|
r23753 | else: | ||
|
r30789 | if opts.git and opts.index > 0: | ||
flag = flag1 | ||||
if flag is None: | ||||
flag = flag2 | ||||
header.append('index %s..%s %s' % | ||||
(gitindex(content1)[0:opts.index], | ||||
gitindex(content2)[0:opts.index], | ||||
gitmode[flag])) | ||||
|
r31273 | uheaders, hunks = mdiff.unidiff(content1, date1, | ||
content2, date2, | ||||
|
r35969 | path1, path2, | ||
binary=binary, opts=opts) | ||||
|
r31271 | header.extend(uheaders) | ||
|
r34856 | yield fctx1, fctx2, header, hunks | ||
|
r2874 | |||
|
r14401 | def diffstatsum(stats): | ||
|
r14437 | maxfile, maxtotal, addtotal, removetotal, binary = 0, 0, 0, 0, False | ||
|
r14401 | for f, a, r, b in stats: | ||
maxfile = max(maxfile, encoding.colwidth(f)) | ||||
|
r14437 | maxtotal = max(maxtotal, a + r) | ||
|
r14401 | addtotal += a | ||
removetotal += r | ||||
binary = binary or b | ||||
|
r14437 | return maxfile, maxtotal, addtotal, removetotal, binary | ||
|
r14401 | |||
|
r7547 | def diffstatdata(lines): | ||
|
r13395 | diffre = re.compile('^diff .*-r [a-z0-9]+\s(.*)$') | ||
|
r14400 | results = [] | ||
|
r15363 | filename, adds, removes, isbinary = None, 0, 0, False | ||
|
r14400 | |||
def addresult(): | ||||
if filename: | ||||
results.append((filename, adds, removes, isbinary)) | ||||
|
r32321 | # inheader is used to track if a line is in the | ||
# header portion of the diff. This helps properly account | ||||
# for lines that start with '--' or '++' | ||||
inheader = False | ||||
|
r7547 | for line in lines: | ||
if line.startswith('diff'): | ||||
|
r14400 | addresult() | ||
|
r32321 | # starting a new file diff | ||
# set numbers to 0 and reset inheader | ||||
inheader = True | ||||
|
r15363 | adds, removes, isbinary = 0, 0, False | ||
|
r18830 | if line.startswith('diff --git a/'): | ||
|
r20972 | filename = gitre.search(line).group(2) | ||
|
r13395 | elif line.startswith('diff -r'): | ||
|
r8761 | # format: "diff -r ... -r ... filename" | ||
|
r13395 | filename = diffre.search(line).group(1) | ||
|
r32321 | elif line.startswith('@@'): | ||
inheader = False | ||||
elif line.startswith('+') and not inheader: | ||||
|
r7547 | adds += 1 | ||
|
r32321 | elif line.startswith('-') and not inheader: | ||
|
r7547 | removes += 1 | ||
|
r15363 | elif (line.startswith('GIT binary patch') or | ||
line.startswith('Binary file')): | ||||
isbinary = True | ||||
|
r14400 | addresult() | ||
return results | ||||
|
r7547 | |||
|
r30407 | def diffstat(lines, width=80): | ||
|
r7547 | output = [] | ||
|
r14402 | stats = diffstatdata(lines) | ||
|
r14437 | maxname, maxtotal, totaladds, totalremoves, hasbinary = diffstatsum(stats) | ||
|
r7547 | |||
countwidth = len(str(maxtotal)) | ||||
|
r9642 | if hasbinary and countwidth < 3: | ||
countwidth = 3 | ||||
|
r9330 | graphwidth = width - countwidth - maxname - 6 | ||
|
r7547 | if graphwidth < 10: | ||
graphwidth = 10 | ||||
|
r9330 | def scale(i): | ||
if maxtotal <= graphwidth: | ||||
return i | ||||
# If diffstat runs out of room it doesn't print anything, | ||||
# which isn't very useful, so always print at least one + or - | ||||
# if there were at least some changes. | ||||
return max(i * graphwidth // maxtotal, int(bool(i))) | ||||
|
r7547 | |||
|
r14402 | for filename, adds, removes, isbinary in stats: | ||
|
r15363 | if isbinary: | ||
|
r9642 | count = 'Bin' | ||
else: | ||||
|
r33104 | count = '%d' % (adds + removes) | ||
|
r9330 | pluses = '+' * scale(adds) | ||
minuses = '-' * scale(removes) | ||||
|
r11611 | output.append(' %s%s | %*s %s%s\n' % | ||
|
r14402 | (filename, ' ' * (maxname - encoding.colwidth(filename)), | ||
countwidth, count, pluses, minuses)) | ||||
|
r7547 | |||
if stats: | ||||
|
r16683 | output.append(_(' %d files changed, %d insertions(+), ' | ||
'%d deletions(-)\n') | ||||
|
r7860 | % (len(stats), totaladds, totalremoves)) | ||
|
r7547 | |||
return ''.join(output) | ||||
|
r10818 | |||
def diffstatui(*args, **kw): | ||||
'''like diffstat(), but yields 2-tuples of (output, label) for | ||||
ui.write() | ||||
''' | ||||
for line in diffstat(*args, **kw).splitlines(): | ||||
if line and line[-1] in '+-': | ||||
name, graph = line.rsplit(' ', 1) | ||||
yield (name + ' ', '') | ||||
|
r33096 | m = re.search(br'\++', graph) | ||
|
r10818 | if m: | ||
yield (m.group(0), 'diffstat.inserted') | ||||
|
r33096 | m = re.search(br'-+', graph) | ||
|
r10818 | if m: | ||
yield (m.group(0), 'diffstat.deleted') | ||||
else: | ||||
yield (line, '') | ||||
yield ('\n', '') | ||||