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

comparison mercurial/patch.py @ 43076:2372284d9457

formatting: blacken the codebase This is using my patch to black (https://github.com/psf/black/pull/826) so we don't un-wrap collection literals. Done with: hg files 'set:**.py - mercurial/thirdparty/** - "contrib/python-zstandard/**"' | xargs black -S # skip-blame mass-reformatting only # no-check-commit reformats foo_bar functions Differential Revision: https://phab.mercurial-scm.org/D6971

author	Augie Fackler <augie@google.com>
date	Sun, 06 Oct 2019 09:45:02 -0400
parents	db33e4f25729
children	687b865b95ad

comparison

equal deleted inserted replaced

-:57875cf423c9
+:2372284d9457
 stringio = util.stringio
 gitre = re.compile(br'diff --git a/(.*) b/(.*)')
 tabsplitter = re.compile(br'(\t+|[^\t]+)')
-wordsplitter = re.compile(br'(\t+| +|[a-zA-Z0-9_\x80-\xff]+|'
+wordsplitter = re.compile(
-b'[^ \ta-zA-Z0-9_\x80-\xff])')
+br'(\t+| +|[a-zA-Z0-9_\x80-\xff]+|' b'[^ \ta-zA-Z0-9_\x80-\xff])'
+)
 PatchError = error.PatchError
 # public functions
 def split(stream):
 '''return an iterator of individual patches from a stream'''
 def isheader(line, inheader):
 if inheader and line.startswith((' ', '\t')):
 # continuation
 return True
 if line.startswith((' ', '-', '+')):
 # Not enough info, keep reading
 # if we are here, we have a very plain patch
 return remainder(cur)
 ## Some facility for extensible patch parsing:
 # list of pairs ("header to match", "data key")
-patchheadermap = [('Date', 'date'),
+patchheadermap = [
-('Branch', 'branch'),
+('Date', 'date'),
-('Node ID', 'nodeid'),
+('Branch', 'branch'),
-]
+('Node ID', 'nodeid'),
+]
 @contextlib.contextmanager
 def extract(ui, fileobj):
 '''extract patch from data read from fileobj.
 yield _extract(ui, fileobj, tmpname, tmpfp)
 finally:
 tmpfp.close()
 os.unlink(tmpname)
 def _extract(ui, fileobj, tmpname, tmpfp):
 # attempt to detect the start of a patch
 # (this heuristic is borrowed from quilt)
-diffre = re.compile(br'^(?:Index:[ \t]|diff[ \t]-|RCS file: |'
+diffre = re.compile(
-br'retrieving revision [0-9]+(\.[0-9]+)*$|'
+br'^(?:Index:[ \t]|diff[ \t]-|RCS file: |'
-br'---[ \t].*?^\+\+\+[ \t]|'
+br'retrieving revision [0-9]+(\.[0-9]+)*$|'
-br'\*\*\*[ \t].*?^---[ \t])',
+br'---[ \t].*?^\+\+\+[ \t]|'
-re.MULTILINE | re.DOTALL)
+br'\*\*\*[ \t].*?^---[ \t])',
+re.MULTILINE | re.DOTALL,
+)
 data = {}
 msg = mail.parse(fileobj)
 subject = msg[r'Subject'] and mail.headdecode(msg[r'Subject'])
 data['user'] = msg[r'From'] and mail.headdecode(msg[r'From'])
 if not subject and not data['user']:
 # Not an email, restore parsed headers if any
-subject = '\n'.join(': '.join(map(encoding.strtolocal, h))
+subject = (
-for h in msg.items()) + '\n'
+'\n'.join(
+': '.join(map(encoding.strtolocal, h)) for h in msg.items()
+)
++ '\n'
+)
 # should try to parse msg['Date']
 parents = []
 if subject:
 if subject.startswith('[PATCH'):
 pend = subject.find(']')
 if pend >= 0:
-subject = subject[pend + 1:].lstrip()
+subject = subject[pend + 1 :].lstrip()
 subject = re.sub(br'\n[ \t]+', ' ', subject)
 ui.debug('Subject: %s\n' % subject)
 if data['user']:
 ui.debug('From: %s\n' % data['user'])
 diffs_seen = 0
 ignoretext = False
 ui.debug('found patch at byte %d\n' % m.start(0))
 diffs_seen += 1
 cfp = stringio()
-for line in payload[:m.start(0)].splitlines():
+for line in payload[: m.start(0)].splitlines():
 if line.startswith('# HG changeset patch') and not hgpatch:
 ui.debug('patch generated by hg export\n')
 hgpatch = True
 hgpatchheader = True
 # drop earlier commit message content
 parents.append(line[9:].lstrip())
 elif line.startswith("# "):
 for header, key in patchheadermap:
 prefix = '# %s ' % header
 if line.startswith(prefix):
-data[key] = line[len(prefix):]
+data[key] = line[len(prefix) :]
 ui.debug('%s: %s\n' % (header, data[key]))
 else:
 hgpatchheader = False
 elif line == '---':
 ignoretext = True
 if diffs_seen:
 data['filename'] = tmpname
 return data
 class patchmeta(object):
 """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
 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.
 """
 def __init__(self, path):
 self.path = path
 self.oldpath = None
 self.mode = None
 self.op = 'MODIFY'
 def ispatching(self, afile, bfile):
 return self._ispatchinga(afile) and self._ispatchingb(bfile)
 def __repr__(self):
 return r"<patchmeta %s %r>" % (self.op, self.path)
 def readgitpatch(lr):
 """extract git-style metadata about patches from <patchname>"""
 # Filter patch for git information
 if gp:
 gitpatches.append(gp)
 return gitpatches
 class linereader(object):
 # simple class to allow pushing lines back into the input stream
 def __init__(self, fp):
 self.fp = fp
 self.buf = []
 return l
 return self.fp.readline()
 def __iter__(self):
 return iter(self.readline, '')
 class abstractbackend(object):
 def __init__(self, ui):
 self.ui = ui
 def exists(self, fname):
 raise NotImplementedError
 def close(self):
 raise NotImplementedError
 class fsbackend(abstractbackend):
 def __init__(self, ui, basedir):
 super(fsbackend, self).__init__(ui)
 self.opener = vfsmod.vfs(basedir)
 self.opener.unlinkpath(fname, ignoremissing=True, rmdir=rmdir)
 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") %
+_("%d out of %d hunks FAILED -- saving rejects to file %s\n")
-(failed, total, fname))
+% (failed, total, fname)
+)
 fp = self.opener(fname, 'w')
 fp.writelines(lines)
 fp.close()
 def exists(self, fname):
 return self.opener.lexists(fname)
 class workingbackend(fsbackend):
 def __init__(self, ui, repo, similarity):
 super(workingbackend, self).__init__(ui, repo.root)
 self.repo = repo
 changed.discard(f)
 if changed:
 scmutil.marktouched(self.repo, changed, self.similarity)
 return sorted(self.changed)
 class filestore(object):
 def __init__(self, maxsize=None):
 self.opener = None
 self.files = {}
 self.created = 0
 self.maxsize = maxsize
 if self.maxsize is None:
-self.maxsize = 4*(2**20)
+self.maxsize = 4 * (2 ** 20)
 self.size = 0
 self.data = {}
 def setfile(self, fname, data, mode, copied=None):
 if self.maxsize < 0 or (len(data) + self.size) <= self.maxsize:
 def close(self):
 if self.opener:
 shutil.rmtree(self.opener.base)
 class repobackend(abstractbackend):
 def __init__(self, ui, repo, ctx, store):
 super(repobackend, self).__init__(ui)
 self.repo = repo
 self.ctx = ctx
 return fname in self.ctx
 def close(self):
 return self.changed | self.removed
 # @@ -start,len +start,len @@ or @@ -start +start @@ if len is 1
 unidesc = re.compile(br'@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@')
 contextdesc = re.compile(br'(?:---|\*\*\*) (\d+)(?:,(\d+))? (?:---|\*\*\*)')
 eolmodes = ['strict', 'crlf', 'lf', 'auto']
 class patchfile(object):
 def __init__(self, ui, gp, backend, store, eolmode='strict'):
 self.fname = gp.path
 self.eolmode = eolmode
 self.missing = False
 if self.mode is None:
 self.mode = (False, False)
 if self.missing:
 self.ui.warn(_("unable to find '%s' for patching\n") % self.fname)
-self.ui.warn(_("(use '--prefix' to apply patch relative to the "
+self.ui.warn(
-"current directory)\n"))
+_(
+"(use '--prefix' to apply patch relative to the "
+"current directory)\n"
+)
+)
 self.hash = {}
 self.dirty = 0
 self.offset = 0
 self.skew = 0
 s = _("patching file %s\n") % self.fname
 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
 lines.append("\n\\ No newline at end of file\n")
 self.backend.writerej(self.fname, len(self.rej), self.hunks, lines)
 def apply(self, h):
 if not h.complete():
-raise PatchError(_("bad hunk #%d %s (%d %d %d %d)") %
+raise PatchError(
-(h.number, h.desc, len(h.a), h.lena, len(h.b),
+_("bad hunk #%d %s (%d %d %d %d)")
-h.lenb))
+% (h.number, h.desc, len(h.a), h.lena, len(h.b), h.lenb)
+)
 self.hunks += 1
 if self.missing:
 self.rej.append(h)
 return -1
 if self.exists and self.create:
 if self.copysource:
-self.ui.warn(_("cannot create %s: destination already "
+self.ui.warn(
-"exists\n") % self.fname)
+_("cannot create %s: destination already " "exists\n")
+% self.fname
+)
 else:
 self.ui.warn(_("file %s already exists\n") % self.fname)
 self.rej.append(h)
 return -1
 self.offset += len(l)
 self.dirty = True
 return 0
 horig = h
-if (self.eolmode in ('crlf', 'lf')
+if (
-or self.eolmode == 'auto' and self.eol):
+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.
 h = h.getnormalized()
 # fast case code
 if self.skew == 0 and diffhelper.testhunk(old, self.lines, oldstart):
 if self.remove:
 self.backend.unlink(self.fname)
 else:
-self.lines[oldstart:oldstart + len(old)] = new
+self.lines[oldstart : oldstart + len(old)] = new
 self.offset += len(new) - len(old)
 self.dirty = True
 return 0
 # ok, we couldn't match the hunk. Lets look for offsets and fuzz it
 self.offset += len(new) - len(old)
 self.skew = l - orig_start
 self.dirty = True
 offset = l - orig_start - fuzzlen
 if fuzzlen:
-msg = _("Hunk #%d succeeded at %d "
+msg = _(
-"with fuzz %d "
+"Hunk #%d succeeded at %d "
-"(offset %d lines).\n")
+"with fuzz %d "
+"(offset %d lines).\n"
+)
 self.printfile(True)
-self.ui.warn(msg %
+self.ui.warn(
-(h.number, l + 1, fuzzlen, offset))
+msg % (h.number, l + 1, fuzzlen, offset)
+)
 else:
-msg = _("Hunk #%d succeeded at %d "
+msg = _(
-"(offset %d lines).\n")
+"Hunk #%d succeeded at %d "
+"(offset %d lines).\n"
+)
 self.ui.note(msg % (h.number, l + 1, offset))
 return fuzzlen
 self.printfile(True)
 self.ui.warn(_("Hunk #%d FAILED at %d\n") % (h.number, orig_start))
 self.rej.append(horig)
 if self.dirty:
 self.writelines(self.fname, self.lines, self.mode)
 self.write_rej()
 return len(self.rej)
 class header(object):
 """patch header
 """
 diffgit_re = re.compile('diff --git a/(.*) b/(.*)$')
 diff_re = re.compile('diff -r .* (.*)$')
 allhunks_re = re.compile('(?:index|deleted file) ')
 pretty_re = re.compile('(?:new file|deleted file) ')
 special_re = re.compile('(?:index|deleted|copy|rename|new mode) ')
 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') %
+fp.write(
-(len(self.hunks),
+_('%d hunks, %d lines changed\n')
-sum([max(h.added, h.removed) for h in self.hunks])))
+% (
+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))
 # 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
+return emptynewfile or any(
-or any(self.special_re.match(h) for h in self.header))
+self.special_re.match(h) for h in self.header
+)
 class recordhunk(object):
 """patch hunk
 XXX shouldn't we merge this with the other hunk class?
 """
-def __init__(self, header, fromline, toline, proc, before, hunk, after,
+def __init__(
-maxcontext=None):
+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:
 def __eq__(self, v):
 if not isinstance(v, recordhunk):
 return False
-return ((v.hunk == self.hunk) and
+return (
-(v.proc == self.proc) and
+(v.hunk == self.hunk)
-(self.fromline == v.fromline) and
+and (v.proc == self.proc)
-(self.header.files() == v.header.files()))
+and (self.fromline == v.fromline)
+and (self.header.files() == v.header.files())
+)
 def __hash__(self):
-return hash((tuple(self.hunk),
+return hash(
-tuple(self.header.files()),
+(
-self.fromline,
+tuple(self.hunk),
-self.proc))
+tuple(self.header.files()),
+self.fromline,
+self.proc,
+)
+)
 def countchanges(self, hunk):
 """hunk -> (n+,n-)"""
 add = len([h for h in hunk if h.startswith('+')])
 rem = len([h for h in hunk if h.startswith('-')])
 that, swap fromline/toline and +/- signs while keep other things
 unchanged.
 """
 m = {'+': '-', '-': '+', '\\': '\\'}
 hunk = ['%s%s' % (m[l[0:1]], l[1:]) for l in self.hunk]
-return recordhunk(self.header, self.toline, self.fromline, self.proc,
+return recordhunk(
-self.before, hunk, self.after)
+self.header,
+self.toline,
+self.fromline,
+self.proc,
+self.before,
+hunk,
+self.after,
+)
 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' %
+fp.write(
-(self.fromline, fromlen, self.toline, tolen,
+'@@ -%d,%d +%d,%d @@%s\n'
-self.proc and (' ' + self.proc)))
+% (
+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)
 def getmessages():
 return {
 'multiple': {
 'apply': _("apply change %d/%d to '%s'?"),
 'discard': _("discard this change to '%s'?"),
 'keep': _("keep this change to '%s'?"),
 'record': _("record this change to '%s'?"),
 },
 'help': {
-'apply': _('[Ynesfdaq?]'
+'apply': _(
-'$$ &Yes, apply this change'
+'[Ynesfdaq?]'
-'$$ &No, skip this change'
+'$$ &Yes, apply this change'
-'$$ &Edit this change manually'
+'$$ &No, skip this change'
-'$$ &Skip remaining changes to this file'
+'$$ &Edit this change manually'
-'$$ Apply remaining changes to this &file'
+'$$ &Skip remaining changes to this file'
-'$$ &Done, skip remaining changes and files'
+'$$ Apply remaining changes to this &file'
-'$$ Apply &all changes to all remaining files'
+'$$ &Done, skip remaining changes and files'
-'$$ &Quit, applying no changes'
+'$$ Apply &all changes to all remaining files'
-'$$ &? (display help)'),
+'$$ &Quit, applying no changes'
-'discard': _('[Ynesfdaq?]'
+'$$ &? (display help)'
-'$$ &Yes, discard this change'
+),
-'$$ &No, skip this change'
+'discard': _(
-'$$ &Edit this change manually'
+'[Ynesfdaq?]'
-'$$ &Skip remaining changes to this file'
+'$$ &Yes, discard this change'
-'$$ Discard remaining changes to this &file'
+'$$ &No, skip this change'
-'$$ &Done, skip remaining changes and files'
+'$$ &Edit this change manually'
-'$$ Discard &all changes to all remaining files'
+'$$ &Skip remaining changes to this file'
-'$$ &Quit, discarding no changes'
+'$$ Discard remaining changes to this &file'
-'$$ &? (display help)'),
+'$$ &Done, skip remaining changes and files'
-'keep': _('[Ynesfdaq?]'
+'$$ Discard &all changes to all remaining files'
-'$$ &Yes, keep this change'
+'$$ &Quit, discarding no changes'
-'$$ &No, skip this change'
+'$$ &? (display help)'
-'$$ &Edit this change manually'
+),
-'$$ &Skip remaining changes to this file'
+'keep': _(
-'$$ Keep remaining changes to this &file'
+'[Ynesfdaq?]'
-'$$ &Done, skip remaining changes and files'
+'$$ &Yes, keep this change'
-'$$ Keep &all changes to all remaining files'
+'$$ &No, skip this change'
-'$$ &Quit, keeping all changes'
+'$$ &Edit this change manually'
-'$$ &? (display help)'),
+'$$ &Skip remaining changes to this file'
-'record': _('[Ynesfdaq?]'
+'$$ Keep remaining changes to this &file'
-'$$ &Yes, record this change'
+'$$ &Done, skip remaining changes and files'
-'$$ &No, skip this change'
+'$$ Keep &all changes to all remaining files'
-'$$ &Edit this change manually'
+'$$ &Quit, keeping all changes'
-'$$ &Skip remaining changes to this file'
+'$$ &? (display help)'
-'$$ Record remaining changes to this &file'
+),
-'$$ &Done, skip remaining changes and files'
+'record': _(
-'$$ Record &all changes to all remaining files'
+'[Ynesfdaq?]'
-'$$ &Quit, recording no changes'
+'$$ &Yes, record this change'
-'$$ &? (display help)'),
+'$$ &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)'
+),
+},
 }
 def filterpatch(ui, headers, match, operation=None):
 """Interactively filter patch chunks into applied-only chunks"""
 messages = getmessages()
 resps = messages['help'][operation]
 # IMPORTANT: keep the last line of this prompt short (<40 english
 # chars is a good target) because of issue6158.
 r = ui.promptchoice("%s\n(enter ? for help) %s" % (query, resps))
 ui.write("\n")
-if r == 8: # ?
+if r == 8:  # ?
 for c, t in ui.extractchoices(resps)[1]:
 ui.write('%s - %s\n' % (c, encoding.lower(t)))
 continue
-elif r == 0: # yes
+elif r == 0:  # yes
 ret = True
-elif r == 1: # no
+elif r == 1:  # no
 ret = False
-elif r == 2: # Edit patch
+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
 # https://mercurial-scm.org/wiki/RecordExtension)
-phelp = '---' + _("""
+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) = pycompat.mkstemp(prefix="hg-editor-",
+)
-suffix=".diff")
+(patchfd, patchfn) = pycompat.mkstemp(
+prefix="hg-editor-", suffix=".diff"
+)
 ncpatchfp = None
 try:
 # Write the initial patch
 f = util.nativeeolwriter(os.fdopen(patchfd, r'wb'))
 chunk.header.write(f)
 chunk.write(f)
-f.write(''.join(['# ' + i + '\n'
+f.write(
-for i in phelp.splitlines()]))
+''.join(['# ' + i + '\n' for i in phelp.splitlines()])
+)
 f.close()
 # Start the editor and wait for it to complete
 editor = ui.geteditor()
-ret = ui.system("%s \"%s\"" % (editor, patchfn),
+ret = ui.system(
-environ={'HGUSER': ui.username()},
+"%s \"%s\"" % (editor, patchfn),
-blockedtag='filterpatch')
+environ={'HGUSER': ui.username()},
+blockedtag='filterpatch',
+)
 if ret != 0:
 ui.warn(_("editor exited with exit code %d\n") % ret)
 continue
 # Remove comment lines
 patchfp = open(patchfn, r'rb')
 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
+elif r == 3:  # Skip
 ret = skipfile = False
-elif r == 4: # file (Record remaining)
+elif r == 4:  # file (Record remaining)
 ret = skipfile = True
-elif r == 5: # done, skip remaining
+elif r == 5:  # done, skip remaining
 ret = skipall = False
-elif r == 6: # all
+elif r == 6:  # all
 ret = skipall = True
-elif r == 7: # quit
+elif r == 7:  # quit
 raise error.Abort(_('user quit'))
 return ret, skipfile, skipall, newpatches
 seen = set()
-applied = {}        # 'filename' -> [] of chunks
+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
 continue
 seen.add(hdr)
 if skipall is None:
 h.pretty(ui)
 files = h.files()
-msg = (_('examine changes to %s?') %
+msg = _('examine changes to %s?') % _(' and ').join(
-_(' and ').join("'%s'" % f for f in files))
+"'%s'" % f for f in files
+)
 if all(match.exact(f) for f in files):
 r, skipall, np = True, None, None
 else:
 r, skipfile, skipall, np = prompt(skipfile, skipall, msg, None)
 if not r:
 chunk.pretty(ui)
 if total == 1:
 msg = messages['single'][operation] % chunk.filename()
 else:
 idx = pos - len(h.hunks) + i
-msg = messages['multiple'][operation] % (idx, total,
+msg = messages['multiple'][operation] % (
-chunk.filename())
+idx,
-r, skipfile, skipall, newpatches = prompt(skipfile,
+total,
-skipall, msg, chunk)
+chunk.filename(),
+)
+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)
 if fixoffset:
 newhunk.toline += fixoffset
 applied[newhunk.filename()].append(newhunk)
 else:
 fixoffset += chunk.removed - chunk.added
-return (sum([h for h in applied.itervalues()
+return (
-if h[0].special() or len(h) > 1], []), {})
+sum(
+[h for h in applied.itervalues() if h[0].special() or len(h) > 1],
+[],
+),
+{},
+)
 class hunk(object):
 def __init__(self, desc, num, lr, context):
 self.number = num
 self.desc = desc
 self.hunk = [desc]
 else:
 self.lenb = int(self.lenb)
 self.starta = int(self.starta)
 self.startb = int(self.startb)
 try:
-diffhelper.addlines(lr, self.hunk, self.lena, self.lenb,
+diffhelper.addlines(
-self.a, self.b)
+lr, self.hunk, self.lena, self.lenb, self.a, self.b
+)
 except error.ParseError as e:
 raise PatchError(_("bad hunk #%d: %s") % (self.number, e))
 # 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:
 if l.startswith('- ') or l.startswith('! '):
 u = '-' + s
 elif l.startswith('  '):
 u = ' ' + s
 else:
-raise PatchError(_("bad hunk #%d old text line %d") %
+raise PatchError(
-(self.number, x))
+_("bad hunk #%d old text line %d") % (self.number, x)
+)
 self.a.append(u)
 self.hunk.append(u)
 l = lr.readline()
 if l.startswith(br'\ '):
 elif len(self.b) == 0:
 # line deletions, new block is empty
 lr.push(l)
 break
 else:
-raise PatchError(_("bad hunk #%d old text line %d") %
+raise PatchError(
-(self.number, x))
+_("bad hunk #%d old text line %d") % (self.number, x)
+)
 self.b.append(s)
 while True:
 if hunki >= len(self.hunk):
 h = ""
 else:
 # 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.desc = "@@ -%d,%d +%d,%d @@\n" % (
-self.startb, self.lenb)
+self.starta,
+self.lena,
+self.startb,
+self.lenb,
+)
 self.hunk[0] = self.desc
 self._fixnewline(lr)
 def _fixnewline(self, lr):
 l = lr.readline()
 else:
 break
 bot = min(fuzz, bot)
 top = min(fuzz, top)
-return old[top:len(old) - bot], new[top:len(new) - bot], top
+return old[top : len(old) - bot], new[top : len(new) - bot], top
 return old, new, 0
 def fuzzit(self, fuzz, toponly):
 old, new, top = self._fuzzit(self.a, self.b, fuzz, toponly)
 oldstart = self.starta + top
 oldstart -= 1
 if self.lenb and newstart > 0:
 newstart -= 1
 return old, oldstart, new, newstart
 class binhunk(object):
 'A binary patch file.'
 def __init__(self, lr, fname):
 self.text = None
 self.delta = False
 self.hunk = ['GIT binary patch\n']
 self._fname = fname
 return l.rstrip('\r\n')
 while True:
 line = getline(lr, self.hunk)
 if not line:
-raise PatchError(_('could not extract "%s" binary data')
+raise PatchError(
-% self._fname)
+_('could not extract "%s" binary data') % self._fname
+)
 if line.startswith('literal '):
 size = int(line[8:].rstrip())
 break
 if line.startswith('delta '):
 size = int(line[6:].rstrip())
 else:
 l = ord(l) - ord('a') + 27
 try:
 dec.append(util.b85decode(line[1:])[:l])
 except ValueError as e:
-raise PatchError(_('could not decode "%s" binary patch: %s')
+raise PatchError(
-% (self._fname, stringutil.forcebytestr(e)))
+_('could not decode "%s" binary patch: %s')
+% (self._fname, stringutil.forcebytestr(e))
+)
 line = getline(lr, self.hunk)
 text = zlib.decompress(''.join(dec))
 if len(text) != size:
-raise PatchError(_('"%s" length is %d bytes, should be %d')
+raise PatchError(
-% (self._fname, len(text), size))
+_('"%s" length is %d bytes, should be %d')
+% (self._fname, len(text), size)
+)
 self.text = text
 def parsefilename(str):
 # --- filename \t|space stuff
 s = str[4:].rstrip('\r\n')
 i = s.find('\t')
 if i < 0:
 i = s.find(' ')
 if i < 0:
 return s
 return s[:i]
 def reversehunks(hunks):
 '''reverse the signs in the hunks given as argument
 This function operates on hunks coming out of patch.filterpatch, that is
 for c in hunks:
 if util.safehasattr(c, 'reversehunk'):
 c = c.reversehunk()
 newhunks.append(c)
 return newhunks
 def parsepatch(originalchunks, maxcontext=None):
 """patch -> [] of headers -> [] of hunks
 If maxcontext is not None, trim context lines if necessary.
 7
 @@ -8,1 +9,2 @@
 8
 +9
 """
 class parser(object):
 """patch parsing state machine"""
 def __init__(self):
 self.fromline = 0
 self.toline = 0
 self.proc = ''
 self.header = None
 self.toline = int(tostart)
 self.proc = proc
 def addcontext(self, context):
 if self.hunk:
-h = recordhunk(self.header, self.fromline, self.toline,
+h = recordhunk(
-self.proc, self.before, self.hunk, context, maxcontext)
+self.header,
+self.fromline,
+self.toline,
+self.proc,
+self.before,
+self.hunk,
+context,
+maxcontext,
+)
 self.header.hunks.append(h)
 self.fromline += len(self.before) + h.removed
 self.toline += len(self.before) + h.added
 self.before = []
 self.hunk = []
 h = header(hdr)
 self.headers.append(h)
 self.header = h
 def addother(self, line):
-pass # 'other' lines are ignored
+pass  # 'other' lines are ignored
 def finished(self):
 self.addcontext([])
 return self.headers
 transitions = {
-'file': {'context': addcontext,
+'file': {
-'file': newfile,
+'context': addcontext,
-'hunk': addhunk,
+'file': newfile,
-'range': addrange},
+'hunk': addhunk,
-'context': {'file': newfile,
+'range': addrange,
-'hunk': addhunk,
+},
-'range': addrange,
+'context': {
-'other': addother},
+'file': newfile,
-'hunk': {'context': addcontext,
+'hunk': addhunk,
-'file': newfile,
+'range': addrange,
-'range': addrange},
+'other': addother,
-'range': {'context': addcontext,
+},
-'hunk': addhunk},
+'hunk': {'context': addcontext, 'file': newfile, 'range': addrange},
+'range': {'context': addcontext, 'hunk': addhunk},
 'other': {'other': addother},
 }
 p = parser()
 fp = stringio()
 fp.write(''.join(originalchunks))
 fp.seek(0)
 state = 'context'
 for newstate, data in scanpatch(fp):
 try:
 p.transitions[state][newstate](p, data)
 except KeyError:
-raise PatchError('unhandled transition: %s -> %s' %
+raise PatchError(
-(state, newstate))
+'unhandled transition: %s -> %s' % (state, newstate)
+)
 state = newstate
 del fp
 return p.finished()
 def pathtransform(path, strip, prefix):
 '''turn a path from a patch into a path suitable for the repository
 prefix, if not empty, is expected to be normalized with a / at the end.
 return '', prefix + path.rstrip()
 count = strip
 while count > 0:
 i = path.find('/', i)
 if i == -1:
-raise PatchError(_("unable to strip away %d of %d dirs from %s") %
+raise PatchError(
-(count, strip, path))
+_("unable to strip away %d of %d dirs from %s")
+% (count, strip, path)
+)
 i += 1
 # consume '//' in the path
-while i < pathlen - 1 and path[i:i + 1] == '/':
+while i < pathlen - 1 and path[i : i + 1] == '/':
 i += 1
 count -= 1
 return path[:i].lstrip(), prefix + path[i:].rstrip()
 def makepatchmeta(backend, afile_orig, bfile_orig, hunk, strip, prefix):
 nulla = afile_orig == "/dev/null"
 nullb = bfile_orig == "/dev/null"
 create = nulla and hunk.starta == 0 and hunk.lena == 0
 goodb = not nullb and backend.exists(bfile)
 missing = not goodb and not gooda and not create
 # some diff programs apparently produce patches where the afile is
 # not /dev/null, but afile starts with bfile
-abasedir = afile[:afile.rfind('/') + 1]
+abasedir = afile[: afile.rfind('/') + 1]
-bbasedir = bfile[:bfile.rfind('/') + 1]
+bbasedir = bfile[: bfile.rfind('/') + 1]
-if (missing and abasedir == bbasedir and afile.startswith(bfile)
+if (
-and hunk.starta == 0 and hunk.lena == 0):
+missing
+and abasedir == bbasedir
+and afile.startswith(bfile)
+and hunk.starta == 0
+and hunk.lena == 0
+):
 create = True
 missing = False
 # 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))
+isbackup = abase == bbase and bfile.startswith(afile)
 fname = None
 if not missing:
 if gooda and goodb:
 if isbackup:
 fname = afile
 gp.op = 'ADD'
 elif remove:
 gp.op = 'DELETE'
 return gp
 def scanpatch(fp):
 """like patch.iterhunks, but yield different events
 - ('file',    [header_lines + fromfile + tofile])
 - ('context', [context_lines])
 break
 return lines
 for line in iter(lr.readline, ''):
 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]
 if m:
 yield 'range', m.groups()
 else:
 yield 'other', line
 def scangitpatch(lr, firstline):
 """
 Git patches can emit:
 - rename a to b
 - change b
 gitlr.push(firstline)
 gitpatches = readgitpatch(gitlr)
 fp.seek(pos)
 return gitpatches
 def iterhunks(fp):
 """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.
 for x in iter(lr.readline, ''):
 if state == BFILE and (
 (not context and x.startswith('@'))
 or (context is not False and x.startswith('***************'))
-or x.startswith('GIT binary patch')):
+or x.startswith('GIT binary patch')
+):
 gp = None
-if (gitpatches and
+if gitpatches and gitpatches[-1].ispatching(afile, bfile):
-gitpatches[-1].ispatching(afile, bfile)):
 gp = gitpatches.pop()
 if x.startswith('GIT binary patch'):
 h = binhunk(lr, gp.path)
 else:
 if context is None and x.startswith('***************'):
 if not m:
 continue
 if gitpatches is None:
 # scan whole input for git metadata
 gitpatches = scangitpatch(lr, x)
-yield 'git', [g.copy() for g in gitpatches
+yield 'git', [
-if g.op in ('COPY', 'RENAME')]
+g.copy() for g in gitpatches if g.op in ('COPY', 'RENAME')
+]
 gitpatches.reverse()
 afile = 'a/' + m.group(1)
 bfile = 'b/' + m.group(2)
 while gitpatches and not gitpatches[-1].ispatching(afile, bfile):
 gp = gitpatches.pop()
 yield 'file', ('a/' + gp.path, 'b/' + gp.path, None, gp.copy())
 if not gitpatches:
-raise PatchError(_('failed to synchronize metadata for "%s"')
+raise PatchError(
-% afile[2:])
+_('failed to synchronize metadata for "%s"') % afile[2:]
+)
 newfile = True
 elif x.startswith('---'):
 # check for a unified diff
 l2 = lr.readline()
 if not l2.startswith('+++'):
 while gitpatches:
 gp = gitpatches.pop()
 yield 'file', ('a/' + gp.path, 'b/' + gp.path, None, gp.copy())
 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 pycompat.bytestr(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])
+cmd = ord(binchunk[i : i + 1])
 i += 1
-if (cmd & 0x80):
+if cmd & 0x80:
 offset = 0
 size = 0
-if (cmd & 0x01):
+if cmd & 0x01:
-offset = ord(binchunk[i:i + 1])
+offset = ord(binchunk[i : i + 1])
 i += 1
-if (cmd & 0x02):
+if cmd & 0x02:
-offset |= ord(binchunk[i:i + 1]) << 8
+offset |= ord(binchunk[i : i + 1]) << 8
 i += 1
-if (cmd & 0x04):
+if cmd & 0x04:
-offset |= ord(binchunk[i:i + 1]) << 16
+offset |= ord(binchunk[i : i + 1]) << 16
 i += 1
-if (cmd & 0x08):
+if cmd & 0x08:
-offset |= ord(binchunk[i:i + 1]) << 24
+offset |= ord(binchunk[i : i + 1]) << 24
 i += 1
-if (cmd & 0x10):
+if cmd & 0x10:
-size = ord(binchunk[i:i + 1])
+size = ord(binchunk[i : i + 1])
 i += 1
-if (cmd & 0x20):
+if cmd & 0x20:
-size |= ord(binchunk[i:i + 1]) << 8
+size |= ord(binchunk[i : i + 1]) << 8
 i += 1
-if (cmd & 0x40):
+if cmd & 0x40:
-size |= ord(binchunk[i:i + 1]) << 16
+size |= ord(binchunk[i : i + 1]) << 16
 i += 1
 if size == 0:
 size = 0x10000
 offset_end = offset + size
 out += data[offset:offset_end]
 i += cmd
 else:
 raise PatchError(_('unexpected delta opcode 0'))
 return out
 def applydiff(ui, fp, backend, store, strip=1, prefix='', eolmode='strict'):
 """Reads a patch from fp and tries to apply it.
 Returns 0 for a clean patch, -1 if any rejects were found and 1 if
 there was any fuzz.
 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'.
 """
-return _applydiff(ui, fp, patchfile, backend, store, strip=strip,
+return _applydiff(
-prefix=prefix, eolmode=eolmode)
+ui,
+fp,
+patchfile,
+backend,
+store,
+strip=strip,
+prefix=prefix,
+eolmode=eolmode,
+)
 def _canonprefix(repo, prefix):
 if prefix:
 prefix = pathutil.canonpath(repo.root, repo.getcwd(), prefix)
 if prefix != '':
 prefix += '/'
 return prefix
-def _applydiff(ui, fp, patcher, backend, store, strip=1, prefix='',
-eolmode='strict'):
+def _applydiff(
+ui, fp, patcher, backend, store, strip=1, prefix='', eolmode='strict'
+):
 prefix = _canonprefix(backend.repo, prefix)
 def pstrip(p):
 return pathtransform(p, strip - 1, prefix)[1]
 rejects = 0
 err = 0
 if gp:
 gp.path = pstrip(gp.path)
 if gp.oldpath:
 gp.oldpath = pstrip(gp.oldpath)
 else:
-gp = makepatchmeta(backend, afile, bfile, first_hunk, strip,
+gp = makepatchmeta(
-prefix)
+backend, afile, bfile, first_hunk, strip, prefix
+)
 if gp.op == 'RENAME':
 backend.unlink(gp.oldpath)
 if not first_hunk:
 if gp.op == 'DELETE':
 backend.unlink(gp.path)
 data, mode = None, None
 if gp.op in ('RENAME', 'COPY'):
 data, mode = store.getfile(gp.oldpath)[:2]
 if data is None:
 # This means that the old path does not exist
-raise PatchError(_("source file '%s' does not exist")
+raise PatchError(
-% gp.oldpath)
+_("source file '%s' does not exist") % gp.oldpath
+)
 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')
+if gp.op in ('ADD', 'RENAME', 'COPY') and backend.exists(
-and backend.exists(gp.path)):
+gp.path
-raise PatchError(_("cannot create %s: destination "
+):
-"already exists") % gp.path)
+raise PatchError(
+_("cannot create %s: destination " "already exists")
+% gp.path
+)
 backend.setfile(gp.path, data, mode, gp.oldpath)
 continue
 try:
-current_file = patcher(ui, gp, backend, store,
+current_file = patcher(ui, gp, backend, store, eolmode=eolmode)
-eolmode=eolmode)
 except PatchError as inst:
 ui.warn(str(inst) + '\n')
 current_file = None
 rejects += 1
 continue
 if rejects:
 return -1
 return err
-def _externalpatch(ui, repo, patcher, patchname, strip, files,
-similarity):
+def _externalpatch(ui, repo, patcher, patchname, strip, files, similarity):
 """use <patcher> to apply <patchname> to the working directory.
 returns whether patch was applied with fuzz factor."""
 fuzz = False
 args = []
 cwd = repo.root
 if cwd:
 args.append('-d %s' % procutil.shellquote(cwd))
-cmd = ('%s %s -p%d < %s'
+cmd = '%s %s -p%d < %s' % (
-% (patcher, ' '.join(args), strip, procutil.shellquote(patchname)))
+patcher,
+' '.join(args),
+strip,
+procutil.shellquote(patchname),
+)
 ui.debug('Using external patch tool: %s\n' % cmd)
 fp = procutil.popen(cmd, 'rb')
 try:
 for line in util.iterfile(fp):
 line = line.rstrip()
 finally:
 if files:
 scmutil.marktouched(repo, files, similarity)
 code = fp.close()
 if code:
-raise PatchError(_("patch command failed: %s") %
+raise PatchError(
-procutil.explainexit(code))
+_("patch command failed: %s") % procutil.explainexit(code)
+)
 return fuzz
-def patchbackend(ui, backend, patchobj, strip, prefix, files=None,
-eolmode='strict'):
+def patchbackend(
+ui, backend, patchobj, strip, prefix, files=None, eolmode='strict'
+):
 if files is None:
 files = set()
 if eolmode is None:
 eolmode = ui.config('patch', 'eol')
 if eolmode.lower() not in eolmodes:
 try:
 fp = open(patchobj, 'rb')
 except TypeError:
 fp = patchobj
 try:
-ret = applydiff(ui, fp, backend, store, strip=strip, prefix=prefix,
+ret = applydiff(
-eolmode=eolmode)
+ui, fp, backend, store, strip=strip, prefix=prefix, eolmode=eolmode
+)
 finally:
 if fp != patchobj:
 fp.close()
 files.update(backend.close())
 store.close()
 if ret < 0:
 raise PatchError(_('patch failed to apply'))
 return ret > 0
-def internalpatch(ui, repo, patchobj, strip, prefix='', files=None,
-eolmode='strict', similarity=0):
+def internalpatch(
+ui,
+repo,
+patchobj,
+strip,
+prefix='',
+files=None,
+eolmode='strict',
+similarity=0,
+):
 """use builtin patch to apply <patchobj> to the working directory.
 returns whether patch was applied with fuzz factor."""
 backend = workingbackend(ui, repo, similarity)
 return patchbackend(ui, backend, patchobj, strip, prefix, files, eolmode)
-def patchrepo(ui, repo, ctx, store, patchobj, strip, prefix, files=None,
-eolmode='strict'):
+def patchrepo(
+ui, repo, ctx, store, patchobj, strip, prefix, files=None, eolmode='strict'
+):
 backend = repobackend(ui, repo, ctx, store)
 return patchbackend(ui, backend, patchobj, strip, prefix, files, eolmode)
-def patch(ui, repo, patchname, strip=1, prefix='', files=None, eolmode='strict',
-similarity=0):
+def patch(
+ui,
+repo,
+patchname,
+strip=1,
+prefix='',
+files=None,
+eolmode='strict',
+similarity=0,
+):
 """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
 """
 patcher = ui.config('ui', 'patch')
 if files is None:
 files = set()
 if patcher:
-return _externalpatch(ui, repo, patcher, patchname, strip,
+return _externalpatch(
-files, similarity)
+ui, repo, patcher, patchname, strip, files, similarity
-return internalpatch(ui, repo, patchname, strip, prefix, files, eolmode,
+)
-similarity)
+return internalpatch(
+ui, repo, patchname, strip, prefix, files, eolmode, similarity
+)
 def changedfiles(ui, repo, patchpath, strip=1, prefix=''):
 backend = fsbackend(ui, repo.root)
 prefix = _canonprefix(repo, prefix)
 with open(patchpath, 'rb') as fp:
 if state == 'file':
 afile, bfile, first_hunk, gp = values
 if gp:
 gp.path = pathtransform(gp.path, strip - 1, prefix)[1]
 if gp.oldpath:
-gp.oldpath = pathtransform(gp.oldpath, strip - 1,
+gp.oldpath = pathtransform(
-prefix)[1]
+gp.oldpath, strip - 1, prefix
+)[1]
 else:
-gp = makepatchmeta(backend, afile, bfile, first_hunk, strip,
+gp = makepatchmeta(
-prefix)
+backend, afile, bfile, first_hunk, strip, prefix
+)
 changed.add(gp.path)
 if gp.op == 'RENAME':
 changed.add(gp.oldpath)
 elif state not in ('hunk', 'git'):
 raise error.Abort(_('unsupported parser state: %s') % state)
 return changed
 class GitDiffRequired(Exception):
 pass
 diffopts = diffutil.diffallopts
 diffallopts = diffutil.diffallopts
 difffeatureopts = diffutil.difffeatureopts
-def diff(repo, node1=None, node2=None, match=None, changes=None,
-opts=None, losedatafn=None, pathfn=None, copy=None,
+def diff(
-copysourcematch=None, hunksfilterfn=None):
+repo,
+node1=None,
+node2=None,
+match=None,
+changes=None,
+opts=None,
+losedatafn=None,
+pathfn=None,
+copy=None,
+copysourcematch=None,
+hunksfilterfn=None,
+):
 '''yields diff of changes to files between two nodes, or node and
 working directory.
 if node1 is None, use first dirstate parent instead.
 if node2 is None, compare node1 with working directory.
 ctx1 = repo[node1]
 ctx2 = repo[node2]
 for fctx1, fctx2, hdr, hunks in diffhunks(
-repo, ctx1=ctx1, ctx2=ctx2, match=match, changes=changes, opts=opts,
+repo,
-losedatafn=losedatafn, pathfn=pathfn, copy=copy,
+ctx1=ctx1,
-copysourcematch=copysourcematch):
+ctx2=ctx2,
+match=match,
+changes=changes,
+opts=opts,
+losedatafn=losedatafn,
+pathfn=pathfn,
+copy=copy,
+copysourcematch=copysourcematch,
+):
 if hunksfilterfn is not None:
 # If the file has been removed, fctx2 is None; but this should
 # not occur here since we catch removed files early in
 # logcmdutil.getlinerangerevs() for 'hg log -L'.
-assert fctx2 is not None, (
+assert (
-'fctx2 unexpectly None in diff hunks filtering')
+fctx2 is not None
+), 'fctx2 unexpectly None in diff hunks filtering'
 hunks = hunksfilterfn(fctx2, hunks)
 text = ''.join(sum((list(hlines) for hrange, hlines in hunks), []))
 if hdr and (text or len(hdr) > 1):
 yield '\n'.join(hdr) + '\n'
 if text:
 yield text
-def diffhunks(repo, ctx1, ctx2, match=None, changes=None, opts=None,
-losedatafn=None, pathfn=None, copy=None, copysourcematch=None):
+def diffhunks(
+repo,
+ctx1,
+ctx2,
+match=None,
+changes=None,
+opts=None,
+losedatafn=None,
+pathfn=None,
+copy=None,
+copysourcematch=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.
 opts = mdiff.defaultopts
 def lrugetfilectx():
 cache = {}
 order = collections.deque()
 def getfilectx(f, ctx):
 fctx = ctx.filectx(f, filelog=cache.get(f))
 if f not in cache:
 if len(cache) > 20:
 del cache[order.popleft()]
 cache[f] = fctx.filelog()
 else:
 order.remove(f)
 order.append(f)
 return fctx
 return getfilectx
 getfilectx = lrugetfilectx()
 if not changes:
 changes = ctx1.status(ctx2, match=match)
 modified, added, removed = changes[:3]
 copy = copies.pathcopies(ctx1, ctx2, match=match)
 if copysourcematch:
 # filter out copies where source side isn't inside the matcher
 # (copies.pathcopies() already filtered out the destination)
-copy = {dst: src for dst, src in copy.iteritems()
+copy = {
-if copysourcematch(src)}
+dst: src for dst, src in copy.iteritems() if copysourcematch(src)
+}
 modifiedset = set(modified)
 addedset = set(added)
 removedset = set(removed)
 for f in modified:
 # 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]
 prefetchmatch = scmutil.matchfiles(
-repo, list(modifiedset | addedset | removedset))
+repo, list(modifiedset | addedset | removedset)
+)
 scmutil.prefetchfiles(repo, [ctx1.rev(), ctx2.rev()], prefetchmatch)
 def difffn(opts, losedata):
-return trydiff(repo, revs, ctx1, ctx2, modified, added, removed,
+return trydiff(
-copy, getfilectx, opts, losedata, pathfn)
+repo,
+revs,
+ctx1,
+ctx2,
+modified,
+added,
+removed,
+copy,
+getfilectx,
+opts,
+losedata,
+pathfn,
+)
 if opts.upgrade and not opts.git:
 try:
 def losedata(fn):
 if not losedatafn or not losedatafn(fn=fn):
 raise GitDiffRequired
 # 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)
 def diffsinglehunk(hunklines):
 """yield tokens for a list of lines in a single hunk"""
 for line in hunklines:
 # chomp
 yield (token, 'diff.tab')
 else:
 yield (token, label)
 if chompline != stripline:
-yield (chompline[len(stripline):], 'diff.trailingwhitespace')
+yield (chompline[len(stripline) :], 'diff.trailingwhitespace')
 if chompline != line:
-yield (line[len(chompline):], '')
+yield (line[len(chompline) :], '')
 def diffsinglehunkinline(hunklines):
 """yield tokens for a list of lines in a single hunk, with inline colors"""
 # prepare deleted, and inserted content
 a = ''
 atokens.append((changed, token))
 for token in mdiff.splitnewlines(''.join(bl[b1:b2])):
 btokens.append((changed, token))
 # yield deleted tokens, then inserted ones
-for prefix, label, tokens in [('-', 'diff.deleted', atokens),
+for prefix, label, tokens in [
-('+', 'diff.inserted', btokens)]:
+('-', 'diff.deleted', atokens),
+('+', 'diff.inserted', btokens),
+]:
 nextisnewline = True
 for changed, token in tokens:
 if nextisnewline:
 yield (prefix, label)
 nextisnewline = False
 # special handling line end
 isendofline = token.endswith('\n')
 if isendofline:
-chomp = token[:-1] # chomp
+chomp = token[:-1]  # chomp
 if chomp.endswith('\r'):
 chomp = chomp[:-1]
-endofline = token[len(chomp):]
+endofline = token[len(chomp) :]
-token = chomp.rstrip() # detect spaces at the end
+token = chomp.rstrip()  # detect spaces at the end
-endspaces = chomp[len(token):]
+endspaces = chomp[len(token) :]
 # scan tabs
 for maybetab in tabsplitter.findall(token):
 if b'\t' == maybetab[0:1]:
 currentlabel = 'diff.tab'
 else:
 if endspaces:
 yield (endspaces, 'diff.trailingwhitespace')
 yield (endofline, '')
 nextisnewline = True
 def difflabel(func, *args, **kw):
 '''yields 2-tuples of (output, label) based on the output of func()'''
 if kw.get(r'opts') and kw[r'opts'].worddiff:
 dodiffhunk = diffsinglehunkinline
 else:
 dodiffhunk = diffsinglehunk
-headprefixes = [('diff', 'diff.diffline'),
+headprefixes = [
-('copy', 'diff.extended'),
+('diff', 'diff.diffline'),
-('rename', 'diff.extended'),
+('copy', 'diff.extended'),
-('old', 'diff.extended'),
+('rename', 'diff.extended'),
-('new', 'diff.extended'),
+('old', 'diff.extended'),
-('deleted', 'diff.extended'),
+('new', 'diff.extended'),
-('index', 'diff.extended'),
+('deleted', 'diff.extended'),
-('similarity', 'diff.extended'),
+('index', 'diff.extended'),
-('---', 'diff.file_a'),
+('similarity', 'diff.extended'),
-('+++', 'diff.file_b')]
+('---', 'diff.file_a'),
-textprefixes = [('@', 'diff.hunk'),
+('+++', 'diff.file_b'),
-# - and + are handled by diffsinglehunk
+]
-]
+textprefixes = [
+('@', 'diff.hunk'),
+# - and + are handled by diffsinglehunk
+]
 head = False
 # buffers a hunk, i.e. adjacent "-", "+" lines without other changes.
 hunkbuffer = []
 def consumehunkbuffer():
 if hunkbuffer:
 for token in dodiffhunk(hunkbuffer):
 yield token
 hunkbuffer[:] = []
 stripline = line.rstrip()
 for prefix, label in prefixes:
 if stripline.startswith(prefix):
 yield (stripline, label)
 if line != stripline:
-yield (line[len(stripline):],
+yield (
-'diff.trailingwhitespace')
+line[len(stripline) :],
+'diff.trailingwhitespace',
+)
 break
 else:
 yield (line, '')
 if i + 1 < linecount:
 yield ('\n', '')
 for token in consumehunkbuffer():
 yield token
 def diffui(*args, **kw):
 '''like diff(), but yields 2-tuples of (output, label) for ui.write()'''
 return difflabel(diff, *args, **kw)
 def _filepairs(modified, added, removed, copy, opts):
 '''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'
 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
+if (
-and copy[copyto[f]] == f):
+f in copyto
+and copyto[f] in addedset
+and copy[copyto[f]] == f
+):
 continue
 yield f1, f2, copyop
-def trydiff(repo, revs, ctx1, ctx2, modified, added, removed,
-copy, getfilectx, opts, losedatafn, pathfn):
+def trydiff(
+repo,
+revs,
+ctx1,
+ctx2,
+modified,
+added,
+removed,
+copy,
+getfilectx,
+opts,
+losedatafn,
+pathfn,
+):
 '''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.
 binary = False
 else:
 binary = any(f.isbinary() for f in [fctx1, fctx2] if f is not None)
 if losedatafn and not opts.git:
-if (binary or
+if (
+binary
+or
 # copy/rename
-f2 in copy or
+f2 in copy
+or
 # empty file creation
-(not f1 and isempty(fctx2)) or
+(not f1 and isempty(fctx2))
+or
 # empty file deletion
-(isempty(fctx1) and not f2) or
+(isempty(fctx1) and not f2)
+or
 # create with flags
-(not f1 and flag2) or
+(not f1 and flag2)
+or
 # change flags
-(f1 and f2 and flag1 != flag2)):
+(f1 and f2 and flag1 != flag2)
+):
 losedatafn(f2 or f1)
 path1 = pathfn(f1 or f2)
 path2 = pathfn(f2 or f1)
 header = []
 if opts.git:
-header.append('diff --git %s%s %s%s' %
+header.append(
-(aprefix, path1, bprefix, path2))
+'diff --git %s%s %s%s' % (aprefix, path1, bprefix, path2)
-if not f1: # added
+)
+if not f1:  # added
 header.append('new file mode %s' % gitmode[flag2])
-elif not f2: # removed
+elif not f2:  # removed
 header.append('deleted file mode %s' % gitmode[flag1])
 else:  # modified/copied/renamed
 mode1, mode2 = gitmode[flag1], gitmode[flag2]
 if mode1 != mode2:
 header.append('old mode %s' % mode1)
 #  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
-if binary and (not opts.git or (opts.git and opts.nobinary and not
+if binary and (
-opts.index)):
+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
+content2 = b'\0'  # not different
 else:
 content2 = b'\0\0'
 else:
 # normal path: load contents
 if fctx1 is not None:
 content2 = fctx2.data()
 if binary and opts.git and not opts.nobinary:
 text = mdiff.b85diff(content1, content2)
 if text:
-header.append('index %s..%s' %
+header.append(
-(gitindex(content1), gitindex(content2)))
+'index %s..%s' % (gitindex(content1), gitindex(content2))
-hunks = (None, [text]),
+)
+hunks = ((None, [text]),)
 else:
 if opts.git and opts.index > 0:
 flag = flag1
 if flag is None:
 flag = flag2
-header.append('index %s..%s %s' %
+header.append(
-(gitindex(content1)[0:opts.index],
+'index %s..%s %s'
-gitindex(content2)[0:opts.index],
+% (
-gitmode[flag]))
+gitindex(content1)[0 : opts.index],
+gitindex(content2)[0 : opts.index],
-uheaders, hunks = mdiff.unidiff(content1, date1,
+gitmode[flag],
-content2, date2,
+)
-path1, path2,
+)
-binary=binary, opts=opts)
+uheaders, hunks = mdiff.unidiff(
+content1,
+date1,
+content2,
+date2,
+path1,
+path2,
+binary=binary,
+opts=opts,
+)
 header.extend(uheaders)
 yield fctx1, fctx2, header, hunks
 def diffstatsum(stats):
 maxfile, maxtotal, addtotal, removetotal, binary = 0, 0, 0, 0, False
 for f, a, r, b in stats:
 maxfile = max(maxfile, encoding.colwidth(f))
 addtotal += a
 removetotal += r
 binary = binary or b
 return maxfile, maxtotal, addtotal, removetotal, binary
 def diffstatdata(lines):
 diffre = re.compile(br'^diff .*-r [a-z0-9]+\s(.*)$')
 results = []
 inheader = False
 elif line.startswith('+') and not inheader:
 adds += 1
 elif line.startswith('-') and not inheader:
 removes += 1
-elif (line.startswith('GIT binary patch') or
+elif line.startswith('GIT binary patch') or line.startswith(
-line.startswith('Binary file')):
+'Binary file'
+):
 isbinary = True
 elif line.startswith('rename from'):
 filename = line[12:]
 elif line.startswith('rename to'):
 filename += ' => %s' % line[10:]
 addresult()
 return results
 def diffstat(lines, width=80):
 output = []
 stats = diffstatdata(lines)
 maxname, maxtotal, totaladds, totalremoves, hasbinary = diffstatsum(stats)
 count = 'Bin'
 else:
 count = '%d' % (adds + removes)
 pluses = '+' * scale(adds)
 minuses = '-' * scale(removes)
-output.append(' %s%s |  %*s %s%s\n' %
+output.append(
-(filename, ' ' * (maxname - encoding.colwidth(filename)),
+' %s%s |  %*s %s%s\n'
-countwidth, count, pluses, minuses))
+% (
+filename,
+' ' * (maxname - encoding.colwidth(filename)),
+countwidth,
+count,
+pluses,
+minuses,
+)
+)
 if stats:
-output.append(_(' %d files changed, %d insertions(+), '
+output.append(
-'%d deletions(-)\n')
+_(' %d files changed, %d insertions(+), ' '%d deletions(-)\n')
-% (len(stats), totaladds, totalremoves))
+% (len(stats), totaladds, totalremoves)
+)
 return ''.join(output)
 def diffstatui(*args, **kw):
 '''like diffstat(), but yields 2-tuples of (output, label) for
 ui.write()
 '''

Mercurial > public > mercurial-scm > hg-stable

comparison mercurial/patch.py @ 43076:2372284d9457