patch: add within-line color diff capacity

The `diff' command usually writes deletion in red and insertions in green. This
patch adds within-line colors, to highlight which part of the lines differ.
Lines to compare are decided based on their similarity ratio, as computed by
difflib SequenceMatcher, with an arbitrary threshold (0.7) to decide at which
point two lines are considered entirely different (therefore no inline-diff
required).

The current implementation is kept behind an experimental flag in order to test
the effect on performance. In order to activate it, set inline-color-diff to
true in [experimental].

mercurial/cmdutil.py

@@ -1,3972 +1,3972 b''
 # cmdutil.py - help for command processing in mercurial
 #
 # Copyright 2005-2007 Matt Mackall <[e-mail]>
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 from __future__ import absolute_import
 
 import errno
 import itertools
 import os
 import re
 import tempfile
 
 from .i18n import _
 from .node import (
     hex,
     nullid,
     nullrev,
     short,
 )
 
 from . import (
     bookmarks,
     changelog,
     copies,
     crecord as crecordmod,
     dagop,
     dirstateguard,
     encoding,
     error,
     formatter,
     graphmod,
     match as matchmod,
     mdiff,
     obsolete,
     patch,
     pathutil,
     pycompat,
     registrar,
     revlog,
     revset,
     scmutil,
     smartset,
     templatekw,
     templater,
     util,
     vfs as vfsmod,
 )
 stringio = util.stringio
 
 # templates of common command options
 
 dryrunopts = [
     ('n', 'dry-run', None,
      _('do not perform actions, just print output')),
 ]
 
 remoteopts = [
     ('e', 'ssh', '',
      _('specify ssh command to use'), _('CMD')),
     ('', 'remotecmd', '',
      _('specify hg command to run on the remote side'), _('CMD')),
     ('', 'insecure', None,
      _('do not verify server certificate (ignoring web.cacerts config)')),
 ]
 
 walkopts = [
     ('I', 'include', [],
      _('include names matching the given patterns'), _('PATTERN')),
     ('X', 'exclude', [],
      _('exclude names matching the given patterns'), _('PATTERN')),
 ]
 
 commitopts = [
     ('m', 'message', '',
      _('use text as commit message'), _('TEXT')),
     ('l', 'logfile', '',
      _('read commit message from file'), _('FILE')),
 ]
 
 commitopts2 = [
     ('d', 'date', '',
      _('record the specified date as commit date'), _('DATE')),
     ('u', 'user', '',
      _('record the specified user as committer'), _('USER')),
 ]
 
 # hidden for now
 formatteropts = [
     ('T', 'template', '',
      _('display with template (EXPERIMENTAL)'), _('TEMPLATE')),
 ]
 
 templateopts = [
     ('', 'style', '',
      _('display using template map file (DEPRECATED)'), _('STYLE')),
     ('T', 'template', '',
      _('display with template'), _('TEMPLATE')),
 ]
 
 logopts = [
     ('p', 'patch', None, _('show patch')),
     ('g', 'git', None, _('use git extended diff format')),
     ('l', 'limit', '',
      _('limit number of changes displayed'), _('NUM')),
     ('M', 'no-merges', None, _('do not show merges')),
     ('', 'stat', None, _('output diffstat-style summary of changes')),
     ('G', 'graph', None, _("show the revision DAG")),
 ] + templateopts
 
 diffopts = [
     ('a', 'text', None, _('treat all files as text')),
     ('g', 'git', None, _('use git extended diff format')),
     ('', 'binary', None, _('generate binary diffs in git mode (default)')),
     ('', 'nodates', None, _('omit dates from diff headers'))
 ]
 
 diffwsopts = [
     ('w', 'ignore-all-space', None,
      _('ignore white space when comparing lines')),
     ('b', 'ignore-space-change', None,
      _('ignore changes in the amount of white space')),
     ('B', 'ignore-blank-lines', None,
      _('ignore changes whose lines are all blank')),
     ('Z', 'ignore-space-at-eol', None,
      _('ignore changes in whitespace at EOL')),
 ]
 
 diffopts2 = [
     ('', 'noprefix', None, _('omit a/ and b/ prefixes from filenames')),
     ('p', 'show-function', None, _('show which function each change is in')),
     ('', 'reverse', None, _('produce a diff that undoes the changes')),
 ] + diffwsopts + [
     ('U', 'unified', '',
      _('number of lines of context to show'), _('NUM')),
     ('', 'stat', None, _('output diffstat-style summary of changes')),
     ('', 'root', '', _('produce diffs relative to subdirectory'), _('DIR')),
 ]
 
 mergetoolopts = [
     ('t', 'tool', '', _('specify merge tool')),
 ]
 
 similarityopts = [
     ('s', 'similarity', '',
      _('guess renamed files by similarity (0<=s<=100)'), _('SIMILARITY'))
 ]
 
 subrepoopts = [
     ('S', 'subrepos', None,
      _('recurse into subrepositories'))
 ]
 
 debugrevlogopts = [
     ('c', 'changelog', False, _('open changelog')),
     ('m', 'manifest', False, _('open manifest')),
     ('', 'dir', '', _('open directory manifest')),
 ]
 
 # special string such that everything below this line will be ingored in the
 # editor text
 _linebelow = "^HG: ------------------------ >8 ------------------------$"
 
 def ishunk(x):
     hunkclasses = (crecordmod.uihunk, patch.recordhunk)
     return isinstance(x, hunkclasses)
 
 def newandmodified(chunks, originalchunks):
     newlyaddedandmodifiedfiles = set()
     for chunk in chunks:
         if ishunk(chunk) and chunk.header.isnewfile() and chunk not in \
             originalchunks:
             newlyaddedandmodifiedfiles.add(chunk.header.filename())
     return newlyaddedandmodifiedfiles
 
 def parsealiases(cmd):
     return cmd.lstrip("^").split("|")
 
 def setupwrapcolorwrite(ui):
     # wrap ui.write so diff output can be labeled/colorized
     def wrapwrite(orig, *args, **kw):
         label = kw.pop('label', '')
         for chunk, l in patch.difflabel(lambda: args):
             orig(chunk, label=label + l)
 
     oldwrite = ui.write
     def wrap(*args, **kwargs):
         return wrapwrite(oldwrite, *args, **kwargs)
     setattr(ui, 'write', wrap)
     return oldwrite
 
 def filterchunks(ui, originalhunks, usecurses, testfile, operation=None):
     if usecurses:
         if testfile:
             recordfn = crecordmod.testdecorator(testfile,
                                                 crecordmod.testchunkselector)
         else:
             recordfn = crecordmod.chunkselector
 
         return crecordmod.filterpatch(ui, originalhunks, recordfn, operation)
 
     else:
         return patch.filterpatch(ui, originalhunks, operation)
 
 def recordfilter(ui, originalhunks, operation=None):
     """ Prompts the user to filter the originalhunks and return a list of
     selected hunks.
     *operation* is used for to build ui messages to indicate the user what
     kind of filtering they are doing: reverting, committing, shelving, etc.
     (see patch.filterpatch).
     """
     usecurses = crecordmod.checkcurses(ui)
     testfile = ui.config('experimental', 'crecordtest')
     oldwrite = setupwrapcolorwrite(ui)
     try:
         newchunks, newopts = filterchunks(ui, originalhunks, usecurses,
                                           testfile, operation)
     finally:
         ui.write = oldwrite
     return newchunks, newopts
 
 def dorecord(ui, repo, commitfunc, cmdsuggest, backupall,
             filterfn, *pats, **opts):
     from . import merge as mergemod
     opts = pycompat.byteskwargs(opts)
     if not ui.interactive():
         if cmdsuggest:
             msg = _('running non-interactively, use %s instead') % cmdsuggest
         else:
             msg = _('running non-interactively')
         raise error.Abort(msg)
 
     # make sure username is set before going interactive
     if not opts.get('user'):
         ui.username() # raise exception, username not provided
 
     def recordfunc(ui, repo, message, match, opts):
         """This is generic record driver.
 
         Its job is to interactively filter local changes, and
         accordingly prepare working directory into a state in which the
         job can be delegated to a non-interactive commit command such as
         'commit' or 'qrefresh'.
 
         After the actual job is done by non-interactive command, the
         working directory is restored to its original state.
 
         In the end we'll record interesting changes, and everything else
         will be left in place, so the user can continue working.
         """
 
         checkunfinished(repo, commit=True)
         wctx = repo[None]
         merge = len(wctx.parents()) > 1
         if merge:
             raise error.Abort(_('cannot partially commit a merge '
                                '(use "hg commit" instead)'))
 
         def fail(f, msg):
             raise error.Abort('%s: %s' % (f, msg))
 
         force = opts.get('force')
         if not force:
             vdirs = []
             match.explicitdir = vdirs.append
             match.bad = fail
 
         status = repo.status(match=match)
         if not force:
             repo.checkcommitpatterns(wctx, vdirs, match, status, fail)
         diffopts = patch.difffeatureopts(ui, opts=opts, whitespace=True)
         diffopts.nodates = True
         diffopts.git = True
         diffopts.showfunc = True
         originaldiff = patch.diff(repo, changes=status, opts=diffopts)
         originalchunks = patch.parsepatch(originaldiff)
 
         # 1. filter patch, since we are intending to apply subset of it
         try:
             chunks, newopts = filterfn(ui, originalchunks)
         except error.PatchError as err:
             raise error.Abort(_('error parsing patch: %s') % err)
         opts.update(newopts)
 
         # We need to keep a backup of files that have been newly added and
         # modified during the recording process because there is a previous
         # version without the edit in the workdir
         newlyaddedandmodifiedfiles = newandmodified(chunks, originalchunks)
         contenders = set()
         for h in chunks:
             try:
                 contenders.update(set(h.files()))
             except AttributeError:
                 pass
 
         changed = status.modified + status.added + status.removed
         newfiles = [f for f in changed if f in contenders]
         if not newfiles:
             ui.status(_('no changes to record\n'))
             return 0
 
         modified = set(status.modified)
 
         # 2. backup changed files, so we can restore them in the end
 
         if backupall:
             tobackup = changed
         else:
             tobackup = [f for f in newfiles if f in modified or f in \
                     newlyaddedandmodifiedfiles]
         backups = {}
         if tobackup:
             backupdir = repo.vfs.join('record-backups')
             try:
                 os.mkdir(backupdir)
             except OSError as err:
                 if err.errno != errno.EEXIST:
                     raise
         try:
             # backup continues
             for f in tobackup:
                 fd, tmpname = tempfile.mkstemp(prefix=f.replace('/', '_')+'.',
                                                dir=backupdir)
                 os.close(fd)
                 ui.debug('backup %r as %r\n' % (f, tmpname))
                 util.copyfile(repo.wjoin(f), tmpname, copystat=True)
                 backups[f] = tmpname
 
             fp = stringio()
             for c in chunks:
                 fname = c.filename()
                 if fname in backups:
                     c.write(fp)
             dopatch = fp.tell()
             fp.seek(0)
 
             # 2.5 optionally review / modify patch in text editor
             if opts.get('review', False):
                 patchtext = (crecordmod.diffhelptext
                              + crecordmod.patchhelptext
                              + fp.read())
                 reviewedpatch = ui.edit(patchtext, "",
                                         action="diff",
                                         repopath=repo.path)
                 fp.truncate(0)
                 fp.write(reviewedpatch)
                 fp.seek(0)
 
             [os.unlink(repo.wjoin(c)) for c in newlyaddedandmodifiedfiles]
             # 3a. apply filtered patch to clean repo  (clean)
             if backups:
                 # Equivalent to hg.revert
                 m = scmutil.matchfiles(repo, backups.keys())
                 mergemod.update(repo, repo.dirstate.p1(),
                         False, True, matcher=m)
 
             # 3b. (apply)
             if dopatch:
                 try:
                     ui.debug('applying patch\n')
                     ui.debug(fp.getvalue())
                     patch.internalpatch(ui, repo, fp, 1, eolmode=None)
                 except error.PatchError as err:
                     raise error.Abort(str(err))
             del fp
 
             # 4. We prepared working directory according to filtered
             #    patch. Now is the time to delegate the job to
             #    commit/qrefresh or the like!
 
             # Make all of the pathnames absolute.
             newfiles = [repo.wjoin(nf) for nf in newfiles]
             return commitfunc(ui, repo, *newfiles, **opts)
         finally:
             # 5. finally restore backed-up files
             try:
                 dirstate = repo.dirstate
                 for realname, tmpname in backups.iteritems():
                     ui.debug('restoring %r to %r\n' % (tmpname, realname))
 
                     if dirstate[realname] == 'n':
                         # without normallookup, restoring timestamp
                         # may cause partially committed files
                         # to be treated as unmodified
                         dirstate.normallookup(realname)
 
                     # copystat=True here and above are a hack to trick any
                     # editors that have f open that we haven't modified them.
                     #
                     # Also note that this racy as an editor could notice the
                     # file's mtime before we've finished writing it.
                     util.copyfile(tmpname, repo.wjoin(realname), copystat=True)
                     os.unlink(tmpname)
                 if tobackup:
                     os.rmdir(backupdir)
             except OSError:
                 pass
 
     def recordinwlock(ui, repo, message, match, opts):
         with repo.wlock():
             return recordfunc(ui, repo, message, match, opts)
 
     return commit(ui, repo, recordinwlock, pats, opts)
 
 class dirnode(object):
     """
     Represent a directory in user working copy with information required for
     the purpose of tersing its status.
 
     path is the path to the directory
 
     statuses is a set of statuses of all files in this directory (this includes
     all the files in all the subdirectories too)
 
     files is a list of files which are direct child of this directory
 
     subdirs is a dictionary of sub-directory name as the key and it's own
     dirnode object as the value
     """
 
     def __init__(self, dirpath):
         self.path = dirpath
         self.statuses = set([])
         self.files = []
         self.subdirs = {}
 
     def _addfileindir(self, filename, status):
         """Add a file in this directory as a direct child."""
         self.files.append((filename, status))
 
     def addfile(self, filename, status):
         """
         Add a file to this directory or to its direct parent directory.
 
         If the file is not direct child of this directory, we traverse to the
         directory of which this file is a direct child of and add the file
         there.
         """
 
         # the filename contains a path separator, it means it's not the direct
         # child of this directory
         if '/' in filename:
             subdir, filep = filename.split('/', 1)
 
             # does the dirnode object for subdir exists
             if subdir not in self.subdirs:
                 subdirpath = os.path.join(self.path, subdir)
                 self.subdirs[subdir] = dirnode(subdirpath)
 
             # try adding the file in subdir
             self.subdirs[subdir].addfile(filep, status)
 
         else:
             self._addfileindir(filename, status)
 
         if status not in self.statuses:
             self.statuses.add(status)
 
     def iterfilepaths(self):
         """Yield (status, path) for files directly under this directory."""
         for f, st in self.files:
             yield st, os.path.join(self.path, f)
 
     def tersewalk(self, terseargs):
         """
         Yield (status, path) obtained by processing the status of this
         dirnode.
 
         terseargs is the string of arguments passed by the user with `--terse`
         flag.
 
         Following are the cases which can happen:
 
         1) All the files in the directory (including all the files in its
         subdirectories) share the same status and the user has asked us to terse
         that status. -> yield (status, dirpath)
 
         2) Otherwise, we do following:
 
                 a) Yield (status, filepath)  for all the files which are in this
                     directory (only the ones in this directory, not the subdirs)
 
                 b) Recurse the function on all the subdirectories of this
                    directory
         """
 
         if len(self.statuses) == 1:
             onlyst = self.statuses.pop()
 
             # Making sure we terse only when the status abbreviation is
             # passed as terse argument
             if onlyst in terseargs:
                 yield onlyst, self.path + pycompat.ossep
                 return
 
         # add the files to status list
         for st, fpath in self.iterfilepaths():
             yield st, fpath
 
         #recurse on the subdirs
         for dirobj in self.subdirs.values():
             for st, fpath in dirobj.tersewalk(terseargs):
                 yield st, fpath
 
 def tersedir(statuslist, terseargs):
     """
     Terse the status if all the files in a directory shares the same status.
 
     statuslist is scmutil.status() object which contains a list of files for
     each status.
     terseargs is string which is passed by the user as the argument to `--terse`
     flag.
 
     The function makes a tree of objects of dirnode class, and at each node it
     stores the information required to know whether we can terse a certain
     directory or not.
     """
     # the order matters here as that is used to produce final list
     allst = ('m', 'a', 'r', 'd', 'u', 'i', 'c')
 
     # checking the argument validity
     for s in pycompat.bytestr(terseargs):
         if s not in allst:
             raise error.Abort(_("'%s' not recognized") % s)
 
     # creating a dirnode object for the root of the repo
     rootobj = dirnode('')
     pstatus = ('modified', 'added', 'deleted', 'clean', 'unknown',
                'ignored', 'removed')
 
     tersedict = {}
     for attrname in pstatus:
         statuschar = attrname[0:1]
         for f in getattr(statuslist, attrname):
             rootobj.addfile(f, statuschar)
         tersedict[statuschar] = []
 
     # we won't be tersing the root dir, so add files in it
     for st, fpath in rootobj.iterfilepaths():
         tersedict[st].append(fpath)
 
     # process each sub-directory and build tersedict
     for subdir in rootobj.subdirs.values():
         for st, f in subdir.tersewalk(terseargs):
             tersedict[st].append(f)
 
     tersedlist = []
     for st in allst:
         tersedict[st].sort()
         tersedlist.append(tersedict[st])
 
     return tersedlist
 
 def _commentlines(raw):
     '''Surround lineswith a comment char and a new line'''
     lines = raw.splitlines()
     commentedlines = ['# %s' % line for line in lines]
     return '\n'.join(commentedlines) + '\n'
 
 def _conflictsmsg(repo):
     # avoid merge cycle
     from . import merge as mergemod
     mergestate = mergemod.mergestate.read(repo)
     if not mergestate.active():
         return
 
     m = scmutil.match(repo[None])
     unresolvedlist = [f for f in mergestate.unresolved() if m(f)]
     if unresolvedlist:
         mergeliststr = '\n'.join(
             ['    %s' % util.pathto(repo.root, pycompat.getcwd(), path)
              for path in unresolvedlist])
         msg = _('''Unresolved merge conflicts:
 
 %s
 
 To mark files as resolved:  hg resolve --mark FILE''') % mergeliststr
     else:
         msg = _('No unresolved merge conflicts.')
 
     return _commentlines(msg)
 
 def _helpmessage(continuecmd, abortcmd):
     msg = _('To continue:                %s\n'
             'To abort:                   %s') % (continuecmd, abortcmd)
     return _commentlines(msg)
 
 def _rebasemsg():
     return _helpmessage('hg rebase --continue', 'hg rebase --abort')
 
 def _histeditmsg():
     return _helpmessage('hg histedit --continue', 'hg histedit --abort')
 
 def _unshelvemsg():
     return _helpmessage('hg unshelve --continue', 'hg unshelve --abort')
 
 def _updatecleanmsg(dest=None):
     warning = _('warning: this will discard uncommitted changes')
     return 'hg update --clean %s    (%s)' % (dest or '.', warning)
 
 def _graftmsg():
     # tweakdefaults requires `update` to have a rev hence the `.`
     return _helpmessage('hg graft --continue', _updatecleanmsg())
 
 def _mergemsg():
     # tweakdefaults requires `update` to have a rev hence the `.`
      return _helpmessage('hg commit', _updatecleanmsg())
 
 def _bisectmsg():
     msg = _('To mark the changeset good:    hg bisect --good\n'
             'To mark the changeset bad:     hg bisect --bad\n'
             'To abort:                      hg bisect --reset\n')
     return _commentlines(msg)
 
 def fileexistspredicate(filename):
     return lambda repo: repo.vfs.exists(filename)
 
 def _mergepredicate(repo):
     return len(repo[None].parents()) > 1
 
 STATES = (
     # (state, predicate to detect states, helpful message function)
     ('histedit', fileexistspredicate('histedit-state'), _histeditmsg),
     ('bisect', fileexistspredicate('bisect.state'), _bisectmsg),
     ('graft', fileexistspredicate('graftstate'), _graftmsg),
     ('unshelve', fileexistspredicate('unshelverebasestate'), _unshelvemsg),
     ('rebase', fileexistspredicate('rebasestate'), _rebasemsg),
     # The merge state is part of a list that will be iterated over.
     # They need to be last because some of the other unfinished states may also
     # be in a merge or update state (eg. rebase, histedit, graft, etc).
     # We want those to have priority.
     ('merge', _mergepredicate, _mergemsg),
 )
 
 def _getrepostate(repo):
     # experimental config: commands.status.skipstates
     skip = set(repo.ui.configlist('commands', 'status.skipstates'))
     for state, statedetectionpredicate, msgfn in STATES:
         if state in skip:
             continue
         if statedetectionpredicate(repo):
             return (state, statedetectionpredicate, msgfn)
 
 def morestatus(repo, fm):
     statetuple = _getrepostate(repo)
     label = 'status.morestatus'
     if statetuple:
         fm.startitem()
         state, statedetectionpredicate, helpfulmsg = statetuple
         statemsg = _('The repository is in an unfinished *%s* state.') % state
         fm.write('statemsg', '%s\n',  _commentlines(statemsg), label=label)
         conmsg = _conflictsmsg(repo)
         if conmsg:
             fm.write('conflictsmsg', '%s\n', conmsg, label=label)
         if helpfulmsg:
             helpmsg = helpfulmsg()
             fm.write('helpmsg', '%s\n', helpmsg, label=label)
 
 def findpossible(cmd, table, strict=False):
     """
     Return cmd -> (aliases, command table entry)
     for each matching command.
     Return debug commands (or their aliases) only if no normal command matches.
     """
     choice = {}
     debugchoice = {}
 
     if cmd in table:
         # short-circuit exact matches, "log" alias beats "^log|history"
         keys = [cmd]
     else:
         keys = table.keys()
 
     allcmds = []
     for e in keys:
         aliases = parsealiases(e)
         allcmds.extend(aliases)
         found = None
         if cmd in aliases:
             found = cmd
         elif not strict:
             for a in aliases:
                 if a.startswith(cmd):
                     found = a
                     break
         if found is not None:
             if aliases[0].startswith("debug") or found.startswith("debug"):
                 debugchoice[found] = (aliases, table[e])
             else:
                 choice[found] = (aliases, table[e])
 
     if not choice and debugchoice:
         choice = debugchoice
 
     return choice, allcmds
 
 def findcmd(cmd, table, strict=True):
     """Return (aliases, command table entry) for command string."""
     choice, allcmds = findpossible(cmd, table, strict)
 
     if cmd in choice:
         return choice[cmd]
 
     if len(choice) > 1:
         clist = sorted(choice)
         raise error.AmbiguousCommand(cmd, clist)
 
     if choice:
         return list(choice.values())[0]
 
     raise error.UnknownCommand(cmd, allcmds)
 
 def findrepo(p):
     while not os.path.isdir(os.path.join(p, ".hg")):
         oldp, p = p, os.path.dirname(p)
         if p == oldp:
             return None
 
     return p
 
 def bailifchanged(repo, merge=True, hint=None):
     """ enforce the precondition that working directory must be clean.
 
     'merge' can be set to false if a pending uncommitted merge should be
     ignored (such as when 'update --check' runs).
 
     'hint' is the usual hint given to Abort exception.
     """
 
     if merge and repo.dirstate.p2() != nullid:
         raise error.Abort(_('outstanding uncommitted merge'), hint=hint)
     modified, added, removed, deleted = repo.status()[:4]
     if modified or added or removed or deleted:
         raise error.Abort(_('uncommitted changes'), hint=hint)
     ctx = repo[None]
     for s in sorted(ctx.substate):
         ctx.sub(s).bailifchanged(hint=hint)
 
 def logmessage(ui, opts):
     """ get the log message according to -m and -l option """
     message = opts.get('message')
     logfile = opts.get('logfile')
 
     if message and logfile:
         raise error.Abort(_('options --message and --logfile are mutually '
                            'exclusive'))
     if not message and logfile:
         try:
             if isstdiofilename(logfile):
                 message = ui.fin.read()
             else:
                 message = '\n'.join(util.readfile(logfile).splitlines())
         except IOError as inst:
             raise error.Abort(_("can't read commit message '%s': %s") %
                              (logfile, encoding.strtolocal(inst.strerror)))
     return message
 
 def mergeeditform(ctxorbool, baseformname):
     """return appropriate editform name (referencing a committemplate)
 
     'ctxorbool' is either a ctx to be committed, or a bool indicating whether
     merging is committed.
 
     This returns baseformname with '.merge' appended if it is a merge,
     otherwise '.normal' is appended.
     """
     if isinstance(ctxorbool, bool):
         if ctxorbool:
             return baseformname + ".merge"
     elif 1 < len(ctxorbool.parents()):
         return baseformname + ".merge"
 
     return baseformname + ".normal"
 
 def getcommiteditor(edit=False, finishdesc=None, extramsg=None,
                     editform='', **opts):
     """get appropriate commit message editor according to '--edit' option
 
     'finishdesc' is a function to be called with edited commit message
     (= 'description' of the new changeset) just after editing, but
     before checking empty-ness. It should return actual text to be
     stored into history. This allows to change description before
     storing.
 
     'extramsg' is a extra message to be shown in the editor instead of
     'Leave message empty to abort commit' line. 'HG: ' prefix and EOL
     is automatically added.
 
     'editform' is a dot-separated list of names, to distinguish
     the purpose of commit text editing.
 
     'getcommiteditor' returns 'commitforceeditor' regardless of
     'edit', if one of 'finishdesc' or 'extramsg' is specified, because
     they are specific for usage in MQ.
     """
     if edit or finishdesc or extramsg:
         return lambda r, c, s: commitforceeditor(r, c, s,
                                                  finishdesc=finishdesc,
                                                  extramsg=extramsg,
                                                  editform=editform)
     elif editform:
         return lambda r, c, s: commiteditor(r, c, s, editform=editform)
     else:
         return commiteditor
 
 def loglimit(opts):
     """get the log limit according to option -l/--limit"""
     limit = opts.get('limit')
     if limit:
         try:
             limit = int(limit)
         except ValueError:
             raise error.Abort(_('limit must be a positive integer'))
         if limit <= 0:
             raise error.Abort(_('limit must be positive'))
     else:
         limit = None
     return limit
 
 def makefilename(repo, pat, node, desc=None,
                   total=None, seqno=None, revwidth=None, pathname=None):
     node_expander = {
         'H': lambda: hex(node),
         'R': lambda: '%d' % repo.changelog.rev(node),
         'h': lambda: short(node),
         'm': lambda: re.sub('[^\w]', '_', desc or '')
         }
     expander = {
         '%': lambda: '%',
         'b': lambda: os.path.basename(repo.root),
         }
 
     try:
         if node:
             expander.update(node_expander)
         if node:
             expander['r'] = (lambda:
                     ('%d' % repo.changelog.rev(node)).zfill(revwidth or 0))
         if total is not None:
             expander['N'] = lambda: '%d' % total
         if seqno is not None:
             expander['n'] = lambda: '%d' % seqno
         if total is not None and seqno is not None:
             expander['n'] = (lambda: ('%d' % seqno).zfill(len('%d' % total)))
         if pathname is not None:
             expander['s'] = lambda: os.path.basename(pathname)
             expander['d'] = lambda: os.path.dirname(pathname) or '.'
             expander['p'] = lambda: pathname
 
         newname = []
         patlen = len(pat)
         i = 0
         while i < patlen:
             c = pat[i:i + 1]
             if c == '%':
                 i += 1
                 c = pat[i:i + 1]
                 c = expander[c]()
             newname.append(c)
             i += 1
         return ''.join(newname)
     except KeyError as inst:
         raise error.Abort(_("invalid format spec '%%%s' in output filename") %
                          inst.args[0])
 
 def isstdiofilename(pat):
     """True if the given pat looks like a filename denoting stdin/stdout"""
     return not pat or pat == '-'
 
 class _unclosablefile(object):
     def __init__(self, fp):
         self._fp = fp
 
     def close(self):
         pass
 
     def __iter__(self):
         return iter(self._fp)
 
     def __getattr__(self, attr):
         return getattr(self._fp, attr)
 
     def __enter__(self):
         return self
 
     def __exit__(self, exc_type, exc_value, exc_tb):
         pass
 
 def makefileobj(repo, pat, node=None, desc=None, total=None,
                 seqno=None, revwidth=None, mode='wb', modemap=None,
                 pathname=None):
 
     writable = mode not in ('r', 'rb')
 
     if isstdiofilename(pat):
         if writable:
             fp = repo.ui.fout
         else:
             fp = repo.ui.fin
         return _unclosablefile(fp)
     fn = makefilename(repo, pat, node, desc, total, seqno, revwidth, pathname)
     if modemap is not None:
         mode = modemap.get(fn, mode)
         if mode == 'wb':
             modemap[fn] = 'ab'
     return open(fn, mode)
 
 def openrevlog(repo, cmd, file_, opts):
     """opens the changelog, manifest, a filelog or a given revlog"""
     cl = opts['changelog']
     mf = opts['manifest']
     dir = opts['dir']
     msg = None
     if cl and mf:
         msg = _('cannot specify --changelog and --manifest at the same time')
     elif cl and dir:
         msg = _('cannot specify --changelog and --dir at the same time')
     elif cl or mf or dir:
         if file_:
             msg = _('cannot specify filename with --changelog or --manifest')
         elif not repo:
             msg = _('cannot specify --changelog or --manifest or --dir '
                     'without a repository')
     if msg:
         raise error.Abort(msg)
 
     r = None
     if repo:
         if cl:
             r = repo.unfiltered().changelog
         elif dir:
             if 'treemanifest' not in repo.requirements:
                 raise error.Abort(_("--dir can only be used on repos with "
                                    "treemanifest enabled"))
             dirlog = repo.manifestlog._revlog.dirlog(dir)
             if len(dirlog):
                 r = dirlog
         elif mf:
             r = repo.manifestlog._revlog
         elif file_:
             filelog = repo.file(file_)
             if len(filelog):
                 r = filelog
     if not r:
         if not file_:
             raise error.CommandError(cmd, _('invalid arguments'))
         if not os.path.isfile(file_):
             raise error.Abort(_("revlog '%s' not found") % file_)
         r = revlog.revlog(vfsmod.vfs(pycompat.getcwd(), audit=False),
                           file_[:-2] + ".i")
     return r
 
 def copy(ui, repo, pats, opts, rename=False):
     # called with the repo lock held
     #
     # hgsep => pathname that uses "/" to separate directories
     # ossep => pathname that uses os.sep to separate directories
     cwd = repo.getcwd()
     targets = {}
     after = opts.get("after")
     dryrun = opts.get("dry_run")
     wctx = repo[None]
 
     def walkpat(pat):
         srcs = []
         if after:
             badstates = '?'
         else:
             badstates = '?r'
         m = scmutil.match(wctx, [pat], opts, globbed=True)
         for abs in wctx.walk(m):
             state = repo.dirstate[abs]
             rel = m.rel(abs)
             exact = m.exact(abs)
             if state in badstates:
                 if exact and state == '?':
                     ui.warn(_('%s: not copying - file is not managed\n') % rel)
                 if exact and state == 'r':
                     ui.warn(_('%s: not copying - file has been marked for'
                               ' remove\n') % rel)
                 continue
             # abs: hgsep
             # rel: ossep
             srcs.append((abs, rel, exact))
         return srcs
 
     # abssrc: hgsep
     # relsrc: ossep
     # otarget: ossep
     def copyfile(abssrc, relsrc, otarget, exact):
         abstarget = pathutil.canonpath(repo.root, cwd, otarget)
         if '/' in abstarget:
             # We cannot normalize abstarget itself, this would prevent
             # case only renames, like a => A.
             abspath, absname = abstarget.rsplit('/', 1)
             abstarget = repo.dirstate.normalize(abspath) + '/' + absname
         reltarget = repo.pathto(abstarget, cwd)
         target = repo.wjoin(abstarget)
         src = repo.wjoin(abssrc)
         state = repo.dirstate[abstarget]
 
         scmutil.checkportable(ui, abstarget)
 
         # check for collisions
         prevsrc = targets.get(abstarget)
         if prevsrc is not None:
             ui.warn(_('%s: not overwriting - %s collides with %s\n') %
                     (reltarget, repo.pathto(abssrc, cwd),
                      repo.pathto(prevsrc, cwd)))
             return
 
         # check for overwrites
         exists = os.path.lexists(target)
         samefile = False
         if exists and abssrc != abstarget:
             if (repo.dirstate.normalize(abssrc) ==
                 repo.dirstate.normalize(abstarget)):
                 if not rename:
                     ui.warn(_("%s: can't copy - same file\n") % reltarget)
                     return
                 exists = False
                 samefile = True
 
         if not after and exists or after and state in 'mn':
             if not opts['force']:
                 if state in 'mn':
                     msg = _('%s: not overwriting - file already committed\n')
                     if after:
                         flags = '--after --force'
                     else:
                         flags = '--force'
                     if rename:
                         hint = _('(hg rename %s to replace the file by '
                                  'recording a rename)\n') % flags
                     else:
                         hint = _('(hg copy %s to replace the file by '
                                  'recording a copy)\n') % flags
                 else:
                     msg = _('%s: not overwriting - file exists\n')
                     if rename:
                         hint = _('(hg rename --after to record the rename)\n')
                     else:
                         hint = _('(hg copy --after to record the copy)\n')
                 ui.warn(msg % reltarget)
                 ui.warn(hint)
                 return
 
         if after:
             if not exists:
                 if rename:
                     ui.warn(_('%s: not recording move - %s does not exist\n') %
                             (relsrc, reltarget))
                 else:
                     ui.warn(_('%s: not recording copy - %s does not exist\n') %
                             (relsrc, reltarget))
                 return
         elif not dryrun:
             try:
                 if exists:
                     os.unlink(target)
                 targetdir = os.path.dirname(target) or '.'
                 if not os.path.isdir(targetdir):
                     os.makedirs(targetdir)
                 if samefile:
                     tmp = target + "~hgrename"
                     os.rename(src, tmp)
                     os.rename(tmp, target)
                 else:
                     util.copyfile(src, target)
                 srcexists = True
             except IOError as inst:
                 if inst.errno == errno.ENOENT:
                     ui.warn(_('%s: deleted in working directory\n') % relsrc)
                     srcexists = False
                 else:
                     ui.warn(_('%s: cannot copy - %s\n') %
                             (relsrc, encoding.strtolocal(inst.strerror)))
                     return True # report a failure
 
         if ui.verbose or not exact:
             if rename:
                 ui.status(_('moving %s to %s\n') % (relsrc, reltarget))
             else:
                 ui.status(_('copying %s to %s\n') % (relsrc, reltarget))
 
         targets[abstarget] = abssrc
 
         # fix up dirstate
         scmutil.dirstatecopy(ui, repo, wctx, abssrc, abstarget,
                              dryrun=dryrun, cwd=cwd)
         if rename and not dryrun:
             if not after and srcexists and not samefile:
                 repo.wvfs.unlinkpath(abssrc)
             wctx.forget([abssrc])
 
     # pat: ossep
     # dest ossep
     # srcs: list of (hgsep, hgsep, ossep, bool)
     # return: function that takes hgsep and returns ossep
     def targetpathfn(pat, dest, srcs):
         if os.path.isdir(pat):
             abspfx = pathutil.canonpath(repo.root, cwd, pat)
             abspfx = util.localpath(abspfx)
             if destdirexists:
                 striplen = len(os.path.split(abspfx)[0])
             else:
                 striplen = len(abspfx)
             if striplen:
                 striplen += len(pycompat.ossep)
             res = lambda p: os.path.join(dest, util.localpath(p)[striplen:])
         elif destdirexists:
             res = lambda p: os.path.join(dest,
                                          os.path.basename(util.localpath(p)))
         else:
             res = lambda p: dest
         return res
 
     # pat: ossep
     # dest ossep
     # srcs: list of (hgsep, hgsep, ossep, bool)
     # return: function that takes hgsep and returns ossep
     def targetpathafterfn(pat, dest, srcs):
         if matchmod.patkind(pat):
             # a mercurial pattern
             res = lambda p: os.path.join(dest,
                                          os.path.basename(util.localpath(p)))
         else:
             abspfx = pathutil.canonpath(repo.root, cwd, pat)
             if len(abspfx) < len(srcs[0][0]):
                 # A directory. Either the target path contains the last
                 # component of the source path or it does not.
                 def evalpath(striplen):
                     score = 0
                     for s in srcs:
                         t = os.path.join(dest, util.localpath(s[0])[striplen:])
                         if os.path.lexists(t):
                             score += 1
                     return score
 
                 abspfx = util.localpath(abspfx)
                 striplen = len(abspfx)
                 if striplen:
                     striplen += len(pycompat.ossep)
                 if os.path.isdir(os.path.join(dest, os.path.split(abspfx)[1])):
                     score = evalpath(striplen)
                     striplen1 = len(os.path.split(abspfx)[0])
                     if striplen1:
                         striplen1 += len(pycompat.ossep)
                     if evalpath(striplen1) > score:
                         striplen = striplen1
                 res = lambda p: os.path.join(dest,
                                              util.localpath(p)[striplen:])
             else:
                 # a file
                 if destdirexists:
                     res = lambda p: os.path.join(dest,
                                         os.path.basename(util.localpath(p)))
                 else:
                     res = lambda p: dest
         return res
 
     pats = scmutil.expandpats(pats)
     if not pats:
         raise error.Abort(_('no source or destination specified'))
     if len(pats) == 1:
         raise error.Abort(_('no destination specified'))
     dest = pats.pop()
     destdirexists = os.path.isdir(dest) and not os.path.islink(dest)
     if not destdirexists:
         if len(pats) > 1 or matchmod.patkind(pats[0]):
             raise error.Abort(_('with multiple sources, destination must be an '
                                'existing directory'))
         if util.endswithsep(dest):
             raise error.Abort(_('destination %s is not a directory') % dest)
 
     tfn = targetpathfn
     if after:
         tfn = targetpathafterfn
     copylist = []
     for pat in pats:
         srcs = walkpat(pat)
         if not srcs:
             continue
         copylist.append((tfn(pat, dest, srcs), srcs))
     if not copylist:
         raise error.Abort(_('no files to copy'))
 
     errors = 0
     for targetpath, srcs in copylist:
         for abssrc, relsrc, exact in srcs:
             if copyfile(abssrc, relsrc, targetpath(abssrc), exact):
                 errors += 1
 
     if errors:
         ui.warn(_('(consider using --after)\n'))
 
     return errors != 0
 
 ## facility to let extension process additional data into an import patch
 # list of identifier to be executed in order
 extrapreimport = []  # run before commit
 extrapostimport = [] # run after commit
 # mapping from identifier to actual import function
 #
 # 'preimport' are run before the commit is made and are provided the following
 # arguments:
 # - repo: the localrepository instance,
 # - patchdata: data extracted from patch header (cf m.patch.patchheadermap),
 # - extra: the future extra dictionary of the changeset, please mutate it,
 # - opts: the import options.
 # XXX ideally, we would just pass an ctx ready to be computed, that would allow
 # mutation of in memory commit and more. Feel free to rework the code to get
 # there.
 extrapreimportmap = {}
 # 'postimport' are run after the commit is made and are provided the following
 # argument:
 # - ctx: the changectx created by import.
 extrapostimportmap = {}
 
 def tryimportone(ui, repo, hunk, parents, opts, msgs, updatefunc):
     """Utility function used by commands.import to import a single patch
 
     This function is explicitly defined here to help the evolve extension to
     wrap this part of the import logic.
 
     The API is currently a bit ugly because it a simple code translation from
     the import command. Feel free to make it better.
 
     :hunk: a patch (as a binary string)
     :parents: nodes that will be parent of the created commit
     :opts: the full dict of option passed to the import command
     :msgs: list to save commit message to.
            (used in case we need to save it when failing)
     :updatefunc: a function that update a repo to a given node
                  updatefunc(<repo>, <node>)
     """
     # avoid cycle context -> subrepo -> cmdutil
     from . import context
     extractdata = patch.extract(ui, hunk)
     tmpname = extractdata.get('filename')
     message = extractdata.get('message')
     user = opts.get('user') or extractdata.get('user')
     date = opts.get('date') or extractdata.get('date')
     branch = extractdata.get('branch')
     nodeid = extractdata.get('nodeid')
     p1 = extractdata.get('p1')
     p2 = extractdata.get('p2')
 
     nocommit = opts.get('no_commit')
     importbranch = opts.get('import_branch')
     update = not opts.get('bypass')
     strip = opts["strip"]
     prefix = opts["prefix"]
     sim = float(opts.get('similarity') or 0)
     if not tmpname:
         return (None, None, False)
 
     rejects = False
 
     try:
         cmdline_message = logmessage(ui, opts)
         if cmdline_message:
             # pickup the cmdline msg
             message = cmdline_message
         elif message:
             # pickup the patch msg
             message = message.strip()
         else:
             # launch the editor
             message = None
         ui.debug('message:\n%s\n' % message)
 
         if len(parents) == 1:
             parents.append(repo[nullid])
         if opts.get('exact'):
             if not nodeid or not p1:
                 raise error.Abort(_('not a Mercurial patch'))
             p1 = repo[p1]
             p2 = repo[p2 or nullid]
         elif p2:
             try:
                 p1 = repo[p1]
                 p2 = repo[p2]
                 # Without any options, consider p2 only if the
                 # patch is being applied on top of the recorded
                 # first parent.
                 if p1 != parents[0]:
                     p1 = parents[0]
                     p2 = repo[nullid]
             except error.RepoError:
                 p1, p2 = parents
             if p2.node() == nullid:
                 ui.warn(_("warning: import the patch as a normal revision\n"
                           "(use --exact to import the patch as a merge)\n"))
         else:
             p1, p2 = parents
 
         n = None
         if update:
             if p1 != parents[0]:
                 updatefunc(repo, p1.node())
             if p2 != parents[1]:
                 repo.setparents(p1.node(), p2.node())
 
             if opts.get('exact') or importbranch:
                 repo.dirstate.setbranch(branch or 'default')
 
             partial = opts.get('partial', False)
             files = set()
             try:
                 patch.patch(ui, repo, tmpname, strip=strip, prefix=prefix,
                             files=files, eolmode=None, similarity=sim / 100.0)
             except error.PatchError as e:
                 if not partial:
                     raise error.Abort(str(e))
                 if partial:
                     rejects = True
 
             files = list(files)
             if nocommit:
                 if message:
                     msgs.append(message)
             else:
                 if opts.get('exact') or p2:
                     # If you got here, you either use --force and know what
                     # you are doing or used --exact or a merge patch while
                     # being updated to its first parent.
                     m = None
                 else:
                     m = scmutil.matchfiles(repo, files or [])
                 editform = mergeeditform(repo[None], 'import.normal')
                 if opts.get('exact'):
                     editor = None
                 else:
                     editor = getcommiteditor(editform=editform, **opts)
                 extra = {}
                 for idfunc in extrapreimport:
                     extrapreimportmap[idfunc](repo, extractdata, extra, opts)
                 overrides = {}
                 if partial:
                     overrides[('ui', 'allowemptycommit')] = True
                 with repo.ui.configoverride(overrides, 'import'):
                     n = repo.commit(message, user,
                                     date, match=m,
                                     editor=editor, extra=extra)
                     for idfunc in extrapostimport:
                         extrapostimportmap[idfunc](repo[n])
         else:
             if opts.get('exact') or importbranch:
                 branch = branch or 'default'
             else:
                 branch = p1.branch()
             store = patch.filestore()
             try:
                 files = set()
                 try:
                     patch.patchrepo(ui, repo, p1, store, tmpname, strip, prefix,
                                     files, eolmode=None)
                 except error.PatchError as e:
                     raise error.Abort(str(e))
                 if opts.get('exact'):
                     editor = None
                 else:
                     editor = getcommiteditor(editform='import.bypass')
                 memctx = context.memctx(repo, (p1.node(), p2.node()),
                                             message,
                                             files=files,
                                             filectxfn=store,
                                             user=user,
                                             date=date,
                                             branch=branch,
                                             editor=editor)
                 n = memctx.commit()
             finally:
                 store.close()
         if opts.get('exact') and nocommit:
             # --exact with --no-commit is still useful in that it does merge
             # and branch bits
             ui.warn(_("warning: can't check exact import with --no-commit\n"))
         elif opts.get('exact') and hex(n) != nodeid:
             raise error.Abort(_('patch is damaged or loses information'))
         msg = _('applied to working directory')
         if n:
             # i18n: refers to a short changeset id
             msg = _('created %s') % short(n)
         return (msg, n, rejects)
     finally:
         os.unlink(tmpname)
 
 # facility to let extensions include additional data in an exported patch
 # list of identifiers to be executed in order
 extraexport = []
 # mapping from identifier to actual export function
 # function as to return a string to be added to the header or None
 # it is given two arguments (sequencenumber, changectx)
 extraexportmap = {}
 
 def _exportsingle(repo, ctx, match, switch_parent, rev, seqno, write, diffopts):
     node = scmutil.binnode(ctx)
     parents = [p.node() for p in ctx.parents() if p]
     branch = ctx.branch()
     if switch_parent:
         parents.reverse()
 
     if parents:
         prev = parents[0]
     else:
         prev = nullid
 
     write("# HG changeset patch\n")
     write("# User %s\n" % ctx.user())
     write("# Date %d %d\n" % ctx.date())
     write("#      %s\n" % util.datestr(ctx.date()))
     if branch and branch != 'default':
         write("# Branch %s\n" % branch)
     write("# Node ID %s\n" % hex(node))
     write("# Parent  %s\n" % hex(prev))
     if len(parents) > 1:
         write("# Parent  %s\n" % hex(parents[1]))
 
     for headerid in extraexport:
         header = extraexportmap[headerid](seqno, ctx)
         if header is not None:
             write('# %s\n' % header)
     write(ctx.description().rstrip())
     write("\n\n")
 
     for chunk, label in patch.diffui(repo, prev, node, match, opts=diffopts):
         write(chunk, label=label)
 
 def export(repo, revs, fntemplate='hg-%h.patch', fp=None, switch_parent=False,
            opts=None, match=None):
     '''export changesets as hg patches
 
     Args:
       repo: The repository from which we're exporting revisions.
       revs: A list of revisions to export as revision numbers.
       fntemplate: An optional string to use for generating patch file names.
       fp: An optional file-like object to which patches should be written.
       switch_parent: If True, show diffs against second parent when not nullid.
                      Default is false, which always shows diff against p1.
       opts: diff options to use for generating the patch.
       match: If specified, only export changes to files matching this matcher.
 
     Returns:
       Nothing.
 
     Side Effect:
       "HG Changeset Patch" data is emitted to one of the following
       destinations:
         fp is specified: All revs are written to the specified
                          file-like object.
         fntemplate specified: Each rev is written to a unique file named using
                             the given template.
         Neither fp nor template specified: All revs written to repo.ui.write()
     '''
 
     total = len(revs)
     revwidth = max(len(str(rev)) for rev in revs)
     filemode = {}
 
     write = None
     dest = '<unnamed>'
     if fp:
         dest = getattr(fp, 'name', dest)
         def write(s, **kw):
             fp.write(s)
     elif not fntemplate:
         write = repo.ui.write
 
     for seqno, rev in enumerate(revs, 1):
         ctx = repo[rev]
         fo = None
         if not fp and fntemplate:
             desc_lines = ctx.description().rstrip().split('\n')
             desc = desc_lines[0]    #Commit always has a first line.
             fo = makefileobj(repo, fntemplate, ctx.node(), desc=desc,
                              total=total, seqno=seqno, revwidth=revwidth,
                              mode='wb', modemap=filemode)
             dest = fo.name
             def write(s, **kw):
                 fo.write(s)
         if not dest.startswith('<'):
             repo.ui.note("%s\n" % dest)
         _exportsingle(
             repo, ctx, match, switch_parent, rev, seqno, write, opts)
         if fo is not None:
             fo.close()
 
 def diffordiffstat(ui, repo, diffopts, node1, node2, match,
                    changes=None, stat=False, fp=None, prefix='',
                    root='', listsubrepos=False, hunksfilterfn=None):
     '''show diff or diffstat.'''
     if fp is None:
         write = ui.write
     else:
         def write(s, **kw):
             fp.write(s)
 
     if root:
         relroot = pathutil.canonpath(repo.root, repo.getcwd(), root)
     else:
         relroot = ''
     if relroot != '':
         # XXX relative roots currently don't work if the root is within a
         # subrepo
         uirelroot = match.uipath(relroot)
         relroot += '/'
         for matchroot in match.files():
             if not matchroot.startswith(relroot):
                 ui.warn(_('warning: %s not inside relative root %s\n') % (
                     match.uipath(matchroot), uirelroot))
 
     if stat:
         diffopts = diffopts.copy(context=0)
         width = 80
         if not ui.plain():
             width = ui.termwidth()
-        chunks = patch.diff(repo, node1, node2, match, changes, diffopts,
+        chunks = patch.diff(repo, node1, node2, match, changes, opts=diffopts,
                             prefix=prefix, relroot=relroot,
                             hunksfilterfn=hunksfilterfn)
         for chunk, label in patch.diffstatui(util.iterlines(chunks),
                                              width=width):
             write(chunk, label=label)
     else:
         for chunk, label in patch.diffui(repo, node1, node2, match,
-                                         changes, diffopts, prefix=prefix,
+                                         changes, opts=diffopts, prefix=prefix,
                                          relroot=relroot,
                                          hunksfilterfn=hunksfilterfn):
             write(chunk, label=label)
 
     if listsubrepos:
         ctx1 = repo[node1]
         ctx2 = repo[node2]
         for subpath, sub in scmutil.itersubrepos(ctx1, ctx2):
             tempnode2 = node2
             try:
                 if node2 is not None:
                     tempnode2 = ctx2.substate[subpath][1]
             except KeyError:
                 # A subrepo that existed in node1 was deleted between node1 and
                 # node2 (inclusive). Thus, ctx2's substate won't contain that
                 # subpath. The best we can do is to ignore it.
                 tempnode2 = None
             submatch = matchmod.subdirmatcher(subpath, match)
             sub.diff(ui, diffopts, tempnode2, submatch, changes=changes,
                      stat=stat, fp=fp, prefix=prefix)
 
 def _changesetlabels(ctx):
     labels = ['log.changeset', 'changeset.%s' % ctx.phasestr()]
     if ctx.obsolete():
         labels.append('changeset.obsolete')
     if ctx.isunstable():
         labels.append('changeset.unstable')
         for instability in ctx.instabilities():
             labels.append('instability.%s' % instability)
     return ' '.join(labels)
 
 class changeset_printer(object):
     '''show changeset information when templating not requested.'''
 
     def __init__(self, ui, repo, matchfn, diffopts, buffered):
         self.ui = ui
         self.repo = repo
         self.buffered = buffered
         self.matchfn = matchfn
         self.diffopts = diffopts
         self.header = {}
         self.hunk = {}
         self.lastheader = None
         self.footer = None
         self._columns = templatekw.getlogcolumns()
 
     def flush(self, ctx):
         rev = ctx.rev()
         if rev in self.header:
             h = self.header[rev]
             if h != self.lastheader:
                 self.lastheader = h
                 self.ui.write(h)
             del self.header[rev]
         if rev in self.hunk:
             self.ui.write(self.hunk[rev])
             del self.hunk[rev]
             return 1
         return 0
 
     def close(self):
         if self.footer:
             self.ui.write(self.footer)
 
     def show(self, ctx, copies=None, matchfn=None, hunksfilterfn=None,
              **props):
         props = pycompat.byteskwargs(props)
         if self.buffered:
             self.ui.pushbuffer(labeled=True)
             self._show(ctx, copies, matchfn, hunksfilterfn, props)
             self.hunk[ctx.rev()] = self.ui.popbuffer()
         else:
             self._show(ctx, copies, matchfn, hunksfilterfn, props)
 
     def _show(self, ctx, copies, matchfn, hunksfilterfn, props):
         '''show a single changeset or file revision'''
         changenode = ctx.node()
         rev = ctx.rev()
 
         if self.ui.quiet:
             self.ui.write("%s\n" % scmutil.formatchangeid(ctx),
                           label='log.node')
             return
 
         columns = self._columns
         self.ui.write(columns['changeset'] % scmutil.formatchangeid(ctx),
                       label=_changesetlabels(ctx))
 
         # branches are shown first before any other names due to backwards
         # compatibility
         branch = ctx.branch()
         # don't show the default branch name
         if branch != 'default':
             self.ui.write(columns['branch'] % branch, label='log.branch')
 
         for nsname, ns in self.repo.names.iteritems():
             # branches has special logic already handled above, so here we just
             # skip it
             if nsname == 'branches':
                 continue
             # we will use the templatename as the color name since those two
             # should be the same
             for name in ns.names(self.repo, changenode):
                 self.ui.write(ns.logfmt % name,
                               label='log.%s' % ns.colorname)
         if self.ui.debugflag:
             self.ui.write(columns['phase'] % ctx.phasestr(), label='log.phase')
         for pctx in scmutil.meaningfulparents(self.repo, ctx):
             label = 'log.parent changeset.%s' % pctx.phasestr()
             self.ui.write(columns['parent'] % scmutil.formatchangeid(pctx),
                           label=label)
 
         if self.ui.debugflag and rev is not None:
             mnode = ctx.manifestnode()
             mrev = self.repo.manifestlog._revlog.rev(mnode)
             self.ui.write(columns['manifest']
                           % scmutil.formatrevnode(self.ui, mrev, mnode),
                           label='ui.debug log.manifest')
         self.ui.write(columns['user'] % ctx.user(), label='log.user')
         self.ui.write(columns['date'] % util.datestr(ctx.date()),
                       label='log.date')
 
         if ctx.isunstable():
             instabilities = ctx.instabilities()
             self.ui.write(columns['instability'] % ', '.join(instabilities),
                           label='log.instability')
 
         elif ctx.obsolete():
             self._showobsfate(ctx)
 
         self._exthook(ctx)
 
         if self.ui.debugflag:
             files = ctx.p1().status(ctx)[:3]
             for key, value in zip(['files', 'files+', 'files-'], files):
                 if value:
                     self.ui.write(columns[key] % " ".join(value),
                                   label='ui.debug log.files')
         elif ctx.files() and self.ui.verbose:
             self.ui.write(columns['files'] % " ".join(ctx.files()),
                           label='ui.note log.files')
         if copies and self.ui.verbose:
             copies = ['%s (%s)' % c for c in copies]
             self.ui.write(columns['copies'] % ' '.join(copies),
                           label='ui.note log.copies')
 
         extra = ctx.extra()
         if extra and self.ui.debugflag:
             for key, value in sorted(extra.items()):
                 self.ui.write(columns['extra'] % (key, util.escapestr(value)),
                               label='ui.debug log.extra')
 
         description = ctx.description().strip()
         if description:
             if self.ui.verbose:
                 self.ui.write(_("description:\n"),
                               label='ui.note log.description')
                 self.ui.write(description,
                               label='ui.note log.description')
                 self.ui.write("\n\n")
             else:
                 self.ui.write(columns['summary'] % description.splitlines()[0],
                               label='log.summary')
         self.ui.write("\n")
 
         self.showpatch(ctx, matchfn, hunksfilterfn=hunksfilterfn)
 
     def _showobsfate(self, ctx):
         obsfate = templatekw.showobsfate(repo=self.repo, ctx=ctx, ui=self.ui)
 
         if obsfate:
             for obsfateline in obsfate:
                 self.ui.write(self._columns['obsolete'] % obsfateline,
                               label='log.obsfate')
 
     def _exthook(self, ctx):
         '''empty method used by extension as a hook point
         '''
 
     def showpatch(self, ctx, matchfn, hunksfilterfn=None):
         if not matchfn:
             matchfn = self.matchfn
         if matchfn:
             stat = self.diffopts.get('stat')
             diff = self.diffopts.get('patch')
             diffopts = patch.diffallopts(self.ui, self.diffopts)
             node = ctx.node()
             prev = ctx.p1().node()
             if stat:
                 diffordiffstat(self.ui, self.repo, diffopts, prev, node,
                                match=matchfn, stat=True,
                                hunksfilterfn=hunksfilterfn)
             if diff:
                 if stat:
                     self.ui.write("\n")
                 diffordiffstat(self.ui, self.repo, diffopts, prev, node,
                                match=matchfn, stat=False,
                                hunksfilterfn=hunksfilterfn)
             self.ui.write("\n")
 
 class jsonchangeset(changeset_printer):
     '''format changeset information.'''
 
     def __init__(self, ui, repo, matchfn, diffopts, buffered):
         changeset_printer.__init__(self, ui, repo, matchfn, diffopts, buffered)
         self.cache = {}
         self._first = True
 
     def close(self):
         if not self._first:
             self.ui.write("\n]\n")
         else:
             self.ui.write("[]\n")
 
     def _show(self, ctx, copies, matchfn, hunksfilterfn, props):
         '''show a single changeset or file revision'''
         rev = ctx.rev()
         if rev is None:
             jrev = jnode = 'null'
         else:
             jrev = '%d' % rev
             jnode = '"%s"' % hex(ctx.node())
         j = encoding.jsonescape
 
         if self._first:
             self.ui.write("[\n {")
             self._first = False
         else:
             self.ui.write(",\n {")
 
         if self.ui.quiet:
             self.ui.write(('\n  "rev": %s') % jrev)
             self.ui.write((',\n  "node": %s') % jnode)
             self.ui.write('\n }')
             return
 
         self.ui.write(('\n  "rev": %s') % jrev)
         self.ui.write((',\n  "node": %s') % jnode)
         self.ui.write((',\n  "branch": "%s"') % j(ctx.branch()))
         self.ui.write((',\n  "phase": "%s"') % ctx.phasestr())
         self.ui.write((',\n  "user": "%s"') % j(ctx.user()))
         self.ui.write((',\n  "date": [%d, %d]') % ctx.date())
         self.ui.write((',\n  "desc": "%s"') % j(ctx.description()))
 
         self.ui.write((',\n  "bookmarks": [%s]') %
                       ", ".join('"%s"' % j(b) for b in ctx.bookmarks()))
         self.ui.write((',\n  "tags": [%s]') %
                       ", ".join('"%s"' % j(t) for t in ctx.tags()))
         self.ui.write((',\n  "parents": [%s]') %
                       ", ".join('"%s"' % c.hex() for c in ctx.parents()))
 
         if self.ui.debugflag:
             if rev is None:
                 jmanifestnode = 'null'
             else:
                 jmanifestnode = '"%s"' % hex(ctx.manifestnode())
             self.ui.write((',\n  "manifest": %s') % jmanifestnode)
 
             self.ui.write((',\n  "extra": {%s}') %
                           ", ".join('"%s": "%s"' % (j(k), j(v))
                                     for k, v in ctx.extra().items()))
 
             files = ctx.p1().status(ctx)
             self.ui.write((',\n  "modified": [%s]') %
                           ", ".join('"%s"' % j(f) for f in files[0]))
             self.ui.write((',\n  "added": [%s]') %
                           ", ".join('"%s"' % j(f) for f in files[1]))
             self.ui.write((',\n  "removed": [%s]') %
                           ", ".join('"%s"' % j(f) for f in files[2]))
 
         elif self.ui.verbose:
             self.ui.write((',\n  "files": [%s]') %
                           ", ".join('"%s"' % j(f) for f in ctx.files()))
 
             if copies:
                 self.ui.write((',\n  "copies": {%s}') %
                               ", ".join('"%s": "%s"' % (j(k), j(v))
                                                         for k, v in copies))
 
         matchfn = self.matchfn
         if matchfn:
             stat = self.diffopts.get('stat')
             diff = self.diffopts.get('patch')
             diffopts = patch.difffeatureopts(self.ui, self.diffopts, git=True)
             node, prev = ctx.node(), ctx.p1().node()
             if stat:
                 self.ui.pushbuffer()
                 diffordiffstat(self.ui, self.repo, diffopts, prev, node,
                                match=matchfn, stat=True)
                 self.ui.write((',\n  "diffstat": "%s"')
                               % j(self.ui.popbuffer()))
             if diff:
                 self.ui.pushbuffer()
                 diffordiffstat(self.ui, self.repo, diffopts, prev, node,
                                match=matchfn, stat=False)
                 self.ui.write((',\n  "diff": "%s"') % j(self.ui.popbuffer()))
 
         self.ui.write("\n }")
 
 class changeset_templater(changeset_printer):
     '''format changeset information.
 
     Note: there are a variety of convenience functions to build a
     changeset_templater for common cases. See functions such as:
     makelogtemplater, show_changeset, buildcommittemplate, or other
     functions that use changesest_templater.
     '''
 
     # Arguments before "buffered" used to be positional. Consider not
     # adding/removing arguments before "buffered" to not break callers.
     def __init__(self, ui, repo, tmplspec, matchfn=None, diffopts=None,
                  buffered=False):
         diffopts = diffopts or {}
 
         changeset_printer.__init__(self, ui, repo, matchfn, diffopts, buffered)
         self.t = formatter.loadtemplater(ui, tmplspec,
                                          cache=templatekw.defaulttempl)
         self._counter = itertools.count()
         self.cache = {}
 
         self._tref = tmplspec.ref
         self._parts = {'header': '', 'footer': '',
                        tmplspec.ref: tmplspec.ref,
                        'docheader': '', 'docfooter': '',
                        'separator': ''}
         if tmplspec.mapfile:
             # find correct templates for current mode, for backward
             # compatibility with 'log -v/-q/--debug' using a mapfile
             tmplmodes = [
                 (True, ''),
                 (self.ui.verbose, '_verbose'),
                 (self.ui.quiet, '_quiet'),
                 (self.ui.debugflag, '_debug'),
             ]
             for mode, postfix in tmplmodes:
                 for t in self._parts:
                     cur = t + postfix
                     if mode and cur in self.t:
                         self._parts[t] = cur
         else:
             partnames = [p for p in self._parts.keys() if p != tmplspec.ref]
             m = formatter.templatepartsmap(tmplspec, self.t, partnames)
             self._parts.update(m)
 
         if self._parts['docheader']:
             self.ui.write(templater.stringify(self.t(self._parts['docheader'])))
 
     def close(self):
         if self._parts['docfooter']:
             if not self.footer:
                 self.footer = ""
             self.footer += templater.stringify(self.t(self._parts['docfooter']))
         return super(changeset_templater, self).close()
 
     def _show(self, ctx, copies, matchfn, hunksfilterfn, props):
         '''show a single changeset or file revision'''
         props = props.copy()
         props.update(templatekw.keywords)
         props['templ'] = self.t
         props['ctx'] = ctx
         props['repo'] = self.repo
         props['ui'] = self.repo.ui
         props['index'] = index = next(self._counter)
         props['revcache'] = {'copies': copies}
         props['cache'] = self.cache
         props = pycompat.strkwargs(props)
 
         # write separator, which wouldn't work well with the header part below
         # since there's inherently a conflict between header (across items) and
         # separator (per item)
         if self._parts['separator'] and index > 0:
             self.ui.write(templater.stringify(self.t(self._parts['separator'])))
 
         # write header
         if self._parts['header']:
             h = templater.stringify(self.t(self._parts['header'], **props))
             if self.buffered:
                 self.header[ctx.rev()] = h
             else:
                 if self.lastheader != h:
                     self.lastheader = h
                     self.ui.write(h)
 
         # write changeset metadata, then patch if requested
         key = self._parts[self._tref]
         self.ui.write(templater.stringify(self.t(key, **props)))
         self.showpatch(ctx, matchfn, hunksfilterfn=hunksfilterfn)
 
         if self._parts['footer']:
             if not self.footer:
                 self.footer = templater.stringify(
                     self.t(self._parts['footer'], **props))
 
 def logtemplatespec(tmpl, mapfile):
     if mapfile:
         return formatter.templatespec('changeset', tmpl, mapfile)
     else:
         return formatter.templatespec('', tmpl, None)
 
 def _lookuplogtemplate(ui, tmpl, style):
     """Find the template matching the given template spec or style
 
     See formatter.lookuptemplate() for details.
     """
 
     # ui settings
     if not tmpl and not style: # template are stronger than style
         tmpl = ui.config('ui', 'logtemplate')
         if tmpl:
             return logtemplatespec(templater.unquotestring(tmpl), None)
         else:
             style = util.expandpath(ui.config('ui', 'style'))
 
     if not tmpl and style:
         mapfile = style
         if not os.path.split(mapfile)[0]:
             mapname = (templater.templatepath('map-cmdline.' + mapfile)
                        or templater.templatepath(mapfile))
             if mapname:
                 mapfile = mapname
         return logtemplatespec(None, mapfile)
 
     if not tmpl:
         return logtemplatespec(None, None)
 
     return formatter.lookuptemplate(ui, 'changeset', tmpl)
 
 def makelogtemplater(ui, repo, tmpl, buffered=False):
     """Create a changeset_templater from a literal template 'tmpl'
     byte-string."""
     spec = logtemplatespec(tmpl, None)
     return changeset_templater(ui, repo, spec, buffered=buffered)
 
 def show_changeset(ui, repo, opts, buffered=False):
     """show one changeset using template or regular display.
 
     Display format will be the first non-empty hit of:
     1. option 'template'
     2. option 'style'
     3. [ui] setting 'logtemplate'
     4. [ui] setting 'style'
     If all of these values are either the unset or the empty string,
     regular display via changeset_printer() is done.
     """
     # options
     match = None
     if opts.get('patch') or opts.get('stat'):
         match = scmutil.matchall(repo)
 
     if opts.get('template') == 'json':
         return jsonchangeset(ui, repo, match, opts, buffered)
 
     spec = _lookuplogtemplate(ui, opts.get('template'), opts.get('style'))
 
     if not spec.ref and not spec.tmpl and not spec.mapfile:
         return changeset_printer(ui, repo, match, opts, buffered)
 
     return changeset_templater(ui, repo, spec, match, opts, buffered)
 
 def showmarker(fm, marker, index=None):
     """utility function to display obsolescence marker in a readable way
 
     To be used by debug function."""
     if index is not None:
         fm.write('index', '%i ', index)
     fm.write('prednode', '%s ', hex(marker.prednode()))
     succs = marker.succnodes()
     fm.condwrite(succs, 'succnodes', '%s ',
                  fm.formatlist(map(hex, succs), name='node'))
     fm.write('flag', '%X ', marker.flags())
     parents = marker.parentnodes()
     if parents is not None:
         fm.write('parentnodes', '{%s} ',
                  fm.formatlist(map(hex, parents), name='node', sep=', '))
     fm.write('date', '(%s) ', fm.formatdate(marker.date()))
     meta = marker.metadata().copy()
     meta.pop('date', None)
     fm.write('metadata', '{%s}', fm.formatdict(meta, fmt='%r: %r', sep=', '))
     fm.plain('\n')
 
 def finddate(ui, repo, date):
     """Find the tipmost changeset that matches the given date spec"""
 
     df = util.matchdate(date)
     m = scmutil.matchall(repo)
     results = {}
 
     def prep(ctx, fns):
         d = ctx.date()
         if df(d[0]):
             results[ctx.rev()] = d
 
     for ctx in walkchangerevs(repo, m, {'rev': None}, prep):
         rev = ctx.rev()
         if rev in results:
             ui.status(_("found revision %s from %s\n") %
                       (rev, util.datestr(results[rev])))
             return '%d' % rev
 
     raise error.Abort(_("revision matching date not found"))
 
 def increasingwindows(windowsize=8, sizelimit=512):
     while True:
         yield windowsize
         if windowsize < sizelimit:
             windowsize *= 2
 
 class FileWalkError(Exception):
     pass
 
 def walkfilerevs(repo, match, follow, revs, fncache):
     '''Walks the file history for the matched files.
 
     Returns the changeset revs that are involved in the file history.
 
     Throws FileWalkError if the file history can't be walked using
     filelogs alone.
     '''
     wanted = set()
     copies = []
     minrev, maxrev = min(revs), max(revs)
     def filerevgen(filelog, last):
         """
         Only files, no patterns.  Check the history of each file.
 
         Examines filelog entries within minrev, maxrev linkrev range
         Returns an iterator yielding (linkrev, parentlinkrevs, copied)
         tuples in backwards order
         """
         cl_count = len(repo)
         revs = []
         for j in xrange(0, last + 1):
             linkrev = filelog.linkrev(j)
             if linkrev < minrev:
                 continue
             # only yield rev for which we have the changelog, it can
             # happen while doing "hg log" during a pull or commit
             if linkrev >= cl_count:
                 break
 
             parentlinkrevs = []
             for p in filelog.parentrevs(j):
                 if p != nullrev:
                     parentlinkrevs.append(filelog.linkrev(p))
             n = filelog.node(j)
             revs.append((linkrev, parentlinkrevs,
                          follow and filelog.renamed(n)))
 
         return reversed(revs)
     def iterfiles():
         pctx = repo['.']
         for filename in match.files():
             if follow:
                 if filename not in pctx:
                     raise error.Abort(_('cannot follow file not in parent '
                                        'revision: "%s"') % filename)
                 yield filename, pctx[filename].filenode()
             else:
                 yield filename, None
         for filename_node in copies:
             yield filename_node
 
     for file_, node in iterfiles():
         filelog = repo.file(file_)
         if not len(filelog):
             if node is None:
                 # A zero count may be a directory or deleted file, so
                 # try to find matching entries on the slow path.
                 if follow:
                     raise error.Abort(
                         _('cannot follow nonexistent file: "%s"') % file_)
                 raise FileWalkError("Cannot walk via filelog")
             else:
                 continue
 
         if node is None:
             last = len(filelog) - 1
         else:
             last = filelog.rev(node)
 
         # keep track of all ancestors of the file
         ancestors = {filelog.linkrev(last)}
 
         # iterate from latest to oldest revision
         for rev, flparentlinkrevs, copied in filerevgen(filelog, last):
             if not follow:
                 if rev > maxrev:
                     continue
             else:
                 # Note that last might not be the first interesting
                 # rev to us:
                 # if the file has been changed after maxrev, we'll
                 # have linkrev(last) > maxrev, and we still need
                 # to explore the file graph
                 if rev not in ancestors:
                     continue
                 # XXX insert 1327 fix here
                 if flparentlinkrevs:
                     ancestors.update(flparentlinkrevs)
 
             fncache.setdefault(rev, []).append(file_)
             wanted.add(rev)
             if copied:
                 copies.append(copied)
 
     return wanted
 
 class _followfilter(object):
     def __init__(self, repo, onlyfirst=False):
         self.repo = repo
         self.startrev = nullrev
         self.roots = set()
         self.onlyfirst = onlyfirst
 
     def match(self, rev):
         def realparents(rev):
             if self.onlyfirst:
                 return self.repo.changelog.parentrevs(rev)[0:1]
             else:
                 return filter(lambda x: x != nullrev,
                               self.repo.changelog.parentrevs(rev))
 
         if self.startrev == nullrev:
             self.startrev = rev
             return True
 
         if rev > self.startrev:
             # forward: all descendants
             if not self.roots:
                 self.roots.add(self.startrev)
             for parent in realparents(rev):
                 if parent in self.roots:
                     self.roots.add(rev)
                     return True
         else:
             # backwards: all parents
             if not self.roots:
                 self.roots.update(realparents(self.startrev))
             if rev in self.roots:
                 self.roots.remove(rev)
                 self.roots.update(realparents(rev))
                 return True
 
         return False
 
 def walkchangerevs(repo, match, opts, prepare):
     '''Iterate over files and the revs in which they changed.
 
     Callers most commonly need to iterate backwards over the history
     in which they are interested. Doing so has awful (quadratic-looking)
     performance, so we use iterators in a "windowed" way.
 
     We walk a window of revisions in the desired order.  Within the
     window, we first walk forwards to gather data, then in the desired
     order (usually backwards) to display it.
 
     This function returns an iterator yielding contexts. Before
     yielding each context, the iterator will first call the prepare
     function on each context in the window in forward order.'''
 
     follow = opts.get('follow') or opts.get('follow_first')
     revs = _logrevs(repo, opts)
     if not revs:
         return []
     wanted = set()
     slowpath = match.anypats() or ((match.isexact() or match.prefix()) and
                                    opts.get('removed'))
     fncache = {}
     change = repo.changectx
 
     # First step is to fill wanted, the set of revisions that we want to yield.
     # When it does not induce extra cost, we also fill fncache for revisions in
     # wanted: a cache of filenames that were changed (ctx.files()) and that
     # match the file filtering conditions.
 
     if match.always():
         # No files, no patterns.  Display all revs.
         wanted = revs
     elif not slowpath:
         # We only have to read through the filelog to find wanted revisions
 
         try:
             wanted = walkfilerevs(repo, match, follow, revs, fncache)
         except FileWalkError:
             slowpath = True
 
             # We decided to fall back to the slowpath because at least one
             # of the paths was not a file. Check to see if at least one of them
             # existed in history, otherwise simply return
             for path in match.files():
                 if path == '.' or path in repo.store:
                     break
             else:
                 return []
 
     if slowpath:
         # We have to read the changelog to match filenames against
         # changed files
 
         if follow:
             raise error.Abort(_('can only follow copies/renames for explicit '
                                'filenames'))
 
         # The slow path checks files modified in every changeset.
         # This is really slow on large repos, so compute the set lazily.
         class lazywantedset(object):
             def __init__(self):
                 self.set = set()
                 self.revs = set(revs)
 
             # No need to worry about locality here because it will be accessed
             # in the same order as the increasing window below.
             def __contains__(self, value):
                 if value in self.set:
                     return True
                 elif not value in self.revs:
                     return False
                 else:
                     self.revs.discard(value)
                     ctx = change(value)
                     matches = filter(match, ctx.files())
                     if matches:
                         fncache[value] = matches
                         self.set.add(value)
                         return True
                     return False
 
             def discard(self, value):
                 self.revs.discard(value)
                 self.set.discard(value)
 
         wanted = lazywantedset()
 
     # it might be worthwhile to do this in the iterator if the rev range
     # is descending and the prune args are all within that range
     for rev in opts.get('prune', ()):
         rev = repo[rev].rev()
         ff = _followfilter(repo)
         stop = min(revs[0], revs[-1])
         for x in xrange(rev, stop - 1, -1):
             if ff.match(x):
                 wanted = wanted - [x]
 
     # Now that wanted is correctly initialized, we can iterate over the
     # revision range, yielding only revisions in wanted.
     def iterate():
         if follow and match.always():
             ff = _followfilter(repo, onlyfirst=opts.get('follow_first'))
             def want(rev):
                 return ff.match(rev) and rev in wanted
         else:
             def want(rev):
                 return rev in wanted
 
         it = iter(revs)
         stopiteration = False
         for windowsize in increasingwindows():
             nrevs = []
             for i in xrange(windowsize):
                 rev = next(it, None)
                 if rev is None:
                     stopiteration = True
                     break
                 elif want(rev):
                     nrevs.append(rev)
             for rev in sorted(nrevs):
                 fns = fncache.get(rev)
                 ctx = change(rev)
                 if not fns:
                     def fns_generator():
                         for f in ctx.files():
                             if match(f):
                                 yield f
                     fns = fns_generator()
                 prepare(ctx, fns)
             for rev in nrevs:
                 yield change(rev)
 
             if stopiteration:
                 break
 
     return iterate()
 
 def _makefollowlogfilematcher(repo, files, followfirst):
     # When displaying a revision with --patch --follow FILE, we have
     # to know which file of the revision must be diffed. With
     # --follow, we want the names of the ancestors of FILE in the
     # revision, stored in "fcache". "fcache" is populated by
     # reproducing the graph traversal already done by --follow revset
     # and relating revs to file names (which is not "correct" but
     # good enough).
     fcache = {}
     fcacheready = [False]
     pctx = repo['.']
 
     def populate():
         for fn in files:
             fctx = pctx[fn]
             fcache.setdefault(fctx.introrev(), set()).add(fctx.path())
             for c in fctx.ancestors(followfirst=followfirst):
                 fcache.setdefault(c.rev(), set()).add(c.path())
 
     def filematcher(rev):
         if not fcacheready[0]:
             # Lazy initialization
             fcacheready[0] = True
             populate()
         return scmutil.matchfiles(repo, fcache.get(rev, []))
 
     return filematcher
 
 def _makenofollowlogfilematcher(repo, pats, opts):
     '''hook for extensions to override the filematcher for non-follow cases'''
     return None
 
 def _makelogrevset(repo, pats, opts, revs):
     """Return (expr, filematcher) where expr is a revset string built
     from log options and file patterns or None. If --stat or --patch
     are not passed filematcher is None. Otherwise it is a callable
     taking a revision number and returning a match objects filtering
     the files to be detailed when displaying the revision.
     """
     opt2revset = {
         'no_merges':        ('not merge()', None),
         'only_merges':      ('merge()', None),
         '_ancestors':       ('ancestors(%(val)s)', None),
         '_fancestors':      ('_firstancestors(%(val)s)', None),
         '_descendants':     ('descendants(%(val)s)', None),
         '_fdescendants':    ('_firstdescendants(%(val)s)', None),
         '_matchfiles':      ('_matchfiles(%(val)s)', None),
         'date':             ('date(%(val)r)', None),
         'branch':           ('branch(%(val)r)', ' or '),
         '_patslog':         ('filelog(%(val)r)', ' or '),
         '_patsfollow':      ('follow(%(val)r)', ' or '),
         '_patsfollowfirst': ('_followfirst(%(val)r)', ' or '),
         'keyword':          ('keyword(%(val)r)', ' or '),
         'prune':            ('not (%(val)r or ancestors(%(val)r))', ' and '),
         'user':             ('user(%(val)r)', ' or '),
         }
 
     opts = dict(opts)
     # follow or not follow?
     follow = opts.get('follow') or opts.get('follow_first')
     if opts.get('follow_first'):
         followfirst = 1
     else:
         followfirst = 0
     # --follow with FILE behavior depends on revs...
     it = iter(revs)
     startrev = next(it)
     followdescendants = startrev < next(it, startrev)
 
     # branch and only_branch are really aliases and must be handled at
     # the same time
     opts['branch'] = opts.get('branch', []) + opts.get('only_branch', [])
     opts['branch'] = [repo.lookupbranch(b) for b in opts['branch']]
     # pats/include/exclude are passed to match.match() directly in
     # _matchfiles() revset but walkchangerevs() builds its matcher with
     # scmutil.match(). The difference is input pats are globbed on
     # platforms without shell expansion (windows).
     wctx = repo[None]
     match, pats = scmutil.matchandpats(wctx, pats, opts)
     slowpath = match.anypats() or ((match.isexact() or match.prefix()) and
                                    opts.get('removed'))
     if not slowpath:
         for f in match.files():
             if follow and f not in wctx:
                 # If the file exists, it may be a directory, so let it
                 # take the slow path.
                 if os.path.exists(repo.wjoin(f)):
                     slowpath = True
                     continue
                 else:
                     raise error.Abort(_('cannot follow file not in parent '
                                        'revision: "%s"') % f)
             filelog = repo.file(f)
             if not filelog:
                 # A zero count may be a directory or deleted file, so
                 # try to find matching entries on the slow path.
                 if follow:
                     raise error.Abort(
                         _('cannot follow nonexistent file: "%s"') % f)
                 slowpath = True
 
         # We decided to fall back to the slowpath because at least one
         # of the paths was not a file. Check to see if at least one of them
         # existed in history - in that case, we'll continue down the
         # slowpath; otherwise, we can turn off the slowpath
         if slowpath:
             for path in match.files():
                 if path == '.' or path in repo.store:
                     break
             else:
                 slowpath = False
 
     fpats = ('_patsfollow', '_patsfollowfirst')
     fnopats = (('_ancestors', '_fancestors'),
                ('_descendants', '_fdescendants'))
     if slowpath:
         # See walkchangerevs() slow path.
         #
         # pats/include/exclude cannot be represented as separate
         # revset expressions as their filtering logic applies at file
         # level. For instance "-I a -X a" matches a revision touching
         # "a" and "b" while "file(a) and not file(b)" does
         # not. Besides, filesets are evaluated against the working
         # directory.
         matchargs = ['r:', 'd:relpath']
         for p in pats:
             matchargs.append('p:' + p)
         for p in opts.get('include', []):
             matchargs.append('i:' + p)
         for p in opts.get('exclude', []):
             matchargs.append('x:' + p)
         matchargs = ','.join(('%r' % p) for p in matchargs)
         opts['_matchfiles'] = matchargs
         if follow:
             opts[fnopats[0][followfirst]] = '.'
     else:
         if follow:
             if pats:
                 # follow() revset interprets its file argument as a
                 # manifest entry, so use match.files(), not pats.
                 opts[fpats[followfirst]] = list(match.files())
             else:
                 op = fnopats[followdescendants][followfirst]
                 opts[op] = 'rev(%d)' % startrev
         else:
             opts['_patslog'] = list(pats)
 
     filematcher = None
     if opts.get('patch') or opts.get('stat'):
         # When following files, track renames via a special matcher.
         # If we're forced to take the slowpath it means we're following
         # at least one pattern/directory, so don't bother with rename tracking.
         if follow and not match.always() and not slowpath:
             # _makefollowlogfilematcher expects its files argument to be
             # relative to the repo root, so use match.files(), not pats.
             filematcher = _makefollowlogfilematcher(repo, match.files(),
                                                     followfirst)
         else:
             filematcher = _makenofollowlogfilematcher(repo, pats, opts)
             if filematcher is None:
                 filematcher = lambda rev: match
 
     expr = []
     for op, val in sorted(opts.iteritems()):
         if not val:
             continue
         if op not in opt2revset:
             continue
         revop, andor = opt2revset[op]
         if '%(val)' not in revop:
             expr.append(revop)
         else:
             if not isinstance(val, list):
                 e = revop % {'val': val}
             else:
                 e = '(' + andor.join((revop % {'val': v}) for v in val) + ')'
             expr.append(e)
 
     if expr:
         expr = '(' + ' and '.join(expr) + ')'
     else:
         expr = None
     return expr, filematcher
 
 def _logrevs(repo, opts):
     # Default --rev value depends on --follow but --follow behavior
     # depends on revisions resolved from --rev...
     follow = opts.get('follow') or opts.get('follow_first')
     if opts.get('rev'):
         revs = scmutil.revrange(repo, opts['rev'])
     elif follow and repo.dirstate.p1() == nullid:
         revs = smartset.baseset()
     elif follow:
         revs = repo.revs('reverse(:.)')
     else:
         revs = smartset.spanset(repo)
         revs.reverse()
     return revs
 
 def getgraphlogrevs(repo, pats, opts):
     """Return (revs, expr, filematcher) where revs is an iterable of
     revision numbers, expr is a revset string built from log options
     and file patterns or None, and used to filter 'revs'. If --stat or
     --patch are not passed filematcher is None. Otherwise it is a
     callable taking a revision number and returning a match objects
     filtering the files to be detailed when displaying the revision.
     """
     limit = loglimit(opts)
     revs = _logrevs(repo, opts)
     if not revs:
         return smartset.baseset(), None, None
     expr, filematcher = _makelogrevset(repo, pats, opts, revs)
     if opts.get('rev'):
         # User-specified revs might be unsorted, but don't sort before
         # _makelogrevset because it might depend on the order of revs
         if not (revs.isdescending() or revs.istopo()):
             revs.sort(reverse=True)
     if expr:
         matcher = revset.match(repo.ui, expr)
         revs = matcher(repo, revs)
     if limit is not None:
         limitedrevs = []
         for idx, rev in enumerate(revs):
             if idx >= limit:
                 break
             limitedrevs.append(rev)
         revs = smartset.baseset(limitedrevs)
 
     return revs, expr, filematcher
 
 def getlogrevs(repo, pats, opts):
     """Return (revs, expr, filematcher) where revs is an iterable of
     revision numbers, expr is a revset string built from log options
     and file patterns or None, and used to filter 'revs'. If --stat or
     --patch are not passed filematcher is None. Otherwise it is a
     callable taking a revision number and returning a match objects
     filtering the files to be detailed when displaying the revision.
     """
     limit = loglimit(opts)
     revs = _logrevs(repo, opts)
     if not revs:
         return smartset.baseset([]), None, None
     expr, filematcher = _makelogrevset(repo, pats, opts, revs)
     if expr:
         matcher = revset.match(repo.ui, expr)
         revs = matcher(repo, revs)
     if limit is not None:
         limitedrevs = []
         for idx, r in enumerate(revs):
             if limit <= idx:
                 break
             limitedrevs.append(r)
         revs = smartset.baseset(limitedrevs)
 
     return revs, expr, filematcher
 
 def _parselinerangelogopt(repo, opts):
     """Parse --line-range log option and return a list of tuples (filename,
     (fromline, toline)).
     """
     linerangebyfname = []
     for pat in opts.get('line_range', []):
         try:
             pat, linerange = pat.rsplit(',', 1)
         except ValueError:
             raise error.Abort(_('malformatted line-range pattern %s') % pat)
         try:
             fromline, toline = map(int, linerange.split(':'))
         except ValueError:
             raise error.Abort(_("invalid line range for %s") % pat)
         msg = _("line range pattern '%s' must match exactly one file") % pat
         fname = scmutil.parsefollowlinespattern(repo, None, pat, msg)
         linerangebyfname.append(
             (fname, util.processlinerange(fromline, toline)))
     return linerangebyfname
 
 def getloglinerangerevs(repo, userrevs, opts):
     """Return (revs, filematcher, hunksfilter).
 
     "revs" are revisions obtained by processing "line-range" log options and
     walking block ancestors of each specified file/line-range.
 
     "filematcher(rev) -> match" is a factory function returning a match object
     for a given revision for file patterns specified in --line-range option.
     If neither --stat nor --patch options are passed, "filematcher" is None.
 
     "hunksfilter(rev) -> filterfn(fctx, hunks)" is a factory function
     returning a hunks filtering function.
     If neither --stat nor --patch options are passed, "filterhunks" is None.
     """
     wctx = repo[None]
 
     # Two-levels map of "rev -> file ctx -> [line range]".
     linerangesbyrev = {}
     for fname, (fromline, toline) in _parselinerangelogopt(repo, opts):
         if fname not in wctx:
             raise error.Abort(_('cannot follow file not in parent '
                                 'revision: "%s"') % fname)
         fctx = wctx.filectx(fname)
         for fctx, linerange in dagop.blockancestors(fctx, fromline, toline):
             rev = fctx.introrev()
             if rev not in userrevs:
                 continue
             linerangesbyrev.setdefault(
                 rev, {}).setdefault(
                     fctx.path(), []).append(linerange)
 
     filematcher = None
     hunksfilter = None
     if opts.get('patch') or opts.get('stat'):
 
         def nofilterhunksfn(fctx, hunks):
             return hunks
 
         def hunksfilter(rev):
             fctxlineranges = linerangesbyrev.get(rev)
             if fctxlineranges is None:
                 return nofilterhunksfn
 
             def filterfn(fctx, hunks):
                 lineranges = fctxlineranges.get(fctx.path())
                 if lineranges is not None:
                     for hr, lines in hunks:
                         if hr is None: # binary
                             yield hr, lines
                             continue
                         if any(mdiff.hunkinrange(hr[2:], lr)
                                for lr in lineranges):
                             yield hr, lines
                 else:
                     for hunk in hunks:
                         yield hunk
 
             return filterfn
 
         def filematcher(rev):
             files = list(linerangesbyrev.get(rev, []))
             return scmutil.matchfiles(repo, files)
 
     revs = sorted(linerangesbyrev, reverse=True)
 
     return revs, filematcher, hunksfilter
 
 def _graphnodeformatter(ui, displayer):
     spec = ui.config('ui', 'graphnodetemplate')
     if not spec:
         return templatekw.showgraphnode  # fast path for "{graphnode}"
 
     spec = templater.unquotestring(spec)
     templ = formatter.maketemplater(ui, spec)
     cache = {}
     if isinstance(displayer, changeset_templater):
         cache = displayer.cache  # reuse cache of slow templates
     props = templatekw.keywords.copy()
     props['templ'] = templ
     props['cache'] = cache
     def formatnode(repo, ctx):
         props['ctx'] = ctx
         props['repo'] = repo
         props['ui'] = repo.ui
         props['revcache'] = {}
         return templ.render(props)
     return formatnode
 
 def displaygraph(ui, repo, dag, displayer, edgefn, getrenamed=None,
                  filematcher=None, props=None):
     props = props or {}
     formatnode = _graphnodeformatter(ui, displayer)
     state = graphmod.asciistate()
     styles = state['styles']
 
     # only set graph styling if HGPLAIN is not set.
     if ui.plain('graph'):
         # set all edge styles to |, the default pre-3.8 behaviour
         styles.update(dict.fromkeys(styles, '|'))
     else:
         edgetypes = {
             'parent': graphmod.PARENT,
             'grandparent': graphmod.GRANDPARENT,
             'missing': graphmod.MISSINGPARENT
         }
         for name, key in edgetypes.items():
             # experimental config: experimental.graphstyle.*
             styles[key] = ui.config('experimental', 'graphstyle.%s' % name,
                                     styles[key])
             if not styles[key]:
                 styles[key] = None
 
         # experimental config: experimental.graphshorten
         state['graphshorten'] = ui.configbool('experimental', 'graphshorten')
 
     for rev, type, ctx, parents in dag:
         char = formatnode(repo, ctx)
         copies = None
         if getrenamed and ctx.rev():
             copies = []
             for fn in ctx.files():
                 rename = getrenamed(fn, ctx.rev())
                 if rename:
                     copies.append((fn, rename[0]))
         revmatchfn = None
         if filematcher is not None:
             revmatchfn = filematcher(ctx.rev())
         edges = edgefn(type, char, state, rev, parents)
         firstedge = next(edges)
         width = firstedge[2]
         displayer.show(ctx, copies=copies, matchfn=revmatchfn,
                        _graphwidth=width, **props)
         lines = displayer.hunk.pop(rev).split('\n')
         if not lines[-1]:
             del lines[-1]
         displayer.flush(ctx)
         for type, char, width, coldata in itertools.chain([firstedge], edges):
             graphmod.ascii(ui, state, type, char, lines, coldata)
             lines = []
     displayer.close()
 
 def graphlog(ui, repo, pats, opts):
     # Parameters are identical to log command ones
     revs, expr, filematcher = getgraphlogrevs(repo, pats, opts)
     revdag = graphmod.dagwalker(repo, revs)
 
     getrenamed = None
     if opts.get('copies'):
         endrev = None
         if opts.get('rev'):
             endrev = scmutil.revrange(repo, opts.get('rev')).max() + 1
         getrenamed = templatekw.getrenamedfn(repo, endrev=endrev)
 
     ui.pager('log')
     displayer = show_changeset(ui, repo, opts, buffered=True)
     displaygraph(ui, repo, revdag, displayer, graphmod.asciiedges, getrenamed,
                  filematcher)
 
 def checkunsupportedgraphflags(pats, opts):
     for op in ["newest_first"]:
         if op in opts and opts[op]:
             raise error.Abort(_("-G/--graph option is incompatible with --%s")
                              % op.replace("_", "-"))
 
 def graphrevs(repo, nodes, opts):
     limit = loglimit(opts)
     nodes.reverse()
     if limit is not None:
         nodes = nodes[:limit]
     return graphmod.nodes(repo, nodes)
 
 def add(ui, repo, match, prefix, explicitonly, **opts):
     join = lambda f: os.path.join(prefix, f)
     bad = []
 
     badfn = lambda x, y: bad.append(x) or match.bad(x, y)
     names = []
     wctx = repo[None]
     cca = None
     abort, warn = scmutil.checkportabilityalert(ui)
     if abort or warn:
         cca = scmutil.casecollisionauditor(ui, abort, repo.dirstate)
 
     badmatch = matchmod.badmatch(match, badfn)
     dirstate = repo.dirstate
     # We don't want to just call wctx.walk here, since it would return a lot of
     # clean files, which we aren't interested in and takes time.
     for f in sorted(dirstate.walk(badmatch, subrepos=sorted(wctx.substate),
                                   unknown=True, ignored=False, full=False)):
         exact = match.exact(f)
         if exact or not explicitonly and f not in wctx and repo.wvfs.lexists(f):
             if cca:
                 cca(f)
             names.append(f)
             if ui.verbose or not exact:
                 ui.status(_('adding %s\n') % match.rel(f))
 
     for subpath in sorted(wctx.substate):
         sub = wctx.sub(subpath)
         try:
             submatch = matchmod.subdirmatcher(subpath, match)
             if opts.get(r'subrepos'):
                 bad.extend(sub.add(ui, submatch, prefix, False, **opts))
             else:
                 bad.extend(sub.add(ui, submatch, prefix, True, **opts))
         except error.LookupError:
             ui.status(_("skipping missing subrepository: %s\n")
                            % join(subpath))
 
     if not opts.get(r'dry_run'):
         rejected = wctx.add(names, prefix)
         bad.extend(f for f in rejected if f in match.files())
     return bad
 
 def addwebdirpath(repo, serverpath, webconf):
     webconf[serverpath] = repo.root
     repo.ui.debug('adding %s = %s\n' % (serverpath, repo.root))
 
     for r in repo.revs('filelog("path:.hgsub")'):
         ctx = repo[r]
         for subpath in ctx.substate:
             ctx.sub(subpath).addwebdirpath(serverpath, webconf)
 
 def forget(ui, repo, match, prefix, explicitonly):
     join = lambda f: os.path.join(prefix, f)
     bad = []
     badfn = lambda x, y: bad.append(x) or match.bad(x, y)
     wctx = repo[None]
     forgot = []
 
     s = repo.status(match=matchmod.badmatch(match, badfn), clean=True)
     forget = sorted(s.modified + s.added + s.deleted + s.clean)
     if explicitonly:
         forget = [f for f in forget if match.exact(f)]
 
     for subpath in sorted(wctx.substate):
         sub = wctx.sub(subpath)
         try:
             submatch = matchmod.subdirmatcher(subpath, match)
             subbad, subforgot = sub.forget(submatch, prefix)
             bad.extend([subpath + '/' + f for f in subbad])
             forgot.extend([subpath + '/' + f for f in subforgot])
         except error.LookupError:
             ui.status(_("skipping missing subrepository: %s\n")
                            % join(subpath))
 
     if not explicitonly:
         for f in match.files():
             if f not in repo.dirstate and not repo.wvfs.isdir(f):
                 if f not in forgot:
                     if repo.wvfs.exists(f):
                         # Don't complain if the exact case match wasn't given.
                         # But don't do this until after checking 'forgot', so
                         # that subrepo files aren't normalized, and this op is
                         # purely from data cached by the status walk above.
                         if repo.dirstate.normalize(f) in repo.dirstate:
                             continue
                         ui.warn(_('not removing %s: '
                                   'file is already untracked\n')
                                 % match.rel(f))
                     bad.append(f)
 
     for f in forget:
         if ui.verbose or not match.exact(f):
             ui.status(_('removing %s\n') % match.rel(f))
 
     rejected = wctx.forget(forget, prefix)
     bad.extend(f for f in rejected if f in match.files())
     forgot.extend(f for f in forget if f not in rejected)
     return bad, forgot
 
 def files(ui, ctx, m, fm, fmt, subrepos):
     rev = ctx.rev()
     ret = 1
     ds = ctx.repo().dirstate
 
     for f in ctx.matches(m):
         if rev is None and ds[f] == 'r':
             continue
         fm.startitem()
         if ui.verbose:
             fc = ctx[f]
             fm.write('size flags', '% 10d % 1s ', fc.size(), fc.flags())
         fm.data(abspath=f)
         fm.write('path', fmt, m.rel(f))
         ret = 0
 
     for subpath in sorted(ctx.substate):
         submatch = matchmod.subdirmatcher(subpath, m)
         if (subrepos or m.exact(subpath) or any(submatch.files())):
             sub = ctx.sub(subpath)
             try:
                 recurse = m.exact(subpath) or subrepos
                 if sub.printfiles(ui, submatch, fm, fmt, recurse) == 0:
                     ret = 0
             except error.LookupError:
                 ui.status(_("skipping missing subrepository: %s\n")
                                % m.abs(subpath))
 
     return ret
 
 def remove(ui, repo, m, prefix, after, force, subrepos, warnings=None):
     join = lambda f: os.path.join(prefix, f)
     ret = 0
     s = repo.status(match=m, clean=True)
     modified, added, deleted, clean = s[0], s[1], s[3], s[6]
 
     wctx = repo[None]
 
     if warnings is None:
         warnings = []
         warn = True
     else:
         warn = False
 
     subs = sorted(wctx.substate)
     total = len(subs)
     count = 0
     for subpath in subs:
         count += 1
         submatch = matchmod.subdirmatcher(subpath, m)
         if subrepos or m.exact(subpath) or any(submatch.files()):
             ui.progress(_('searching'), count, total=total, unit=_('subrepos'))
             sub = wctx.sub(subpath)
             try:
                 if sub.removefiles(submatch, prefix, after, force, subrepos,
                                    warnings):
                     ret = 1
             except error.LookupError:
                 warnings.append(_("skipping missing subrepository: %s\n")
                                % join(subpath))
     ui.progress(_('searching'), None)
 
     # warn about failure to delete explicit files/dirs
     deleteddirs = util.dirs(deleted)
     files = m.files()
     total = len(files)
     count = 0
     for f in files:
         def insubrepo():
             for subpath in wctx.substate:
                 if f.startswith(subpath + '/'):
                     return True
             return False
 
         count += 1
         ui.progress(_('deleting'), count, total=total, unit=_('files'))
         isdir = f in deleteddirs or wctx.hasdir(f)
         if (f in repo.dirstate or isdir or f == '.'
             or insubrepo() or f in subs):
             continue
 
         if repo.wvfs.exists(f):
             if repo.wvfs.isdir(f):
                 warnings.append(_('not removing %s: no tracked files\n')
                         % m.rel(f))
             else:
                 warnings.append(_('not removing %s: file is untracked\n')
                         % m.rel(f))
         # missing files will generate a warning elsewhere
         ret = 1
     ui.progress(_('deleting'), None)
 
     if force:
         list = modified + deleted + clean + added
     elif after:
         list = deleted
         remaining = modified + added + clean
         total = len(remaining)
         count = 0
         for f in remaining:
             count += 1
             ui.progress(_('skipping'), count, total=total, unit=_('files'))
             if ui.verbose or (f in files):
                 warnings.append(_('not removing %s: file still exists\n')
                                 % m.rel(f))
             ret = 1
         ui.progress(_('skipping'), None)
     else:
         list = deleted + clean
         total = len(modified) + len(added)
         count = 0
         for f in modified:
             count += 1
             ui.progress(_('skipping'), count, total=total, unit=_('files'))
             warnings.append(_('not removing %s: file is modified (use -f'
                       ' to force removal)\n') % m.rel(f))
             ret = 1
         for f in added:
             count += 1
             ui.progress(_('skipping'), count, total=total, unit=_('files'))
             warnings.append(_("not removing %s: file has been marked for add"
                       " (use 'hg forget' to undo add)\n") % m.rel(f))
             ret = 1
         ui.progress(_('skipping'), None)
 
     list = sorted(list)
     total = len(list)
     count = 0
     for f in list:
         count += 1
         if ui.verbose or not m.exact(f):
             ui.progress(_('deleting'), count, total=total, unit=_('files'))
             ui.status(_('removing %s\n') % m.rel(f))
     ui.progress(_('deleting'), None)
 
     with repo.wlock():
         if not after:
             for f in list:
                 if f in added:
                     continue # we never unlink added files on remove
                 repo.wvfs.unlinkpath(f, ignoremissing=True)
         repo[None].forget(list)
 
     if warn:
         for warning in warnings:
             ui.warn(warning)
 
     return ret
 
 def cat(ui, repo, ctx, matcher, basefm, fntemplate, prefix, **opts):
     err = 1
 
     def write(path):
         filename = None
         if fntemplate:
             filename = makefilename(repo, fntemplate, ctx.node(),
                                     pathname=os.path.join(prefix, path))
             # attempt to create the directory if it does not already exist
             try:
                 os.makedirs(os.path.dirname(filename))
             except OSError:
                 pass
         with formatter.maybereopen(basefm, filename, opts) as fm:
             data = ctx[path].data()
             if opts.get('decode'):
                 data = repo.wwritedata(path, data)
             fm.startitem()
             fm.write('data', '%s', data)
             fm.data(abspath=path, path=matcher.rel(path))
 
     # Automation often uses hg cat on single files, so special case it
     # for performance to avoid the cost of parsing the manifest.
     if len(matcher.files()) == 1 and not matcher.anypats():
         file = matcher.files()[0]
         mfl = repo.manifestlog
         mfnode = ctx.manifestnode()
         try:
             if mfnode and mfl[mfnode].find(file)[0]:
                 write(file)
                 return 0
         except KeyError:
             pass
 
     for abs in ctx.walk(matcher):
         write(abs)
         err = 0
 
     for subpath in sorted(ctx.substate):
         sub = ctx.sub(subpath)
         try:
             submatch = matchmod.subdirmatcher(subpath, matcher)
 
             if not sub.cat(submatch, basefm, fntemplate,
                            os.path.join(prefix, sub._path), **opts):
                 err = 0
         except error.RepoLookupError:
             ui.status(_("skipping missing subrepository: %s\n")
                            % os.path.join(prefix, subpath))
 
     return err
 
 def commit(ui, repo, commitfunc, pats, opts):
     '''commit the specified files or all outstanding changes'''
     date = opts.get('date')
     if date:
         opts['date'] = util.parsedate(date)
     message = logmessage(ui, opts)
     matcher = scmutil.match(repo[None], pats, opts)
 
     dsguard = None
     # extract addremove carefully -- this function can be called from a command
     # that doesn't support addremove
     if opts.get('addremove'):
         dsguard = dirstateguard.dirstateguard(repo, 'commit')
     with dsguard or util.nullcontextmanager():
         if dsguard:
             if scmutil.addremove(repo, matcher, "", opts) != 0:
                 raise error.Abort(
                     _("failed to mark all new/missing files as added/removed"))
 
         return commitfunc(ui, repo, message, matcher, opts)
 
 def samefile(f, ctx1, ctx2):
     if f in ctx1.manifest():
         a = ctx1.filectx(f)
         if f in ctx2.manifest():
             b = ctx2.filectx(f)
             return (not a.cmp(b)
                     and a.flags() == b.flags())
         else:
             return False
     else:
         return f not in ctx2.manifest()
 
 def amend(ui, repo, old, extra, pats, opts):
     # avoid cycle context -> subrepo -> cmdutil
     from . import context
 
     # amend will reuse the existing user if not specified, but the obsolete
     # marker creation requires that the current user's name is specified.
     if obsolete.isenabled(repo, obsolete.createmarkersopt):
         ui.username() # raise exception if username not set
 
     ui.note(_('amending changeset %s\n') % old)
     base = old.p1()
 
     with repo.wlock(), repo.lock(), repo.transaction('amend'):
         # Participating changesets:
         #
         # wctx     o - workingctx that contains changes from working copy
         #          |   to go into amending commit
         #          |
         # old      o - changeset to amend
         #          |
         # base     o - first parent of the changeset to amend
         wctx = repo[None]
 
         # Copy to avoid mutating input
         extra = extra.copy()
         # Update extra dict from amended commit (e.g. to preserve graft
         # source)
         extra.update(old.extra())
 
         # Also update it from the from the wctx
         extra.update(wctx.extra())
 
         user = opts.get('user') or old.user()
         date = opts.get('date') or old.date()
 
         # Parse the date to allow comparison between date and old.date()
         date = util.parsedate(date)
 
         if len(old.parents()) > 1:
             # ctx.files() isn't reliable for merges, so fall back to the
             # slower repo.status() method
             files = set([fn for st in repo.status(base, old)[:3]
                          for fn in st])
         else:
             files = set(old.files())
 
         # add/remove the files to the working copy if the "addremove" option
         # was specified.
         matcher = scmutil.match(wctx, pats, opts)
         if (opts.get('addremove')
             and scmutil.addremove(repo, matcher, "", opts)):
             raise error.Abort(
                 _("failed to mark all new/missing files as added/removed"))
 
         # Check subrepos. This depends on in-place wctx._status update in
         # subrepo.precommit(). To minimize the risk of this hack, we do
         # nothing if .hgsub does not exist.
         if '.hgsub' in wctx or '.hgsub' in old:
             from . import subrepo  # avoid cycle: cmdutil -> subrepo -> cmdutil
             subs, commitsubs, newsubstate = subrepo.precommit(
                 ui, wctx, wctx._status, matcher)
             # amend should abort if commitsubrepos is enabled
             assert not commitsubs
             if subs:
                 subrepo.writestate(repo, newsubstate)
 
         filestoamend = set(f for f in wctx.files() if matcher(f))
 
         changes = (len(filestoamend) > 0)
         if changes:
             # Recompute copies (avoid recording a -> b -> a)
             copied = copies.pathcopies(base, wctx, matcher)
             if old.p2:
                 copied.update(copies.pathcopies(old.p2(), wctx, matcher))
 
             # Prune files which were reverted by the updates: if old
             # introduced file X and the file was renamed in the working
             # copy, then those two files are the same and
             # we can discard X from our list of files. Likewise if X
             # was removed, it's no longer relevant. If X is missing (aka
             # deleted), old X must be preserved.
             files.update(filestoamend)
             files = [f for f in files if (not samefile(f, wctx, base)
                                           or f in wctx.deleted())]
 
             def filectxfn(repo, ctx_, path):
                 try:
                     # If the file being considered is not amongst the files
                     # to be amended, we should return the file context from the
                     # old changeset. This avoids issues when only some files in
                     # the working copy are being amended but there are also
                     # changes to other files from the old changeset.
                     if path not in filestoamend:
                         return old.filectx(path)
 
                     # Return None for removed files.
                     if path in wctx.removed():
                         return None
 
                     fctx = wctx[path]
                     flags = fctx.flags()
                     mctx = context.memfilectx(repo,
                                               fctx.path(), fctx.data(),
                                               islink='l' in flags,
                                               isexec='x' in flags,
                                               copied=copied.get(path))
                     return mctx
                 except KeyError:
                     return None
         else:
             ui.note(_('copying changeset %s to %s\n') % (old, base))
 
             # Use version of files as in the old cset
             def filectxfn(repo, ctx_, path):
                 try:
                     return old.filectx(path)
                 except KeyError:
                     return None
 
         # See if we got a message from -m or -l, if not, open the editor with
         # the message of the changeset to amend.
         message = logmessage(ui, opts)
 
         editform = mergeeditform(old, 'commit.amend')
         editor = getcommiteditor(editform=editform,
                                  **pycompat.strkwargs(opts))
 
         if not message:
             editor = getcommiteditor(edit=True, editform=editform)
             message = old.description()
 
         pureextra = extra.copy()
         extra['amend_source'] = old.hex()
 
         new = context.memctx(repo,
                              parents=[base.node(), old.p2().node()],
                              text=message,
                              files=files,
                              filectxfn=filectxfn,
                              user=user,
                              date=date,
                              extra=extra,
                              editor=editor)
 
         newdesc = changelog.stripdesc(new.description())
         if ((not changes)
             and newdesc == old.description()
             and user == old.user()
             and date == old.date()
             and pureextra == old.extra()):
             # nothing changed. continuing here would create a new node
             # anyway because of the amend_source noise.
             #
             # This not what we expect from amend.
             return old.node()
 
         if opts.get('secret'):
             commitphase = 'secret'
         else:
             commitphase = old.phase()
         overrides = {('phases', 'new-commit'): commitphase}
         with ui.configoverride(overrides, 'amend'):
             newid = repo.commitctx(new)
 
         # Reroute the working copy parent to the new changeset
         repo.setparents(newid, nullid)
         mapping = {old.node(): (newid,)}
         obsmetadata = None
         if opts.get('note'):
             obsmetadata = {'note': opts['note']}
         scmutil.cleanupnodes(repo, mapping, 'amend', metadata=obsmetadata)
 
         # Fixing the dirstate because localrepo.commitctx does not update
         # it. This is rather convenient because we did not need to update
         # the dirstate for all the files in the new commit which commitctx
         # could have done if it updated the dirstate. Now, we can
         # selectively update the dirstate only for the amended files.
         dirstate = repo.dirstate
 
         # Update the state of the files which were added and
         # and modified in the amend to "normal" in the dirstate.
         normalfiles = set(wctx.modified() + wctx.added()) & filestoamend
         for f in normalfiles:
             dirstate.normal(f)
 
         # Update the state of files which were removed in the amend
         # to "removed" in the dirstate.
         removedfiles = set(wctx.removed()) & filestoamend
         for f in removedfiles:
             dirstate.drop(f)
 
     return newid
 
 def commiteditor(repo, ctx, subs, editform=''):
     if ctx.description():
         return ctx.description()
     return commitforceeditor(repo, ctx, subs, editform=editform,
                              unchangedmessagedetection=True)
 
 def commitforceeditor(repo, ctx, subs, finishdesc=None, extramsg=None,
                       editform='', unchangedmessagedetection=False):
     if not extramsg:
         extramsg = _("Leave message empty to abort commit.")
 
     forms = [e for e in editform.split('.') if e]
     forms.insert(0, 'changeset')
     templatetext = None
     while forms:
         ref = '.'.join(forms)
         if repo.ui.config('committemplate', ref):
             templatetext = committext = buildcommittemplate(
                 repo, ctx, subs, extramsg, ref)
             break
         forms.pop()
     else:
         committext = buildcommittext(repo, ctx, subs, extramsg)
 
     # run editor in the repository root
     olddir = pycompat.getcwd()
     os.chdir(repo.root)
 
     # make in-memory changes visible to external process
     tr = repo.currenttransaction()
     repo.dirstate.write(tr)
     pending = tr and tr.writepending() and repo.root
 
     editortext = repo.ui.edit(committext, ctx.user(), ctx.extra(),
                               editform=editform, pending=pending,
                               repopath=repo.path, action='commit')
     text = editortext
 
     # strip away anything below this special string (used for editors that want
     # to display the diff)
     stripbelow = re.search(_linebelow, text, flags=re.MULTILINE)
     if stripbelow:
         text = text[:stripbelow.start()]
 
     text = re.sub("(?m)^HG:.*(\n|$)", "", text)
     os.chdir(olddir)
 
     if finishdesc:
         text = finishdesc(text)
     if not text.strip():
         raise error.Abort(_("empty commit message"))
     if unchangedmessagedetection and editortext == templatetext:
         raise error.Abort(_("commit message unchanged"))
 
     return text
 
 def buildcommittemplate(repo, ctx, subs, extramsg, ref):
     ui = repo.ui
     spec = formatter.templatespec(ref, None, None)
     t = changeset_templater(ui, repo, spec, None, {}, False)
     t.t.cache.update((k, templater.unquotestring(v))
                      for k, v in repo.ui.configitems('committemplate'))
 
     if not extramsg:
         extramsg = '' # ensure that extramsg is string
 
     ui.pushbuffer()
     t.show(ctx, extramsg=extramsg)
     return ui.popbuffer()
 
 def hgprefix(msg):
     return "\n".join(["HG: %s" % a for a in msg.split("\n") if a])
 
 def buildcommittext(repo, ctx, subs, extramsg):
     edittext = []
     modified, added, removed = ctx.modified(), ctx.added(), ctx.removed()
     if ctx.description():
         edittext.append(ctx.description())
     edittext.append("")
     edittext.append("") # Empty line between message and comments.
     edittext.append(hgprefix(_("Enter commit message."
                       "  Lines beginning with 'HG:' are removed.")))
     edittext.append(hgprefix(extramsg))
     edittext.append("HG: --")
     edittext.append(hgprefix(_("user: %s") % ctx.user()))
     if ctx.p2():
         edittext.append(hgprefix(_("branch merge")))
     if ctx.branch():
         edittext.append(hgprefix(_("branch '%s'") % ctx.branch()))
     if bookmarks.isactivewdirparent(repo):
         edittext.append(hgprefix(_("bookmark '%s'") % repo._activebookmark))
     edittext.extend([hgprefix(_("subrepo %s") % s) for s in subs])
     edittext.extend([hgprefix(_("added %s") % f) for f in added])
     edittext.extend([hgprefix(_("changed %s") % f) for f in modified])
     edittext.extend([hgprefix(_("removed %s") % f) for f in removed])
     if not added and not modified and not removed:
         edittext.append(hgprefix(_("no files changed")))
     edittext.append("")
 
     return "\n".join(edittext)
 
 def commitstatus(repo, node, branch, bheads=None, opts=None):
     if opts is None:
         opts = {}
     ctx = repo[node]
     parents = ctx.parents()
 
     if (not opts.get('amend') and bheads and node not in bheads and not
         [x for x in parents if x.node() in bheads and x.branch() == branch]):
         repo.ui.status(_('created new head\n'))
         # The message is not printed for initial roots. For the other
         # changesets, it is printed in the following situations:
         #
         # Par column: for the 2 parents with ...
         #   N: null or no parent
         #   B: parent is on another named branch
         #   C: parent is a regular non head changeset
         #   H: parent was a branch head of the current branch
         # Msg column: whether we print "created new head" message
         # In the following, it is assumed that there already exists some
         # initial branch heads of the current branch, otherwise nothing is
         # printed anyway.
         #
         # Par Msg Comment
         # N N  y  additional topo root
         #
         # B N  y  additional branch root
         # C N  y  additional topo head
         # H N  n  usual case
         #
         # B B  y  weird additional branch root
         # C B  y  branch merge
         # H B  n  merge with named branch
         #
         # C C  y  additional head from merge
         # C H  n  merge with a head
         #
         # H H  n  head merge: head count decreases
 
     if not opts.get('close_branch'):
         for r in parents:
             if r.closesbranch() and r.branch() == branch:
                 repo.ui.status(_('reopening closed branch head %d\n') % r)
 
     if repo.ui.debugflag:
         repo.ui.write(_('committed changeset %d:%s\n') % (int(ctx), ctx.hex()))
     elif repo.ui.verbose:
         repo.ui.write(_('committed changeset %d:%s\n') % (int(ctx), ctx))
 
 def postcommitstatus(repo, pats, opts):
     return repo.status(match=scmutil.match(repo[None], pats, opts))
 
 def revert(ui, repo, ctx, parents, *pats, **opts):
     opts = pycompat.byteskwargs(opts)
     parent, p2 = parents
     node = ctx.node()
 
     mf = ctx.manifest()
     if node == p2:
         parent = p2
 
     # need all matching names in dirstate and manifest of target rev,
     # so have to walk both. do not print errors if files exist in one
     # but not other. in both cases, filesets should be evaluated against
     # workingctx to get consistent result (issue4497). this means 'set:**'
     # cannot be used to select missing files from target rev.
 
     # `names` is a mapping for all elements in working copy and target revision
     # The mapping is in the form:
     #   <asb path in repo> -> (<path from CWD>, <exactly specified by matcher?>)
     names = {}
 
     with repo.wlock():
         ## filling of the `names` mapping
         # walk dirstate to fill `names`
 
         interactive = opts.get('interactive', False)
         wctx = repo[None]
         m = scmutil.match(wctx, pats, opts)
 
         # we'll need this later
         targetsubs = sorted(s for s in wctx.substate if m(s))
 
         if not m.always():
             matcher = matchmod.badmatch(m, lambda x, y: False)
             for abs in wctx.walk(matcher):
                 names[abs] = m.rel(abs), m.exact(abs)
 
             # walk target manifest to fill `names`
 
             def badfn(path, msg):
                 if path in names:
                     return
                 if path in ctx.substate:
                     return
                 path_ = path + '/'
                 for f in names:
                     if f.startswith(path_):
                         return
                 ui.warn("%s: %s\n" % (m.rel(path), msg))
 
             for abs in ctx.walk(matchmod.badmatch(m, badfn)):
                 if abs not in names:
                     names[abs] = m.rel(abs), m.exact(abs)
 
             # Find status of all file in `names`.
             m = scmutil.matchfiles(repo, names)
 
             changes = repo.status(node1=node, match=m,
                                   unknown=True, ignored=True, clean=True)
         else:
             changes = repo.status(node1=node, match=m)
             for kind in changes:
                 for abs in kind:
                     names[abs] = m.rel(abs), m.exact(abs)
 
             m = scmutil.matchfiles(repo, names)
 
         modified = set(changes.modified)
         added    = set(changes.added)
         removed  = set(changes.removed)
         _deleted = set(changes.deleted)
         unknown  = set(changes.unknown)
         unknown.update(changes.ignored)
         clean    = set(changes.clean)
         modadded = set()
 
         # We need to account for the state of the file in the dirstate,
         # even when we revert against something else than parent. This will
         # slightly alter the behavior of revert (doing back up or not, delete
         # or just forget etc).
         if parent == node:
             dsmodified = modified
             dsadded = added
             dsremoved = removed
             # store all local modifications, useful later for rename detection
             localchanges = dsmodified | dsadded
             modified, added, removed = set(), set(), set()
         else:
             changes = repo.status(node1=parent, match=m)
             dsmodified = set(changes.modified)
             dsadded    = set(changes.added)
             dsremoved  = set(changes.removed)
             # store all local modifications, useful later for rename detection
             localchanges = dsmodified | dsadded
 
             # only take into account for removes between wc and target
             clean |= dsremoved - removed
             dsremoved &= removed
             # distinct between dirstate remove and other
             removed -= dsremoved
 
             modadded = added & dsmodified
             added -= modadded
 
             # tell newly modified apart.
             dsmodified &= modified
             dsmodified |= modified & dsadded # dirstate added may need backup
             modified -= dsmodified
 
             # We need to wait for some post-processing to update this set
             # before making the distinction. The dirstate will be used for
             # that purpose.
             dsadded = added
 
         # in case of merge, files that are actually added can be reported as
         # modified, we need to post process the result
         if p2 != nullid:
             mergeadd = set(dsmodified)
             for path in dsmodified:
                 if path in mf:
                     mergeadd.remove(path)
             dsadded |= mergeadd
             dsmodified -= mergeadd
 
         # if f is a rename, update `names` to also revert the source
         cwd = repo.getcwd()
         for f in localchanges:
             src = repo.dirstate.copied(f)
             # XXX should we check for rename down to target node?
             if src and src not in names and repo.dirstate[src] == 'r':
                 dsremoved.add(src)
                 names[src] = (repo.pathto(src, cwd), True)
 
         # determine the exact nature of the deleted changesets
         deladded = set(_deleted)
         for path in _deleted:
             if path in mf:
                 deladded.remove(path)
         deleted = _deleted - deladded
 
         # distinguish between file to forget and the other
         added = set()
         for abs in dsadded:
             if repo.dirstate[abs] != 'a':
                 added.add(abs)
         dsadded -= added
 
         for abs in deladded:
             if repo.dirstate[abs] == 'a':
                 dsadded.add(abs)
         deladded -= dsadded
 
         # For files marked as removed, we check if an unknown file is present at
         # the same path. If a such file exists it may need to be backed up.
         # Making the distinction at this stage helps have simpler backup
         # logic.
         removunk = set()
         for abs in removed:
             target = repo.wjoin(abs)
             if os.path.lexists(target):
                 removunk.add(abs)
         removed -= removunk
 
         dsremovunk = set()
         for abs in dsremoved:
             target = repo.wjoin(abs)
             if os.path.lexists(target):
                 dsremovunk.add(abs)
         dsremoved -= dsremovunk
 
         # action to be actually performed by revert
         # (<list of file>, message>) tuple
         actions = {'revert': ([], _('reverting %s\n')),
                    'add': ([], _('adding %s\n')),
                    'remove': ([], _('removing %s\n')),
                    'drop': ([], _('removing %s\n')),
                    'forget': ([], _('forgetting %s\n')),
                    'undelete': ([], _('undeleting %s\n')),
                    'noop': (None, _('no changes needed to %s\n')),
                    'unknown': (None, _('file not managed: %s\n')),
                   }
 
         # "constant" that convey the backup strategy.
         # All set to `discard` if `no-backup` is set do avoid checking
         # no_backup lower in the code.
         # These values are ordered for comparison purposes
         backupinteractive = 3 # do backup if interactively modified
         backup = 2  # unconditionally do backup
         check = 1   # check if the existing file differs from target
         discard = 0 # never do backup
         if opts.get('no_backup'):
             backupinteractive = backup = check = discard
         if interactive:
             dsmodifiedbackup = backupinteractive
         else:
             dsmodifiedbackup = backup
         tobackup = set()
 
         backupanddel = actions['remove']
         if not opts.get('no_backup'):
             backupanddel = actions['drop']
 
         disptable = (
             # dispatch table:
             #   file state
             #   action
             #   make backup
 
             ## Sets that results that will change file on disk
             # Modified compared to target, no local change
             (modified,      actions['revert'],   discard),
             # Modified compared to target, but local file is deleted
             (deleted,       actions['revert'],   discard),
             # Modified compared to target, local change
             (dsmodified,    actions['revert'],   dsmodifiedbackup),
             # Added since target
             (added,         actions['remove'],   discard),
             # Added in working directory
             (dsadded,       actions['forget'],   discard),
             # Added since target, have local modification
             (modadded,      backupanddel,        backup),
             # Added since target but file is missing in working directory
             (deladded,      actions['drop'],   discard),
             # Removed since  target, before working copy parent
             (removed,       actions['add'],      discard),
             # Same as `removed` but an unknown file exists at the same path
             (removunk,      actions['add'],      check),
             # Removed since targe, marked as such in working copy parent
             (dsremoved,     actions['undelete'], discard),
             # Same as `dsremoved` but an unknown file exists at the same path
             (dsremovunk,    actions['undelete'], check),
             ## the following sets does not result in any file changes
             # File with no modification
             (clean,         actions['noop'],     discard),
             # Existing file, not tracked anywhere
             (unknown,       actions['unknown'],  discard),
             )
 
         for abs, (rel, exact) in sorted(names.items()):
             # target file to be touch on disk (relative to cwd)
             target = repo.wjoin(abs)
             # search the entry in the dispatch table.
             # if the file is in any of these sets, it was touched in the working
             # directory parent and we are sure it needs to be reverted.
             for table, (xlist, msg), dobackup in disptable:
                 if abs not in table:
                     continue
                 if xlist is not None:
                     xlist.append(abs)
                     if dobackup:
                         # If in interactive mode, don't automatically create
                         # .orig files (issue4793)
                         if dobackup == backupinteractive:
                             tobackup.add(abs)
                         elif (backup <= dobackup or wctx[abs].cmp(ctx[abs])):
                             bakname = scmutil.origpath(ui, repo, rel)
                             ui.note(_('saving current version of %s as %s\n') %
                                     (rel, bakname))
                             if not opts.get('dry_run'):
                                 if interactive:
                                     util.copyfile(target, bakname)
                                 else:
                                     util.rename(target, bakname)
                     if ui.verbose or not exact:
                         if not isinstance(msg, bytes):
                             msg = msg(abs)
                         ui.status(msg % rel)
                 elif exact:
                     ui.warn(msg % rel)
                 break
 
         if not opts.get('dry_run'):
             needdata = ('revert', 'add', 'undelete')
             _revertprefetch(repo, ctx, *[actions[name][0] for name in needdata])
             _performrevert(repo, parents, ctx, actions, interactive, tobackup)
 
         if targetsubs:
             # Revert the subrepos on the revert list
             for sub in targetsubs:
                 try:
                     wctx.sub(sub).revert(ctx.substate[sub], *pats,
                                          **pycompat.strkwargs(opts))
                 except KeyError:
                     raise error.Abort("subrepository '%s' does not exist in %s!"
                                       % (sub, short(ctx.node())))
 
 def _revertprefetch(repo, ctx, *files):
     """Let extension changing the storage layer prefetch content"""
 
 def _performrevert(repo, parents, ctx, actions, interactive=False,
                    tobackup=None):
     """function that actually perform all the actions computed for revert
 
     This is an independent function to let extension to plug in and react to
     the imminent revert.
 
     Make sure you have the working directory locked when calling this function.
     """
     parent, p2 = parents
     node = ctx.node()
     excluded_files = []
     matcher_opts = {"exclude": excluded_files}
 
     def checkout(f):
         fc = ctx[f]
         repo.wwrite(f, fc.data(), fc.flags())
 
     def doremove(f):
         try:
             repo.wvfs.unlinkpath(f)
         except OSError:
             pass
         repo.dirstate.remove(f)
 
     audit_path = pathutil.pathauditor(repo.root, cached=True)
     for f in actions['forget'][0]:
         if interactive:
             choice = repo.ui.promptchoice(
                 _("forget added file %s (Yn)?$$ &Yes $$ &No") % f)
             if choice == 0:
                 repo.dirstate.drop(f)
             else:
                 excluded_files.append(repo.wjoin(f))
         else:
             repo.dirstate.drop(f)
     for f in actions['remove'][0]:
         audit_path(f)
         if interactive:
             choice = repo.ui.promptchoice(
                 _("remove added file %s (Yn)?$$ &Yes $$ &No") % f)
             if choice == 0:
                 doremove(f)
             else:
                 excluded_files.append(repo.wjoin(f))
         else:
             doremove(f)
     for f in actions['drop'][0]:
         audit_path(f)
         repo.dirstate.remove(f)
 
     normal = None
     if node == parent:
         # We're reverting to our parent. If possible, we'd like status
         # to report the file as clean. We have to use normallookup for
         # merges to avoid losing information about merged/dirty files.
         if p2 != nullid:
             normal = repo.dirstate.normallookup
         else:
             normal = repo.dirstate.normal
 
     newlyaddedandmodifiedfiles = set()
     if interactive:
         # Prompt the user for changes to revert
         torevert = [repo.wjoin(f) for f in actions['revert'][0]]
         m = scmutil.match(ctx, torevert, matcher_opts)
         diffopts = patch.difffeatureopts(repo.ui, whitespace=True)
         diffopts.nodates = True
         diffopts.git = True
         operation = 'discard'
         reversehunks = True
         if node != parent:
             operation = 'apply'
             reversehunks = False
         if reversehunks:
             diff = patch.diff(repo, ctx.node(), None, m, opts=diffopts)
         else:
             diff = patch.diff(repo, None, ctx.node(), m, opts=diffopts)
         originalchunks = patch.parsepatch(diff)
 
         try:
 
             chunks, opts = recordfilter(repo.ui, originalchunks,
                                         operation=operation)
             if reversehunks:
                 chunks = patch.reversehunks(chunks)
 
         except error.PatchError as err:
             raise error.Abort(_('error parsing patch: %s') % err)
 
         newlyaddedandmodifiedfiles = newandmodified(chunks, originalchunks)
         if tobackup is None:
             tobackup = set()
         # Apply changes
         fp = stringio()
         for c in chunks:
             # Create a backup file only if this hunk should be backed up
             if ishunk(c) and c.header.filename() in tobackup:
                 abs = c.header.filename()
                 target = repo.wjoin(abs)
                 bakname = scmutil.origpath(repo.ui, repo, m.rel(abs))
                 util.copyfile(target, bakname)
                 tobackup.remove(abs)
             c.write(fp)
         dopatch = fp.tell()
         fp.seek(0)
         if dopatch:
             try:
                 patch.internalpatch(repo.ui, repo, fp, 1, eolmode=None)
             except error.PatchError as err:
                 raise error.Abort(str(err))
         del fp
     else:
         for f in actions['revert'][0]:
             checkout(f)
             if normal:
                 normal(f)
 
     for f in actions['add'][0]:
         # Don't checkout modified files, they are already created by the diff
         if f not in newlyaddedandmodifiedfiles:
             checkout(f)
             repo.dirstate.add(f)
 
     normal = repo.dirstate.normallookup
     if node == parent and p2 == nullid:
         normal = repo.dirstate.normal
     for f in actions['undelete'][0]:
         checkout(f)
         normal(f)
 
     copied = copies.pathcopies(repo[parent], ctx)
 
     for f in actions['add'][0] + actions['undelete'][0] + actions['revert'][0]:
         if f in copied:
             repo.dirstate.copy(copied[f], f)
 
 class command(registrar.command):
     """deprecated: used registrar.command instead"""
     def _doregister(self, func, name, *args, **kwargs):
         func._deprecatedregistrar = True  # flag for deprecwarn in extensions.py
         return super(command, self)._doregister(func, name, *args, **kwargs)
 
 # a list of (ui, repo, otherpeer, opts, missing) functions called by
 # commands.outgoing.  "missing" is "missing" of the result of
 # "findcommonoutgoing()"
 outgoinghooks = util.hooks()
 
 # a list of (ui, repo) functions called by commands.summary
 summaryhooks = util.hooks()
 
 # a list of (ui, repo, opts, changes) functions called by commands.summary.
 #
 # functions should return tuple of booleans below, if 'changes' is None:
 #  (whether-incomings-are-needed, whether-outgoings-are-needed)
 #
 # otherwise, 'changes' is a tuple of tuples below:
 #  - (sourceurl, sourcebranch, sourcepeer, incoming)
 #  - (desturl,   destbranch,   destpeer,   outgoing)
 summaryremotehooks = util.hooks()
 
 # A list of state files kept by multistep operations like graft.
 # Since graft cannot be aborted, it is considered 'clearable' by update.
 # note: bisect is intentionally excluded
 # (state file, clearable, allowcommit, error, hint)
 unfinishedstates = [
     ('graftstate', True, False, _('graft in progress'),
      _("use 'hg graft --continue' or 'hg update' to abort")),
     ('updatestate', True, False, _('last update was interrupted'),
      _("use 'hg update' to get a consistent checkout"))
     ]
 
 def checkunfinished(repo, commit=False):
     '''Look for an unfinished multistep operation, like graft, and abort
     if found. It's probably good to check this right before
     bailifchanged().
     '''
     for f, clearable, allowcommit, msg, hint in unfinishedstates:
         if commit and allowcommit:
             continue
         if repo.vfs.exists(f):
             raise error.Abort(msg, hint=hint)
 
 def clearunfinished(repo):
     '''Check for unfinished operations (as above), and clear the ones
     that are clearable.
     '''
     for f, clearable, allowcommit, msg, hint in unfinishedstates:
         if not clearable and repo.vfs.exists(f):
             raise error.Abort(msg, hint=hint)
     for f, clearable, allowcommit, msg, hint in unfinishedstates:
         if clearable and repo.vfs.exists(f):
             util.unlink(repo.vfs.join(f))
 
 afterresolvedstates = [
     ('graftstate',
      _('hg graft --continue')),
     ]
 
 def howtocontinue(repo):
     '''Check for an unfinished operation and return the command to finish
     it.
 
     afterresolvedstates tuples define a .hg/{file} and the corresponding
     command needed to finish it.
 
     Returns a (msg, warning) tuple. 'msg' is a string and 'warning' is
     a boolean.
     '''
     contmsg = _("continue: %s")
     for f, msg in afterresolvedstates:
         if repo.vfs.exists(f):
             return contmsg % msg, True
     if repo[None].dirty(missing=True, merge=False, branch=False):
         return contmsg % _("hg commit"), False
     return None, None
 
 def checkafterresolved(repo):
     '''Inform the user about the next action after completing hg resolve
 
     If there's a matching afterresolvedstates, howtocontinue will yield
     repo.ui.warn as the reporter.
 
     Otherwise, it will yield repo.ui.note.
     '''
     msg, warning = howtocontinue(repo)
     if msg is not None:
         if warning:
             repo.ui.warn("%s\n" % msg)
         else:
             repo.ui.note("%s\n" % msg)
 
 def wrongtooltocontinue(repo, task):
     '''Raise an abort suggesting how to properly continue if there is an
     active task.
 
     Uses howtocontinue() to find the active task.
 
     If there's no task (repo.ui.note for 'hg commit'), it does not offer
     a hint.
     '''
     after = howtocontinue(repo)
     hint = None
     if after[1]:
         hint = after[0]
     raise error.Abort(_('no %s in progress') % task, hint=hint)

mercurial/color.py

@@ -1,518 +1,520 b''
 # utility for color output for Mercurial commands
 #
 # Copyright (C) 2007 Kevin Christen <[e-mail]> and other
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 from __future__ import absolute_import
 
 import re
 
 from .i18n import _
 
 from . import (
     encoding,
     pycompat,
     util
 )
 
 try:
     import curses
     # Mapping from effect name to terminfo attribute name (or raw code) or
     # color number.  This will also force-load the curses module.
     _baseterminfoparams = {
         'none': (True, 'sgr0', ''),
         'standout': (True, 'smso', ''),
         'underline': (True, 'smul', ''),
         'reverse': (True, 'rev', ''),
         'inverse': (True, 'rev', ''),
         'blink': (True, 'blink', ''),
         'dim': (True, 'dim', ''),
         'bold': (True, 'bold', ''),
         'invisible': (True, 'invis', ''),
         'italic': (True, 'sitm', ''),
         'black': (False, curses.COLOR_BLACK, ''),
         'red': (False, curses.COLOR_RED, ''),
         'green': (False, curses.COLOR_GREEN, ''),
         'yellow': (False, curses.COLOR_YELLOW, ''),
         'blue': (False, curses.COLOR_BLUE, ''),
         'magenta': (False, curses.COLOR_MAGENTA, ''),
         'cyan': (False, curses.COLOR_CYAN, ''),
         'white': (False, curses.COLOR_WHITE, ''),
     }
 except ImportError:
     curses = None
     _baseterminfoparams = {}
 
 # start and stop parameters for effects
 _effects = {
     'none': 0,
     'black': 30,
     'red': 31,
     'green': 32,
     'yellow': 33,
     'blue': 34,
     'magenta': 35,
     'cyan': 36,
     'white': 37,
     'bold': 1,
     'italic': 3,
     'underline': 4,
     'inverse': 7,
     'dim': 2,
     'black_background': 40,
     'red_background': 41,
     'green_background': 42,
     'yellow_background': 43,
     'blue_background': 44,
     'purple_background': 45,
     'cyan_background': 46,
     'white_background': 47,
     }
 
 _defaultstyles = {
     'grep.match': 'red bold',
     'grep.linenumber': 'green',
     'grep.rev': 'green',
     'grep.change': 'green',
     'grep.sep': 'cyan',
     'grep.filename': 'magenta',
     'grep.user': 'magenta',
     'grep.date': 'magenta',
     'bookmarks.active': 'green',
     'branches.active': 'none',
     'branches.closed': 'black bold',
     'branches.current': 'green',
     'branches.inactive': 'none',
     'diff.changed': 'white',
     'diff.deleted': 'red',
+    'diff.deleted.highlight': 'red bold underline',
     'diff.diffline': 'bold',
     'diff.extended': 'cyan bold',
     'diff.file_a': 'red bold',
     'diff.file_b': 'green bold',
     'diff.hunk': 'magenta',
     'diff.inserted': 'green',
+    'diff.inserted.highlight': 'green bold underline',
     'diff.tab': '',
     'diff.trailingwhitespace': 'bold red_background',
     'changeset.public': '',
     'changeset.draft': '',
     'changeset.secret': '',
     'diffstat.deleted': 'red',
     'diffstat.inserted': 'green',
     'histedit.remaining': 'red bold',
     'ui.prompt': 'yellow',
     'log.changeset': 'yellow',
     'patchbomb.finalsummary': '',
     'patchbomb.from': 'magenta',
     'patchbomb.to': 'cyan',
     'patchbomb.subject': 'green',
     'patchbomb.diffstats': '',
     'rebase.rebased': 'blue',
     'rebase.remaining': 'red bold',
     'resolve.resolved': 'green bold',
     'resolve.unresolved': 'red bold',
     'shelve.age': 'cyan',
     'shelve.newest': 'green bold',
     'shelve.name': 'blue bold',
     'status.added': 'green bold',
     'status.clean': 'none',
     'status.copied': 'none',
     'status.deleted': 'cyan bold underline',
     'status.ignored': 'black bold',
     'status.modified': 'blue bold',
     'status.removed': 'red bold',
     'status.unknown': 'magenta bold underline',
     'tags.normal': 'green',
     'tags.local': 'black bold',
 }
 
 def loadcolortable(ui, extname, colortable):
     _defaultstyles.update(colortable)
 
 def _terminfosetup(ui, mode, formatted):
     '''Initialize terminfo data and the terminal if we're in terminfo mode.'''
 
     # If we failed to load curses, we go ahead and return.
     if curses is None:
         return
     # Otherwise, see what the config file says.
     if mode not in ('auto', 'terminfo'):
         return
     ui._terminfoparams.update(_baseterminfoparams)
 
     for key, val in ui.configitems('color'):
         if key.startswith('color.'):
             newval = (False, int(val), '')
             ui._terminfoparams[key[6:]] = newval
         elif key.startswith('terminfo.'):
             newval = (True, '', val.replace('\\E', '\x1b'))
             ui._terminfoparams[key[9:]] = newval
     try:
         curses.setupterm()
     except curses.error as e:
         ui._terminfoparams.clear()
         return
 
     for key, (b, e, c) in ui._terminfoparams.items():
         if not b:
             continue
         if not c and not curses.tigetstr(e):
             # Most terminals don't support dim, invis, etc, so don't be
             # noisy and use ui.debug().
             ui.debug("no terminfo entry for %s\n" % e)
             del ui._terminfoparams[key]
     if not curses.tigetstr('setaf') or not curses.tigetstr('setab'):
         # Only warn about missing terminfo entries if we explicitly asked for
         # terminfo mode and we're in a formatted terminal.
         if mode == "terminfo" and formatted:
             ui.warn(_("no terminfo entry for setab/setaf: reverting to "
               "ECMA-48 color\n"))
         ui._terminfoparams.clear()
 
 def setup(ui):
     """configure color on a ui
 
     That function both set the colormode for the ui object and read
     the configuration looking for custom colors and effect definitions."""
     mode = _modesetup(ui)
     ui._colormode = mode
     if mode and mode != 'debug':
         configstyles(ui)
 
 def _modesetup(ui):
     if ui.plain('color'):
         return None
     config = ui.config('ui', 'color')
     if config == 'debug':
         return 'debug'
 
     auto = (config == 'auto')
     always = False
     if not auto and util.parsebool(config):
         # We want the config to behave like a boolean, "on" is actually auto,
         # but "always" value is treated as a special case to reduce confusion.
         if ui.configsource('ui', 'color') == '--color' or config == 'always':
             always = True
         else:
             auto = True
 
     if not always and not auto:
         return None
 
     formatted = (always or (encoding.environ.get('TERM') != 'dumb'
                  and ui.formatted()))
 
     mode = ui.config('color', 'mode')
 
     # If pager is active, color.pagermode overrides color.mode.
     if getattr(ui, 'pageractive', False):
         mode = ui.config('color', 'pagermode', mode)
 
     realmode = mode
     if pycompat.iswindows:
         from . import win32
 
         term = encoding.environ.get('TERM')
         # TERM won't be defined in a vanilla cmd.exe environment.
 
         # UNIX-like environments on Windows such as Cygwin and MSYS will
         # set TERM. They appear to make a best effort attempt at setting it
         # to something appropriate. However, not all environments with TERM
         # defined support ANSI.
         ansienviron = term and 'xterm' in term
 
         if mode == 'auto':
             # Since "ansi" could result in terminal gibberish, we error on the
             # side of selecting "win32". However, if w32effects is not defined,
             # we almost certainly don't support "win32", so don't even try.
             # w32ffects is not populated when stdout is redirected, so checking
             # it first avoids win32 calls in a state known to error out.
             if ansienviron or not w32effects or win32.enablevtmode():
                 realmode = 'ansi'
             else:
                 realmode = 'win32'
         # An empty w32effects is a clue that stdout is redirected, and thus
         # cannot enable VT mode.
         elif mode == 'ansi' and w32effects and not ansienviron:
             win32.enablevtmode()
     elif mode == 'auto':
         realmode = 'ansi'
 
     def modewarn():
         # only warn if color.mode was explicitly set and we're in
         # a formatted terminal
         if mode == realmode and formatted:
             ui.warn(_('warning: failed to set color mode to %s\n') % mode)
 
     if realmode == 'win32':
         ui._terminfoparams.clear()
         if not w32effects:
             modewarn()
             return None
     elif realmode == 'ansi':
         ui._terminfoparams.clear()
     elif realmode == 'terminfo':
         _terminfosetup(ui, mode, formatted)
         if not ui._terminfoparams:
             ## FIXME Shouldn't we return None in this case too?
             modewarn()
             realmode = 'ansi'
     else:
         return None
 
     if always or (auto and formatted):
         return realmode
     return None
 
 def configstyles(ui):
     ui._styles.update(_defaultstyles)
     for status, cfgeffects in ui.configitems('color'):
         if '.' not in status or status.startswith(('color.', 'terminfo.')):
             continue
         cfgeffects = ui.configlist('color', status)
         if cfgeffects:
             good = []
             for e in cfgeffects:
                 if valideffect(ui, e):
                     good.append(e)
                 else:
                     ui.warn(_("ignoring unknown color/effect %r "
                               "(configured in color.%s)\n")
                             % (e, status))
             ui._styles[status] = ' '.join(good)
 
 def _activeeffects(ui):
     '''Return the effects map for the color mode set on the ui.'''
     if ui._colormode == 'win32':
         return w32effects
     elif ui._colormode is not None:
         return _effects
     return {}
 
 def valideffect(ui, effect):
     'Determine if the effect is valid or not.'
     return ((not ui._terminfoparams and effect in _activeeffects(ui))
              or (effect in ui._terminfoparams
                  or effect[:-11] in ui._terminfoparams))
 
 def _effect_str(ui, effect):
     '''Helper function for render_effects().'''
 
     bg = False
     if effect.endswith('_background'):
         bg = True
         effect = effect[:-11]
     try:
         attr, val, termcode = ui._terminfoparams[effect]
     except KeyError:
         return ''
     if attr:
         if termcode:
             return termcode
         else:
             return curses.tigetstr(val)
     elif bg:
         return curses.tparm(curses.tigetstr('setab'), val)
     else:
         return curses.tparm(curses.tigetstr('setaf'), val)
 
 def _mergeeffects(text, start, stop):
     """Insert start sequence at every occurrence of stop sequence
 
     >>> s = _mergeeffects(b'cyan', b'[C]', b'|')
     >>> s = _mergeeffects(s + b'yellow', b'[Y]', b'|')
     >>> s = _mergeeffects(b'ma' + s + b'genta', b'[M]', b'|')
     >>> s = _mergeeffects(b'red' + s, b'[R]', b'|')
     >>> s
     '[R]red[M]ma[Y][C]cyan|[R][M][Y]yellow|[R][M]genta|'
     """
     parts = []
     for t in text.split(stop):
         if not t:
             continue
         parts.extend([start, t, stop])
     return ''.join(parts)
 
 def _render_effects(ui, text, effects):
     'Wrap text in commands to turn on each effect.'
     if not text:
         return text
     if ui._terminfoparams:
         start = ''.join(_effect_str(ui, effect)
                         for effect in ['none'] + effects.split())
         stop = _effect_str(ui, 'none')
     else:
         activeeffects = _activeeffects(ui)
         start = [pycompat.bytestr(activeeffects[e])
                  for e in ['none'] + effects.split()]
         start = '\033[' + ';'.join(start) + 'm'
         stop = '\033[' + pycompat.bytestr(activeeffects['none']) + 'm'
     return _mergeeffects(text, start, stop)
 
 _ansieffectre = re.compile(br'\x1b\[[0-9;]*m')
 
 def stripeffects(text):
     """Strip ANSI control codes which could be inserted by colorlabel()"""
     return _ansieffectre.sub('', text)
 
 def colorlabel(ui, msg, label):
     """add color control code according to the mode"""
     if ui._colormode == 'debug':
         if label and msg:
             if msg[-1] == '\n':
                 msg = "[%s|%s]\n" % (label, msg[:-1])
             else:
                 msg = "[%s|%s]" % (label, msg)
     elif ui._colormode is not None:
         effects = []
         for l in label.split():
             s = ui._styles.get(l, '')
             if s:
                 effects.append(s)
             elif valideffect(ui, l):
                 effects.append(l)
         effects = ' '.join(effects)
         if effects:
             msg = '\n'.join([_render_effects(ui, line, effects)
                              for line in msg.split('\n')])
     return msg
 
 w32effects = None
 if pycompat.iswindows:
     import ctypes
 
     _kernel32 = ctypes.windll.kernel32
 
     _WORD = ctypes.c_ushort
 
     _INVALID_HANDLE_VALUE = -1
 
     class _COORD(ctypes.Structure):
         _fields_ = [('X', ctypes.c_short),
                     ('Y', ctypes.c_short)]
 
     class _SMALL_RECT(ctypes.Structure):
         _fields_ = [('Left', ctypes.c_short),
                     ('Top', ctypes.c_short),
                     ('Right', ctypes.c_short),
                     ('Bottom', ctypes.c_short)]
 
     class _CONSOLE_SCREEN_BUFFER_INFO(ctypes.Structure):
         _fields_ = [('dwSize', _COORD),
                     ('dwCursorPosition', _COORD),
                     ('wAttributes', _WORD),
                     ('srWindow', _SMALL_RECT),
                     ('dwMaximumWindowSize', _COORD)]
 
     _STD_OUTPUT_HANDLE = 0xfffffff5 # (DWORD)-11
     _STD_ERROR_HANDLE = 0xfffffff4  # (DWORD)-12
 
     _FOREGROUND_BLUE = 0x0001
     _FOREGROUND_GREEN = 0x0002
     _FOREGROUND_RED = 0x0004
     _FOREGROUND_INTENSITY = 0x0008
 
     _BACKGROUND_BLUE = 0x0010
     _BACKGROUND_GREEN = 0x0020
     _BACKGROUND_RED = 0x0040
     _BACKGROUND_INTENSITY = 0x0080
 
     _COMMON_LVB_REVERSE_VIDEO = 0x4000
     _COMMON_LVB_UNDERSCORE = 0x8000
 
     # http://msdn.microsoft.com/en-us/library/ms682088%28VS.85%29.aspx
     w32effects = {
         'none': -1,
         'black': 0,
         'red': _FOREGROUND_RED,
         'green': _FOREGROUND_GREEN,
         'yellow': _FOREGROUND_RED | _FOREGROUND_GREEN,
         'blue': _FOREGROUND_BLUE,
         'magenta': _FOREGROUND_BLUE | _FOREGROUND_RED,
         'cyan': _FOREGROUND_BLUE | _FOREGROUND_GREEN,
         'white': _FOREGROUND_RED | _FOREGROUND_GREEN | _FOREGROUND_BLUE,
         'bold': _FOREGROUND_INTENSITY,
         'black_background': 0x100,                  # unused value > 0x0f
         'red_background': _BACKGROUND_RED,
         'green_background': _BACKGROUND_GREEN,
         'yellow_background': _BACKGROUND_RED | _BACKGROUND_GREEN,
         'blue_background': _BACKGROUND_BLUE,
         'purple_background': _BACKGROUND_BLUE | _BACKGROUND_RED,
         'cyan_background': _BACKGROUND_BLUE | _BACKGROUND_GREEN,
         'white_background': (_BACKGROUND_RED | _BACKGROUND_GREEN |
                              _BACKGROUND_BLUE),
         'bold_background': _BACKGROUND_INTENSITY,
         'underline': _COMMON_LVB_UNDERSCORE,  # double-byte charsets only
         'inverse': _COMMON_LVB_REVERSE_VIDEO, # double-byte charsets only
     }
 
     passthrough = {_FOREGROUND_INTENSITY,
                    _BACKGROUND_INTENSITY,
                    _COMMON_LVB_UNDERSCORE,
                    _COMMON_LVB_REVERSE_VIDEO}
 
     stdout = _kernel32.GetStdHandle(
                   _STD_OUTPUT_HANDLE)  # don't close the handle returned
     if stdout is None or stdout == _INVALID_HANDLE_VALUE:
         w32effects = None
     else:
         csbi = _CONSOLE_SCREEN_BUFFER_INFO()
         if not _kernel32.GetConsoleScreenBufferInfo(
                     stdout, ctypes.byref(csbi)):
             # stdout may not support GetConsoleScreenBufferInfo()
             # when called from subprocess or redirected
             w32effects = None
         else:
             origattr = csbi.wAttributes
             ansire = re.compile('\033\[([^m]*)m([^\033]*)(.*)',
                                 re.MULTILINE | re.DOTALL)
 
     def win32print(ui, writefunc, *msgs, **opts):
         for text in msgs:
             _win32print(ui, text, writefunc, **opts)
 
     def _win32print(ui, text, writefunc, **opts):
         label = opts.get('label', '')
         attr = origattr
 
         def mapcolor(val, attr):
             if val == -1:
                 return origattr
             elif val in passthrough:
                 return attr | val
             elif val > 0x0f:
                 return (val & 0x70) | (attr & 0x8f)
             else:
                 return (val & 0x07) | (attr & 0xf8)
 
         # determine console attributes based on labels
         for l in label.split():
             style = ui._styles.get(l, '')
             for effect in style.split():
                 try:
                     attr = mapcolor(w32effects[effect], attr)
                 except KeyError:
                     # w32effects could not have certain attributes so we skip
                     # them if not found
                     pass
         # hack to ensure regexp finds data
         if not text.startswith('\033['):
             text = '\033[m' + text
 
         # Look for ANSI-like codes embedded in text
         m = re.match(ansire, text)
 
         try:
             while m:
                 for sattr in m.group(1).split(';'):
                     if sattr:
                         attr = mapcolor(int(sattr), attr)
                 ui.flush()
                 _kernel32.SetConsoleTextAttribute(stdout, attr)
                 writefunc(m.group(2), **opts)
                 m = re.match(ansire, m.group(3))
         finally:
             # Explicitly reset original attributes
             ui.flush()
             _kernel32.SetConsoleTextAttribute(stdout, origattr)

mercurial/configitems.py

@@ -1,1271 +1,1274 b''
 # configitems.py - centralized declaration of configuration option
 #
 #  Copyright 2017 Pierre-Yves David <[e-mail]>
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 from __future__ import absolute_import
 
 import functools
 import re
 
 from . import (
     encoding,
     error,
 )
 
 def loadconfigtable(ui, extname, configtable):
     """update config item known to the ui with the extension ones"""
     for section, items in configtable.items():
         knownitems = ui._knownconfig.setdefault(section, itemregister())
         knownkeys = set(knownitems)
         newkeys = set(items)
         for key in sorted(knownkeys & newkeys):
             msg = "extension '%s' overwrite config item '%s.%s'"
             msg %= (extname, section, key)
             ui.develwarn(msg, config='warn-config')
 
         knownitems.update(items)
 
 class configitem(object):
     """represent a known config item
 
     :section: the official config section where to find this item,
        :name: the official name within the section,
     :default: default value for this item,
     :alias: optional list of tuples as alternatives,
     :generic: this is a generic definition, match name using regular expression.
     """
 
     def __init__(self, section, name, default=None, alias=(),
                  generic=False, priority=0):
         self.section = section
         self.name = name
         self.default = default
         self.alias = list(alias)
         self.generic = generic
         self.priority = priority
         self._re = None
         if generic:
             self._re = re.compile(self.name)
 
 class itemregister(dict):
     """A specialized dictionary that can handle wild-card selection"""
 
     def __init__(self):
         super(itemregister, self).__init__()
         self._generics = set()
 
     def update(self, other):
         super(itemregister, self).update(other)
         self._generics.update(other._generics)
 
     def __setitem__(self, key, item):
         super(itemregister, self).__setitem__(key, item)
         if item.generic:
             self._generics.add(item)
 
     def get(self, key):
         baseitem = super(itemregister, self).get(key)
         if baseitem is not None and not baseitem.generic:
             return baseitem
 
         # search for a matching generic item
         generics = sorted(self._generics, key=(lambda x: (x.priority, x.name)))
         for item in generics:
             # we use 'match' instead of 'search' to make the matching simpler
             # for people unfamiliar with regular expression. Having the match
             # rooted to the start of the string will produce less surprising
             # result for user writing simple regex for sub-attribute.
             #
             # For example using "color\..*" match produces an unsurprising
             # result, while using search could suddenly match apparently
             # unrelated configuration that happens to contains "color."
             # anywhere. This is a tradeoff where we favor requiring ".*" on
             # some match to avoid the need to prefix most pattern with "^".
             # The "^" seems more error prone.
             if item._re.match(key):
                 return item
 
         return None
 
 coreitems = {}
 
 def _register(configtable, *args, **kwargs):
     item = configitem(*args, **kwargs)
     section = configtable.setdefault(item.section, itemregister())
     if item.name in section:
         msg = "duplicated config item registration for '%s.%s'"
         raise error.ProgrammingError(msg % (item.section, item.name))
     section[item.name] = item
 
 # special value for case where the default is derived from other values
 dynamicdefault = object()
 
 # Registering actual config items
 
 def getitemregister(configtable):
     f = functools.partial(_register, configtable)
     # export pseudo enum as configitem.*
     f.dynamicdefault = dynamicdefault
     return f
 
 coreconfigitem = getitemregister(coreitems)
 
 coreconfigitem('alias', '.*',
     default=None,
     generic=True,
 )
 coreconfigitem('annotate', 'nodates',
     default=False,
 )
 coreconfigitem('annotate', 'showfunc',
     default=False,
 )
 coreconfigitem('annotate', 'unified',
     default=None,
 )
 coreconfigitem('annotate', 'git',
     default=False,
 )
 coreconfigitem('annotate', 'ignorews',
     default=False,
 )
 coreconfigitem('annotate', 'ignorewsamount',
     default=False,
 )
 coreconfigitem('annotate', 'ignoreblanklines',
     default=False,
 )
 coreconfigitem('annotate', 'ignorewseol',
     default=False,
 )
 coreconfigitem('annotate', 'nobinary',
     default=False,
 )
 coreconfigitem('annotate', 'noprefix',
     default=False,
 )
 coreconfigitem('auth', 'cookiefile',
     default=None,
 )
 # bookmarks.pushing: internal hack for discovery
 coreconfigitem('bookmarks', 'pushing',
     default=list,
 )
 # bundle.mainreporoot: internal hack for bundlerepo
 coreconfigitem('bundle', 'mainreporoot',
     default='',
 )
 # bundle.reorder: experimental config
 coreconfigitem('bundle', 'reorder',
     default='auto',
 )
 coreconfigitem('censor', 'policy',
     default='abort',
 )
 coreconfigitem('chgserver', 'idletimeout',
     default=3600,
 )
 coreconfigitem('chgserver', 'skiphash',
     default=False,
 )
 coreconfigitem('cmdserver', 'log',
     default=None,
 )
 coreconfigitem('color', '.*',
     default=None,
     generic=True,
 )
 coreconfigitem('color', 'mode',
     default='auto',
 )
 coreconfigitem('color', 'pagermode',
     default=dynamicdefault,
 )
 coreconfigitem('commands', 'show.aliasprefix',
     default=list,
 )
 coreconfigitem('commands', 'status.relative',
     default=False,
 )
 coreconfigitem('commands', 'status.skipstates',
     default=[],
 )
 coreconfigitem('commands', 'status.verbose',
     default=False,
 )
 coreconfigitem('commands', 'update.check',
     default=None,
     # Deprecated, remove after 4.4 release
     alias=[('experimental', 'updatecheck')]
 )
 coreconfigitem('commands', 'update.requiredest',
     default=False,
 )
 coreconfigitem('committemplate', '.*',
     default=None,
     generic=True,
 )
 coreconfigitem('convert', 'cvsps.cache',
     default=True,
 )
 coreconfigitem('convert', 'cvsps.fuzz',
     default=60,
 )
 coreconfigitem('convert', 'cvsps.logencoding',
     default=None,
 )
 coreconfigitem('convert', 'cvsps.mergefrom',
     default=None,
 )
 coreconfigitem('convert', 'cvsps.mergeto',
     default=None,
 )
 coreconfigitem('convert', 'git.committeractions',
     default=lambda: ['messagedifferent'],
 )
 coreconfigitem('convert', 'git.extrakeys',
     default=list,
 )
 coreconfigitem('convert', 'git.findcopiesharder',
     default=False,
 )
 coreconfigitem('convert', 'git.remoteprefix',
     default='remote',
 )
 coreconfigitem('convert', 'git.renamelimit',
     default=400,
 )
 coreconfigitem('convert', 'git.saverev',
     default=True,
 )
 coreconfigitem('convert', 'git.similarity',
     default=50,
 )
 coreconfigitem('convert', 'git.skipsubmodules',
     default=False,
 )
 coreconfigitem('convert', 'hg.clonebranches',
     default=False,
 )
 coreconfigitem('convert', 'hg.ignoreerrors',
     default=False,
 )
 coreconfigitem('convert', 'hg.revs',
     default=None,
 )
 coreconfigitem('convert', 'hg.saverev',
     default=False,
 )
 coreconfigitem('convert', 'hg.sourcename',
     default=None,
 )
 coreconfigitem('convert', 'hg.startrev',
     default=None,
 )
 coreconfigitem('convert', 'hg.tagsbranch',
     default='default',
 )
 coreconfigitem('convert', 'hg.usebranchnames',
     default=True,
 )
 coreconfigitem('convert', 'ignoreancestorcheck',
     default=False,
 )
 coreconfigitem('convert', 'localtimezone',
     default=False,
 )
 coreconfigitem('convert', 'p4.encoding',
     default=dynamicdefault,
 )
 coreconfigitem('convert', 'p4.startrev',
     default=0,
 )
 coreconfigitem('convert', 'skiptags',
     default=False,
 )
 coreconfigitem('convert', 'svn.debugsvnlog',
     default=True,
 )
 coreconfigitem('convert', 'svn.trunk',
     default=None,
 )
 coreconfigitem('convert', 'svn.tags',
     default=None,
 )
 coreconfigitem('convert', 'svn.branches',
     default=None,
 )
 coreconfigitem('convert', 'svn.startrev',
     default=0,
 )
 coreconfigitem('debug', 'dirstate.delaywrite',
     default=0,
 )
 coreconfigitem('defaults', '.*',
     default=None,
     generic=True,
 )
 coreconfigitem('devel', 'all-warnings',
     default=False,
 )
 coreconfigitem('devel', 'bundle2.debug',
     default=False,
 )
 coreconfigitem('devel', 'cache-vfs',
     default=None,
 )
 coreconfigitem('devel', 'check-locks',
     default=False,
 )
 coreconfigitem('devel', 'check-relroot',
     default=False,
 )
 coreconfigitem('devel', 'default-date',
     default=None,
 )
 coreconfigitem('devel', 'deprec-warn',
     default=False,
 )
 coreconfigitem('devel', 'disableloaddefaultcerts',
     default=False,
 )
 coreconfigitem('devel', 'warn-empty-changegroup',
     default=False,
 )
 coreconfigitem('devel', 'legacy.exchange',
     default=list,
 )
 coreconfigitem('devel', 'servercafile',
     default='',
 )
 coreconfigitem('devel', 'serverexactprotocol',
     default='',
 )
 coreconfigitem('devel', 'serverrequirecert',
     default=False,
 )
 coreconfigitem('devel', 'strip-obsmarkers',
     default=True,
 )
 coreconfigitem('devel', 'warn-config',
     default=None,
 )
 coreconfigitem('devel', 'warn-config-default',
     default=None,
 )
 coreconfigitem('devel', 'user.obsmarker',
     default=None,
 )
 coreconfigitem('devel', 'warn-config-unknown',
     default=None,
 )
 coreconfigitem('diff', 'nodates',
     default=False,
 )
 coreconfigitem('diff', 'showfunc',
     default=False,
 )
 coreconfigitem('diff', 'unified',
     default=None,
 )
 coreconfigitem('diff', 'git',
     default=False,
 )
 coreconfigitem('diff', 'ignorews',
     default=False,
 )
 coreconfigitem('diff', 'ignorewsamount',
     default=False,
 )
 coreconfigitem('diff', 'ignoreblanklines',
     default=False,
 )
 coreconfigitem('diff', 'ignorewseol',
     default=False,
 )
 coreconfigitem('diff', 'nobinary',
     default=False,
 )
 coreconfigitem('diff', 'noprefix',
     default=False,
 )
 coreconfigitem('email', 'bcc',
     default=None,
 )
 coreconfigitem('email', 'cc',
     default=None,
 )
 coreconfigitem('email', 'charsets',
     default=list,
 )
 coreconfigitem('email', 'from',
     default=None,
 )
 coreconfigitem('email', 'method',
     default='smtp',
 )
 coreconfigitem('email', 'reply-to',
     default=None,
 )
 coreconfigitem('email', 'to',
     default=None,
 )
 coreconfigitem('experimental', 'archivemetatemplate',
     default=dynamicdefault,
 )
 coreconfigitem('experimental', 'bundle-phases',
     default=False,
 )
 coreconfigitem('experimental', 'bundle2-advertise',
     default=True,
 )
 coreconfigitem('experimental', 'bundle2-output-capture',
     default=False,
 )
 coreconfigitem('experimental', 'bundle2.pushback',
     default=False,
 )
 coreconfigitem('experimental', 'bundle2lazylocking',
     default=False,
 )
 coreconfigitem('experimental', 'bundlecomplevel',
     default=None,
 )
 coreconfigitem('experimental', 'changegroup3',
     default=False,
 )
 coreconfigitem('experimental', 'clientcompressionengines',
     default=list,
 )
 coreconfigitem('experimental', 'copytrace',
     default='on',
 )
 coreconfigitem('experimental', 'copytrace.movecandidateslimit',
     default=100,
 )
 coreconfigitem('experimental', 'copytrace.sourcecommitlimit',
     default=100,
 )
 coreconfigitem('experimental', 'crecordtest',
     default=None,
 )
 coreconfigitem('experimental', 'editortmpinhg',
     default=False,
 )
 coreconfigitem('experimental', 'evolution',
     default=list,
 )
 coreconfigitem('experimental', 'evolution.allowdivergence',
     default=False,
     alias=[('experimental', 'allowdivergence')]
 )
 coreconfigitem('experimental', 'evolution.allowunstable',
     default=None,
 )
 coreconfigitem('experimental', 'evolution.createmarkers',
     default=None,
 )
 coreconfigitem('experimental', 'evolution.effect-flags',
     default=True,
     alias=[('experimental', 'effect-flags')]
 )
 coreconfigitem('experimental', 'evolution.exchange',
     default=None,
 )
 coreconfigitem('experimental', 'evolution.bundle-obsmarker',
     default=False,
 )
 coreconfigitem('experimental', 'evolution.track-operation',
     default=True,
 )
+coreconfigitem('experimental', 'worddiff',
+    default=False,
+)
 coreconfigitem('experimental', 'maxdeltachainspan',
     default=-1,
 )
 coreconfigitem('experimental', 'mmapindexthreshold',
     default=None,
 )
 coreconfigitem('experimental', 'nonnormalparanoidcheck',
     default=False,
 )
 coreconfigitem('experimental', 'exportableenviron',
     default=list,
 )
 coreconfigitem('experimental', 'extendedheader.index',
     default=None,
 )
 coreconfigitem('experimental', 'extendedheader.similarity',
     default=False,
 )
 coreconfigitem('experimental', 'format.compression',
     default='zlib',
 )
 coreconfigitem('experimental', 'graphshorten',
     default=False,
 )
 coreconfigitem('experimental', 'graphstyle.parent',
     default=dynamicdefault,
 )
 coreconfigitem('experimental', 'graphstyle.missing',
     default=dynamicdefault,
 )
 coreconfigitem('experimental', 'graphstyle.grandparent',
     default=dynamicdefault,
 )
 coreconfigitem('experimental', 'hook-track-tags',
     default=False,
 )
 coreconfigitem('experimental', 'httppostargs',
     default=False,
 )
 coreconfigitem('experimental', 'manifestv2',
     default=False,
 )
 coreconfigitem('experimental', 'mergedriver',
     default=None,
 )
 coreconfigitem('experimental', 'obsmarkers-exchange-debug',
     default=False,
 )
 coreconfigitem('experimental', 'rebase.multidest',
     default=False,
 )
 coreconfigitem('experimental', 'remotenames',
     default=False,
 )
 coreconfigitem('experimental', 'revlogv2',
     default=None,
 )
 coreconfigitem('experimental', 'single-head-per-branch',
     default=False,
 )
 coreconfigitem('experimental', 'spacemovesdown',
     default=False,
 )
 coreconfigitem('experimental', 'sparse-read',
     default=False,
 )
 coreconfigitem('experimental', 'sparse-read.density-threshold',
     default=0.25,
 )
 coreconfigitem('experimental', 'sparse-read.min-gap-size',
     default='256K',
 )
 coreconfigitem('experimental', 'treemanifest',
     default=False,
 )
 coreconfigitem('extensions', '.*',
     default=None,
     generic=True,
 )
 coreconfigitem('extdata', '.*',
     default=None,
     generic=True,
 )
 coreconfigitem('format', 'aggressivemergedeltas',
     default=False,
 )
 coreconfigitem('format', 'chunkcachesize',
     default=None,
 )
 coreconfigitem('format', 'dotencode',
     default=True,
 )
 coreconfigitem('format', 'generaldelta',
     default=False,
 )
 coreconfigitem('format', 'manifestcachesize',
     default=None,
 )
 coreconfigitem('format', 'maxchainlen',
     default=None,
 )
 coreconfigitem('format', 'obsstore-version',
     default=None,
 )
 coreconfigitem('format', 'usefncache',
     default=True,
 )
 coreconfigitem('format', 'usegeneraldelta',
     default=True,
 )
 coreconfigitem('format', 'usestore',
     default=True,
 )
 coreconfigitem('fsmonitor', 'warn_when_unused',
     default=True,
 )
 coreconfigitem('fsmonitor', 'warn_update_file_count',
     default=50000,
 )
 coreconfigitem('hooks', '.*',
     default=dynamicdefault,
     generic=True,
 )
 coreconfigitem('hgweb-paths', '.*',
     default=list,
     generic=True,
 )
 coreconfigitem('hostfingerprints', '.*',
     default=list,
     generic=True,
 )
 coreconfigitem('hostsecurity', 'ciphers',
     default=None,
 )
 coreconfigitem('hostsecurity', 'disabletls10warning',
     default=False,
 )
 coreconfigitem('hostsecurity', 'minimumprotocol',
     default=dynamicdefault,
 )
 coreconfigitem('hostsecurity', '.*:minimumprotocol$',
     default=dynamicdefault,
     generic=True,
 )
 coreconfigitem('hostsecurity', '.*:ciphers$',
     default=dynamicdefault,
     generic=True,
 )
 coreconfigitem('hostsecurity', '.*:fingerprints$',
     default=list,
     generic=True,
 )
 coreconfigitem('hostsecurity', '.*:verifycertsfile$',
     default=None,
     generic=True,
 )
 
 coreconfigitem('http_proxy', 'always',
     default=False,
 )
 coreconfigitem('http_proxy', 'host',
     default=None,
 )
 coreconfigitem('http_proxy', 'no',
     default=list,
 )
 coreconfigitem('http_proxy', 'passwd',
     default=None,
 )
 coreconfigitem('http_proxy', 'user',
     default=None,
 )
 coreconfigitem('logtoprocess', 'commandexception',
     default=None,
 )
 coreconfigitem('logtoprocess', 'commandfinish',
     default=None,
 )
 coreconfigitem('logtoprocess', 'command',
     default=None,
 )
 coreconfigitem('logtoprocess', 'develwarn',
     default=None,
 )
 coreconfigitem('logtoprocess', 'uiblocked',
     default=None,
 )
 coreconfigitem('merge', 'checkunknown',
     default='abort',
 )
 coreconfigitem('merge', 'checkignored',
     default='abort',
 )
 coreconfigitem('experimental', 'merge.checkpathconflicts',
     default=False,
 )
 coreconfigitem('merge', 'followcopies',
     default=True,
 )
 coreconfigitem('merge', 'on-failure',
     default='continue',
 )
 coreconfigitem('merge', 'preferancestor',
         default=lambda: ['*'],
 )
 coreconfigitem('merge-tools', '.*',
     default=None,
     generic=True,
 )
 coreconfigitem('merge-tools', br'.*\.args$',
     default="$local $base $other",
     generic=True,
     priority=-1,
 )
 coreconfigitem('merge-tools', br'.*\.binary$',
     default=False,
     generic=True,
     priority=-1,
 )
 coreconfigitem('merge-tools', br'.*\.check$',
     default=list,
     generic=True,
     priority=-1,
 )
 coreconfigitem('merge-tools', br'.*\.checkchanged$',
     default=False,
     generic=True,
     priority=-1,
 )
 coreconfigitem('merge-tools', br'.*\.executable$',
     default=dynamicdefault,
     generic=True,
     priority=-1,
 )
 coreconfigitem('merge-tools', br'.*\.fixeol$',
     default=False,
     generic=True,
     priority=-1,
 )
 coreconfigitem('merge-tools', br'.*\.gui$',
     default=False,
     generic=True,
     priority=-1,
 )
 coreconfigitem('merge-tools', br'.*\.priority$',
     default=0,
     generic=True,
     priority=-1,
 )
 coreconfigitem('merge-tools', br'.*\.premerge$',
     default=dynamicdefault,
     generic=True,
     priority=-1,
 )
 coreconfigitem('merge-tools', br'.*\.symlink$',
     default=False,
     generic=True,
     priority=-1,
 )
 coreconfigitem('pager', 'attend-.*',
     default=dynamicdefault,
     generic=True,
 )
 coreconfigitem('pager', 'ignore',
     default=list,
 )
 coreconfigitem('pager', 'pager',
     default=dynamicdefault,
 )
 coreconfigitem('patch', 'eol',
     default='strict',
 )
 coreconfigitem('patch', 'fuzz',
     default=2,
 )
 coreconfigitem('paths', 'default',
     default=None,
 )
 coreconfigitem('paths', 'default-push',
     default=None,
 )
 coreconfigitem('paths', '.*',
     default=None,
     generic=True,
 )
 coreconfigitem('phases', 'checksubrepos',
     default='follow',
 )
 coreconfigitem('phases', 'new-commit',
     default='draft',
 )
 coreconfigitem('phases', 'publish',
     default=True,
 )
 coreconfigitem('profiling', 'enabled',
     default=False,
 )
 coreconfigitem('profiling', 'format',
     default='text',
 )
 coreconfigitem('profiling', 'freq',
     default=1000,
 )
 coreconfigitem('profiling', 'limit',
     default=30,
 )
 coreconfigitem('profiling', 'nested',
     default=0,
 )
 coreconfigitem('profiling', 'output',
     default=None,
 )
 coreconfigitem('profiling', 'showmax',
     default=0.999,
 )
 coreconfigitem('profiling', 'showmin',
     default=dynamicdefault,
 )
 coreconfigitem('profiling', 'sort',
     default='inlinetime',
 )
 coreconfigitem('profiling', 'statformat',
     default='hotpath',
 )
 coreconfigitem('profiling', 'type',
     default='stat',
 )
 coreconfigitem('progress', 'assume-tty',
     default=False,
 )
 coreconfigitem('progress', 'changedelay',
     default=1,
 )
 coreconfigitem('progress', 'clear-complete',
     default=True,
 )
 coreconfigitem('progress', 'debug',
     default=False,
 )
 coreconfigitem('progress', 'delay',
     default=3,
 )
 coreconfigitem('progress', 'disable',
     default=False,
 )
 coreconfigitem('progress', 'estimateinterval',
     default=60.0,
 )
 coreconfigitem('progress', 'format',
     default=lambda: ['topic', 'bar', 'number', 'estimate'],
 )
 coreconfigitem('progress', 'refresh',
     default=0.1,
 )
 coreconfigitem('progress', 'width',
     default=dynamicdefault,
 )
 coreconfigitem('push', 'pushvars.server',
     default=False,
 )
 coreconfigitem('server', 'bookmarks-pushkey-compat',
     default=True,
 )
 coreconfigitem('server', 'bundle1',
     default=True,
 )
 coreconfigitem('server', 'bundle1gd',
     default=None,
 )
 coreconfigitem('server', 'bundle1.pull',
     default=None,
 )
 coreconfigitem('server', 'bundle1gd.pull',
     default=None,
 )
 coreconfigitem('server', 'bundle1.push',
     default=None,
 )
 coreconfigitem('server', 'bundle1gd.push',
     default=None,
 )
 coreconfigitem('server', 'compressionengines',
     default=list,
 )
 coreconfigitem('server', 'concurrent-push-mode',
     default='strict',
 )
 coreconfigitem('server', 'disablefullbundle',
     default=False,
 )
 coreconfigitem('server', 'maxhttpheaderlen',
     default=1024,
 )
 coreconfigitem('server', 'preferuncompressed',
     default=False,
 )
 coreconfigitem('server', 'uncompressed',
     default=True,
 )
 coreconfigitem('server', 'uncompressedallowsecret',
     default=False,
 )
 coreconfigitem('server', 'validate',
     default=False,
 )
 coreconfigitem('server', 'zliblevel',
     default=-1,
 )
 coreconfigitem('share', 'pool',
     default=None,
 )
 coreconfigitem('share', 'poolnaming',
     default='identity',
 )
 coreconfigitem('smtp', 'host',
     default=None,
 )
 coreconfigitem('smtp', 'local_hostname',
     default=None,
 )
 coreconfigitem('smtp', 'password',
     default=None,
 )
 coreconfigitem('smtp', 'port',
     default=dynamicdefault,
 )
 coreconfigitem('smtp', 'tls',
     default='none',
 )
 coreconfigitem('smtp', 'username',
     default=None,
 )
 coreconfigitem('sparse', 'missingwarning',
     default=True,
 )
 coreconfigitem('subrepos', 'allowed',
     default=dynamicdefault,  # to make backporting simpler
 )
 coreconfigitem('subrepos', 'hg:allowed',
     default=dynamicdefault,
 )
 coreconfigitem('subrepos', 'git:allowed',
     default=dynamicdefault,
 )
 coreconfigitem('subrepos', 'svn:allowed',
     default=dynamicdefault,
 )
 coreconfigitem('templates', '.*',
     default=None,
     generic=True,
 )
 coreconfigitem('trusted', 'groups',
     default=list,
 )
 coreconfigitem('trusted', 'users',
     default=list,
 )
 coreconfigitem('ui', '_usedassubrepo',
     default=False,
 )
 coreconfigitem('ui', 'allowemptycommit',
     default=False,
 )
 coreconfigitem('ui', 'archivemeta',
     default=True,
 )
 coreconfigitem('ui', 'askusername',
     default=False,
 )
 coreconfigitem('ui', 'clonebundlefallback',
     default=False,
 )
 coreconfigitem('ui', 'clonebundleprefers',
     default=list,
 )
 coreconfigitem('ui', 'clonebundles',
     default=True,
 )
 coreconfigitem('ui', 'color',
     default='auto',
 )
 coreconfigitem('ui', 'commitsubrepos',
     default=False,
 )
 coreconfigitem('ui', 'debug',
     default=False,
 )
 coreconfigitem('ui', 'debugger',
     default=None,
 )
 coreconfigitem('ui', 'editor',
     default=dynamicdefault,
 )
 coreconfigitem('ui', 'fallbackencoding',
     default=None,
 )
 coreconfigitem('ui', 'forcecwd',
     default=None,
 )
 coreconfigitem('ui', 'forcemerge',
     default=None,
 )
 coreconfigitem('ui', 'formatdebug',
     default=False,
 )
 coreconfigitem('ui', 'formatjson',
     default=False,
 )
 coreconfigitem('ui', 'formatted',
     default=None,
 )
 coreconfigitem('ui', 'graphnodetemplate',
     default=None,
 )
 coreconfigitem('ui', 'http2debuglevel',
     default=None,
 )
 coreconfigitem('ui', 'interactive',
     default=None,
 )
 coreconfigitem('ui', 'interface',
     default=None,
 )
 coreconfigitem('ui', 'interface.chunkselector',
     default=None,
 )
 coreconfigitem('ui', 'logblockedtimes',
     default=False,
 )
 coreconfigitem('ui', 'logtemplate',
     default=None,
 )
 coreconfigitem('ui', 'merge',
     default=None,
 )
 coreconfigitem('ui', 'mergemarkers',
     default='basic',
 )
 coreconfigitem('ui', 'mergemarkertemplate',
     default=('{node|short} '
             '{ifeq(tags, "tip", "", '
             'ifeq(tags, "", "", "{tags} "))}'
             '{if(bookmarks, "{bookmarks} ")}'
             '{ifeq(branch, "default", "", "{branch} ")}'
             '- {author|user}: {desc|firstline}')
 )
 coreconfigitem('ui', 'nontty',
     default=False,
 )
 coreconfigitem('ui', 'origbackuppath',
     default=None,
 )
 coreconfigitem('ui', 'paginate',
     default=True,
 )
 coreconfigitem('ui', 'patch',
     default=None,
 )
 coreconfigitem('ui', 'portablefilenames',
     default='warn',
 )
 coreconfigitem('ui', 'promptecho',
     default=False,
 )
 coreconfigitem('ui', 'quiet',
     default=False,
 )
 coreconfigitem('ui', 'quietbookmarkmove',
     default=False,
 )
 coreconfigitem('ui', 'remotecmd',
     default='hg',
 )
 coreconfigitem('ui', 'report_untrusted',
     default=True,
 )
 coreconfigitem('ui', 'rollback',
     default=True,
 )
 coreconfigitem('ui', 'slash',
     default=False,
 )
 coreconfigitem('ui', 'ssh',
     default='ssh',
 )
 coreconfigitem('ui', 'ssherrorhint',
     default=None,
 )
 coreconfigitem('ui', 'statuscopies',
     default=False,
 )
 coreconfigitem('ui', 'strict',
     default=False,
 )
 coreconfigitem('ui', 'style',
     default='',
 )
 coreconfigitem('ui', 'supportcontact',
     default=None,
 )
 coreconfigitem('ui', 'textwidth',
     default=78,
 )
 coreconfigitem('ui', 'timeout',
     default='600',
 )
 coreconfigitem('ui', 'timeout.warn',
     default=0,
 )
 coreconfigitem('ui', 'traceback',
     default=False,
 )
 coreconfigitem('ui', 'tweakdefaults',
     default=False,
 )
 coreconfigitem('ui', 'usehttp2',
     default=False,
 )
 coreconfigitem('ui', 'username',
     alias=[('ui', 'user')]
 )
 coreconfigitem('ui', 'verbose',
     default=False,
 )
 coreconfigitem('verify', 'skipflags',
     default=None,
 )
 coreconfigitem('web', 'allowbz2',
     default=False,
 )
 coreconfigitem('web', 'allowgz',
     default=False,
 )
 coreconfigitem('web', 'allow-pull',
     alias=[('web', 'allowpull')],
     default=True,
 )
 coreconfigitem('web', 'allow-push',
     alias=[('web', 'allow_push')],
     default=list,
 )
 coreconfigitem('web', 'allowzip',
     default=False,
 )
 coreconfigitem('web', 'archivesubrepos',
     default=False,
 )
 coreconfigitem('web', 'cache',
     default=True,
 )
 coreconfigitem('web', 'contact',
     default=None,
 )
 coreconfigitem('web', 'deny_push',
     default=list,
 )
 coreconfigitem('web', 'guessmime',
     default=False,
 )
 coreconfigitem('web', 'hidden',
     default=False,
 )
 coreconfigitem('web', 'labels',
     default=list,
 )
 coreconfigitem('web', 'logoimg',
     default='hglogo.png',
 )
 coreconfigitem('web', 'logourl',
     default='https://mercurial-scm.org/',
 )
 coreconfigitem('web', 'accesslog',
     default='-',
 )
 coreconfigitem('web', 'address',
     default='',
 )
 coreconfigitem('web', 'allow_archive',
     default=list,
 )
 coreconfigitem('web', 'allow_read',
     default=list,
 )
 coreconfigitem('web', 'baseurl',
     default=None,
 )
 coreconfigitem('web', 'cacerts',
     default=None,
 )
 coreconfigitem('web', 'certificate',
     default=None,
 )
 coreconfigitem('web', 'collapse',
     default=False,
 )
 coreconfigitem('web', 'csp',
     default=None,
 )
 coreconfigitem('web', 'deny_read',
     default=list,
 )
 coreconfigitem('web', 'descend',
     default=True,
 )
 coreconfigitem('web', 'description',
     default="",
 )
 coreconfigitem('web', 'encoding',
     default=lambda: encoding.encoding,
 )
 coreconfigitem('web', 'errorlog',
     default='-',
 )
 coreconfigitem('web', 'ipv6',
     default=False,
 )
 coreconfigitem('web', 'maxchanges',
     default=10,
 )
 coreconfigitem('web', 'maxfiles',
     default=10,
 )
 coreconfigitem('web', 'maxshortchanges',
     default=60,
 )
 coreconfigitem('web', 'motd',
     default='',
 )
 coreconfigitem('web', 'name',
     default=dynamicdefault,
 )
 coreconfigitem('web', 'port',
     default=8000,
 )
 coreconfigitem('web', 'prefix',
     default='',
 )
 coreconfigitem('web', 'push_ssl',
     default=True,
 )
 coreconfigitem('web', 'refreshinterval',
     default=20,
 )
 coreconfigitem('web', 'staticurl',
     default=None,
 )
 coreconfigitem('web', 'stripes',
     default=1,
 )
 coreconfigitem('web', 'style',
     default='paper',
 )
 coreconfigitem('web', 'templates',
     default=None,
 )
 coreconfigitem('web', 'view',
     default='served',
 )
 coreconfigitem('worker', 'backgroundclose',
     default=dynamicdefault,
 )
 # Windows defaults to a limit of 512 open files. A buffer of 128
 # should give us enough headway.
 coreconfigitem('worker', 'backgroundclosemaxqueue',
     default=384,
 )
 coreconfigitem('worker', 'backgroundcloseminfilecount',
     default=2048,
 )
 coreconfigitem('worker', 'backgroundclosethreadcount',
     default=4,
 )
 coreconfigitem('worker', 'numcpus',
     default=None,
 )
 
 # Rebase related configuration moved to core because other extension are doing
 # strange things. For example, shelve import the extensions to reuse some bit
 # without formally loading it.
 coreconfigitem('commands', 'rebase.requiredest',
             default=False,
 )
 coreconfigitem('experimental', 'rebaseskipobsolete',
     default=True,
 )
 coreconfigitem('rebase', 'singletransaction',
     default=False,
 )

mercurial/mdiff.py

@@ -1,491 +1,492 b''
 # mdiff.py - diff and patch routines for mercurial
 #
 # Copyright 2005, 2006 Matt Mackall <[e-mail]>
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 from __future__ import absolute_import
 
 import re
 import struct
 import zlib
 
 from .i18n import _
 from . import (
     error,
     policy,
     pycompat,
     util,
 )
 
 bdiff = policy.importmod(r'bdiff')
 mpatch = policy.importmod(r'mpatch')
 
 blocks = bdiff.blocks
 fixws = bdiff.fixws
 patches = mpatch.patches
 patchedsize = mpatch.patchedsize
 textdiff = bdiff.bdiff
 
 def splitnewlines(text):
     '''like str.splitlines, but only split on newlines.'''
     lines = [l + '\n' for l in text.split('\n')]
     if lines:
         if lines[-1] == '\n':
             lines.pop()
         else:
             lines[-1] = lines[-1][:-1]
     return lines
 
 class diffopts(object):
     '''context is the number of context lines
     text treats all files as text
     showfunc enables diff -p output
     git enables the git extended patch format
     nodates removes dates from diff headers
     nobinary ignores binary files
     noprefix disables the 'a/' and 'b/' prefixes (ignored in plain mode)
     ignorews ignores all whitespace changes in the diff
     ignorewsamount ignores changes in the amount of whitespace
     ignoreblanklines ignores changes whose lines are all blank
     upgrade generates git diffs to avoid data loss
     '''
 
     defaults = {
         'context': 3,
         'text': False,
         'showfunc': False,
         'git': False,
         'nodates': False,
         'nobinary': False,
         'noprefix': False,
         'index': 0,
         'ignorews': False,
         'ignorewsamount': False,
         'ignorewseol': False,
         'ignoreblanklines': False,
         'upgrade': False,
         'showsimilarity': False,
+        'worddiff': False,
         }
 
     def __init__(self, **opts):
         opts = pycompat.byteskwargs(opts)
         for k in self.defaults.keys():
             v = opts.get(k)
             if v is None:
                 v = self.defaults[k]
             setattr(self, k, v)
 
         try:
             self.context = int(self.context)
         except ValueError:
             raise error.Abort(_('diff context lines count must be '
                                'an integer, not %r') % self.context)
 
     def copy(self, **kwargs):
         opts = dict((k, getattr(self, k)) for k in self.defaults)
         opts = pycompat.strkwargs(opts)
         opts.update(kwargs)
         return diffopts(**opts)
 
 defaultopts = diffopts()
 
 def wsclean(opts, text, blank=True):
     if opts.ignorews:
         text = bdiff.fixws(text, 1)
     elif opts.ignorewsamount:
         text = bdiff.fixws(text, 0)
     if blank and opts.ignoreblanklines:
         text = re.sub('\n+', '\n', text).strip('\n')
     if opts.ignorewseol:
         text = re.sub(r'[ \t\r\f]+\n', r'\n', text)
     return text
 
 def splitblock(base1, lines1, base2, lines2, opts):
     # The input lines matches except for interwoven blank lines. We
     # transform it into a sequence of matching blocks and blank blocks.
     lines1 = [(wsclean(opts, l) and 1 or 0) for l in lines1]
     lines2 = [(wsclean(opts, l) and 1 or 0) for l in lines2]
     s1, e1 = 0, len(lines1)
     s2, e2 = 0, len(lines2)
     while s1 < e1 or s2 < e2:
         i1, i2, btype = s1, s2, '='
         if (i1 >= e1 or lines1[i1] == 0
             or i2 >= e2 or lines2[i2] == 0):
             # Consume the block of blank lines
             btype = '~'
             while i1 < e1 and lines1[i1] == 0:
                 i1 += 1
             while i2 < e2 and lines2[i2] == 0:
                 i2 += 1
         else:
             # Consume the matching lines
             while i1 < e1 and lines1[i1] == 1 and lines2[i2] == 1:
                 i1 += 1
                 i2 += 1
         yield [base1 + s1, base1 + i1, base2 + s2, base2 + i2], btype
         s1 = i1
         s2 = i2
 
 def hunkinrange(hunk, linerange):
     """Return True if `hunk` defined as (start, length) is in `linerange`
     defined as (lowerbound, upperbound).
 
     >>> hunkinrange((5, 10), (2, 7))
     True
     >>> hunkinrange((5, 10), (6, 12))
     True
     >>> hunkinrange((5, 10), (13, 17))
     True
     >>> hunkinrange((5, 10), (3, 17))
     True
     >>> hunkinrange((5, 10), (1, 3))
     False
     >>> hunkinrange((5, 10), (18, 20))
     False
     >>> hunkinrange((5, 10), (1, 5))
     False
     >>> hunkinrange((5, 10), (15, 27))
     False
     """
     start, length = hunk
     lowerbound, upperbound = linerange
     return lowerbound < start + length and start < upperbound
 
 def blocksinrange(blocks, rangeb):
     """filter `blocks` like (a1, a2, b1, b2) from items outside line range
     `rangeb` from ``(b1, b2)`` point of view.
 
     Return `filteredblocks, rangea` where:
 
     * `filteredblocks` is list of ``block = (a1, a2, b1, b2), stype`` items of
       `blocks` that are inside `rangeb` from ``(b1, b2)`` point of view; a
       block ``(b1, b2)`` being inside `rangeb` if
       ``rangeb[0] < b2 and b1 < rangeb[1]``;
     * `rangea` is the line range w.r.t. to ``(a1, a2)`` parts of `blocks`.
     """
     lbb, ubb = rangeb
     lba, uba = None, None
     filteredblocks = []
     for block in blocks:
         (a1, a2, b1, b2), stype = block
         if lbb >= b1 and ubb <= b2 and stype == '=':
             # rangeb is within a single "=" hunk, restrict back linerange1
             # by offsetting rangeb
             lba = lbb - b1 + a1
             uba = ubb - b1 + a1
         else:
             if b1 <= lbb < b2:
                 if stype == '=':
                     lba = a2 - (b2 - lbb)
                 else:
                     lba = a1
             if b1 < ubb <= b2:
                 if stype == '=':
                     uba = a1 + (ubb - b1)
                 else:
                     uba = a2
         if hunkinrange((b1, (b2 - b1)), rangeb):
             filteredblocks.append(block)
     if lba is None or uba is None or uba < lba:
         raise error.Abort(_('line range exceeds file size'))
     return filteredblocks, (lba, uba)
 
 def allblocks(text1, text2, opts=None, lines1=None, lines2=None):
     """Return (block, type) tuples, where block is an mdiff.blocks
     line entry. type is '=' for blocks matching exactly one another
     (bdiff blocks), '!' for non-matching blocks and '~' for blocks
     matching only after having filtered blank lines.
     line1 and line2 are text1 and text2 split with splitnewlines() if
     they are already available.
     """
     if opts is None:
         opts = defaultopts
     if opts.ignorews or opts.ignorewsamount or opts.ignorewseol:
         text1 = wsclean(opts, text1, False)
         text2 = wsclean(opts, text2, False)
     diff = bdiff.blocks(text1, text2)
     for i, s1 in enumerate(diff):
         # The first match is special.
         # we've either found a match starting at line 0 or a match later
         # in the file.  If it starts later, old and new below will both be
         # empty and we'll continue to the next match.
         if i > 0:
             s = diff[i - 1]
         else:
             s = [0, 0, 0, 0]
         s = [s[1], s1[0], s[3], s1[2]]
 
         # bdiff sometimes gives huge matches past eof, this check eats them,
         # and deals with the special first match case described above
         if s[0] != s[1] or s[2] != s[3]:
             type = '!'
             if opts.ignoreblanklines:
                 if lines1 is None:
                     lines1 = splitnewlines(text1)
                 if lines2 is None:
                     lines2 = splitnewlines(text2)
                 old = wsclean(opts, "".join(lines1[s[0]:s[1]]))
                 new = wsclean(opts, "".join(lines2[s[2]:s[3]]))
                 if old == new:
                     type = '~'
             yield s, type
         yield s1, '='
 
 def unidiff(a, ad, b, bd, fn1, fn2, opts=defaultopts):
     """Return a unified diff as a (headers, hunks) tuple.
 
     If the diff is not null, `headers` is a list with unified diff header
     lines "--- <original>" and "+++ <new>" and `hunks` is a generator yielding
     (hunkrange, hunklines) coming from _unidiff().
     Otherwise, `headers` and `hunks` are empty.
     """
     def datetag(date, fn=None):
         if not opts.git and not opts.nodates:
             return '\t%s' % date
         if fn and ' ' in fn:
             return '\t'
         return ''
 
     sentinel = [], ()
     if not a and not b:
         return sentinel
 
     if opts.noprefix:
         aprefix = bprefix = ''
     else:
         aprefix = 'a/'
         bprefix = 'b/'
 
     epoch = util.datestr((0, 0))
 
     fn1 = util.pconvert(fn1)
     fn2 = util.pconvert(fn2)
 
     def checknonewline(lines):
         for text in lines:
             if text[-1:] != '\n':
                 text += "\n\ No newline at end of file\n"
             yield text
 
     if not opts.text and (util.binary(a) or util.binary(b)):
         if a and b and len(a) == len(b) and a == b:
             return sentinel
         headerlines = []
         hunks = (None, ['Binary file %s has changed\n' % fn1]),
     elif not a:
         b = splitnewlines(b)
         if a is None:
             l1 = '--- /dev/null%s' % datetag(epoch)
         else:
             l1 = "--- %s%s%s" % (aprefix, fn1, datetag(ad, fn1))
         l2 = "+++ %s%s" % (bprefix + fn2, datetag(bd, fn2))
         headerlines = [l1, l2]
         size = len(b)
         hunkrange = (0, 0, 1, size)
         hunklines = ["@@ -0,0 +1,%d @@\n" % size] + ["+" + e for e in b]
         hunks = (hunkrange, checknonewline(hunklines)),
     elif not b:
         a = splitnewlines(a)
         l1 = "--- %s%s%s" % (aprefix, fn1, datetag(ad, fn1))
         if b is None:
             l2 = '+++ /dev/null%s' % datetag(epoch)
         else:
             l2 = "+++ %s%s%s" % (bprefix, fn2, datetag(bd, fn2))
         headerlines = [l1, l2]
         size = len(a)
         hunkrange = (1, size, 0, 0)
         hunklines = ["@@ -1,%d +0,0 @@\n" % size] + ["-" + e for e in a]
         hunks = (hunkrange, checknonewline(hunklines)),
     else:
         diffhunks = _unidiff(a, b, opts=opts)
         try:
             hunkrange, hunklines = next(diffhunks)
         except StopIteration:
             return sentinel
 
         headerlines = [
             "--- %s%s%s" % (aprefix, fn1, datetag(ad, fn1)),
             "+++ %s%s%s" % (bprefix, fn2, datetag(bd, fn2)),
         ]
         def rewindhunks():
             yield hunkrange, checknonewline(hunklines)
             for hr, hl in diffhunks:
                 yield hr, checknonewline(hl)
 
         hunks = rewindhunks()
 
     return headerlines, hunks
 
 def _unidiff(t1, t2, opts=defaultopts):
     """Yield hunks of a headerless unified diff from t1 and t2 texts.
 
     Each hunk consists of a (hunkrange, hunklines) tuple where `hunkrange` is a
     tuple (s1, l1, s2, l2) representing the range information of the hunk to
     form the '@@ -s1,l1 +s2,l2 @@' header and `hunklines` is a list of lines
     of the hunk combining said header followed by line additions and
     deletions.
     """
     l1 = splitnewlines(t1)
     l2 = splitnewlines(t2)
     def contextend(l, len):
         ret = l + opts.context
         if ret > len:
             ret = len
         return ret
 
     def contextstart(l):
         ret = l - opts.context
         if ret < 0:
             return 0
         return ret
 
     lastfunc = [0, '']
     def yieldhunk(hunk):
         (astart, a2, bstart, b2, delta) = hunk
         aend = contextend(a2, len(l1))
         alen = aend - astart
         blen = b2 - bstart + aend - a2
 
         func = ""
         if opts.showfunc:
             lastpos, func = lastfunc
             # walk backwards from the start of the context up to the start of
             # the previous hunk context until we find a line starting with an
             # alphanumeric char.
             for i in xrange(astart - 1, lastpos - 1, -1):
                 if l1[i][0].isalnum():
                     func = ' ' + l1[i].rstrip()[:40]
                     lastfunc[1] = func
                     break
             # by recording this hunk's starting point as the next place to
             # start looking for function lines, we avoid reading any line in
             # the file more than once.
             lastfunc[0] = astart
 
         # zero-length hunk ranges report their start line as one less
         if alen:
             astart += 1
         if blen:
             bstart += 1
 
         hunkrange = astart, alen, bstart, blen
         hunklines = (
             ["@@ -%d,%d +%d,%d @@%s\n" % (hunkrange + (func,))]
             + delta
             + [' ' + l1[x] for x in xrange(a2, aend)]
         )
         yield hunkrange, hunklines
 
     # bdiff.blocks gives us the matching sequences in the files.  The loop
     # below finds the spaces between those matching sequences and translates
     # them into diff output.
     #
     hunk = None
     ignoredlines = 0
     for s, stype in allblocks(t1, t2, opts, l1, l2):
         a1, a2, b1, b2 = s
         if stype != '!':
             if stype == '~':
                 # The diff context lines are based on t1 content. When
                 # blank lines are ignored, the new lines offsets must
                 # be adjusted as if equivalent blocks ('~') had the
                 # same sizes on both sides.
                 ignoredlines += (b2 - b1) - (a2 - a1)
             continue
         delta = []
         old = l1[a1:a2]
         new = l2[b1:b2]
 
         b1 -= ignoredlines
         b2 -= ignoredlines
         astart = contextstart(a1)
         bstart = contextstart(b1)
         prev = None
         if hunk:
             # join with the previous hunk if it falls inside the context
             if astart < hunk[1] + opts.context + 1:
                 prev = hunk
                 astart = hunk[1]
                 bstart = hunk[3]
             else:
                 for x in yieldhunk(hunk):
                     yield x
         if prev:
             # we've joined the previous hunk, record the new ending points.
             hunk[1] = a2
             hunk[3] = b2
             delta = hunk[4]
         else:
             # create a new hunk
             hunk = [astart, a2, bstart, b2, delta]
 
         delta[len(delta):] = [' ' + x for x in l1[astart:a1]]
         delta[len(delta):] = ['-' + x for x in old]
         delta[len(delta):] = ['+' + x for x in new]
 
     if hunk:
         for x in yieldhunk(hunk):
             yield x
 
 def b85diff(to, tn):
     '''print base85-encoded binary diff'''
     def fmtline(line):
         l = len(line)
         if l <= 26:
             l = chr(ord('A') + l - 1)
         else:
             l = chr(l - 26 + ord('a') - 1)
         return '%c%s\n' % (l, util.b85encode(line, True))
 
     def chunk(text, csize=52):
         l = len(text)
         i = 0
         while i < l:
             yield text[i:i + csize]
             i += csize
 
     if to is None:
         to = ''
     if tn is None:
         tn = ''
 
     if to == tn:
         return ''
 
     # TODO: deltas
     ret = []
     ret.append('GIT binary patch\n')
     ret.append('literal %d\n' % len(tn))
     for l in chunk(zlib.compress(tn)):
         ret.append(fmtline(l))
     ret.append('\n')
 
     return ''.join(ret)
 
 def patchtext(bin):
     pos = 0
     t = []
     while pos < len(bin):
         p1, p2, l = struct.unpack(">lll", bin[pos:pos + 12])
         pos += 12
         t.append(bin[pos:pos + l])
         pos += l
     return "".join(t)
 
 def patch(a, bin):
     if len(a) == 0:
         # skip over trivial delta header
         return util.buffer(bin, 12)
     return mpatch.patches(a, [bin])
 
 # similar to difflib.SequenceMatcher.get_matching_blocks
 def get_matching_blocks(a, b):
     return [(d[0], d[2], d[1] - d[0]) for d in bdiff.blocks(a, b)]
 
 def trivialdiffheader(length):
     return struct.pack(">lll", 0, 0, length) if length else ''
 
 def replacediffheader(oldlen, newlen):
     return struct.pack(">lll", 0, oldlen, newlen)

mercurial/patch.py

@@ -1,2816 +1,2895 b''
 # patch.py - patch file parsing routines
 #
 # Copyright 2006 Brendan Cully <[e-mail]>
 # Copyright 2007 Chris Mason <[e-mail]>
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 from __future__ import absolute_import, print_function
 
 import collections
 import copy
+import difflib
 import email
 import errno
 import hashlib
 import os
 import posixpath
 import re
 import shutil
 import tempfile
 import zlib
 
 from .i18n import _
 from .node import (
     hex,
     short,
 )
 from . import (
     copies,
     encoding,
     error,
     mail,
     mdiff,
     pathutil,
     policy,
     pycompat,
     scmutil,
     similar,
     util,
     vfs as vfsmod,
 )
 
 diffhelpers = policy.importmod(r'diffhelpers')
 stringio = util.stringio
 
 gitre = re.compile(br'diff --git a/(.*) b/(.*)')
 tabsplitter = re.compile(br'(\t+|[^\t]+)')
 
 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[0] in (' ', '\t'):
             # continuation
             return True
         if line[0] in (' ', '-', '+'):
             # diff line - don't check for header pattern in there
             return False
         l = line.split(': ', 1)
         return len(l) == 2 and ' ' not in l[0]
 
     def chunk(lines):
         return stringio(''.join(lines))
 
     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):
             fp = stringio()
             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)
 
         m = email.Parser.Parser().parse(c)
         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
 
         __next__ = next
 
     inheader = False
     cur = []
 
     mimeheaders = ['content-type']
 
     if not util.safehasattr(stream, 'next'):
         # 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)
         elif line.startswith('--- ') and inheader:
             # No evil headers seen by diff start, split by hand
             return headersplit(stream, cur)
         # 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'),
                   ('Branch', 'branch'),
                   ('Node ID', 'nodeid'),
                  ]
 
 def extract(ui, fileobj):
     '''extract patch from data read from fileobj.
 
     patch can be a normal patch or contained in an email message.
 
     return a dictionary. Standard keys are:
       - filename,
       - message,
       - user,
       - date,
       - branch,
       - node,
       - p1,
       - p2.
     Any item can be missing from the dictionary. If filename is missing,
     fileobj did not contain a patch. Caller must unlink filename when done.'''
 
     # attempt to detect the start of a patch
     # (this heuristic is borrowed from quilt)
     diffre = re.compile(br'^(?:Index:[ \t]|diff[ \t]-|RCS file: |'
                         br'retrieving revision [0-9]+(\.[0-9]+)*$|'
                         br'---[ \t].*?^\+\+\+[ \t]|'
                         br'\*\*\*[ \t].*?^---[ \t])',
                         re.MULTILINE | re.DOTALL)
 
     data = {}
     fd, tmpname = tempfile.mkstemp(prefix='hg-patch-')
     tmpfp = os.fdopen(fd, pycompat.sysstr('w'))
     try:
         msg = email.Parser.Parser().parse(fileobj)
 
         subject = msg['Subject'] and mail.headdecode(msg['Subject'])
         data['user'] = msg['From'] and mail.headdecode(msg['From'])
         if not subject and not data['user']:
             # Not an email, restore parsed headers if any
             subject = '\n'.join(': '.join(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 = 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
         ok_types = ('text/plain', 'text/x-diff', 'text/x-patch')
         message = ''
         for part in msg.walk():
             content_type = part.get_content_type()
             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:
                 hgpatch = False
                 hgpatchheader = False
                 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():
                     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
                         cfp.seek(0)
                         cfp.truncate()
                         subject = None
                     elif hgpatchheader:
                         if line.startswith('# User '):
                             data['user'] = line[7:]
                             ui.debug('From: %s\n' % data['user'])
                         elif line.startswith("# Parent "):
                             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):]
                         else:
                             hgpatchheader = False
                     elif line == '---':
                         ignoretext = True
                     if not hgpatchheader and not ignoretext:
                         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
     except: # re-raises
         tmpfp.close()
         os.unlink(tmpname)
         raise
 
     if subject and not message.startswith(subject):
         message = '%s\n%s' % (subject, message)
     data['message'] = message
     tmpfp.close()
     if parents:
         data['p1'] = parents.pop(0)
         if parents:
             data['p2'] = parents.pop(0)
 
     if diffs_seen:
         data['filename'] = tmpname
     else:
         os.unlink(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'
         self.binary = False
 
     def setmode(self, mode):
         islink = mode & 0o20000
         isexec = mode & 0o100
         self.mode = (islink, isexec)
 
     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
 
     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)
 
     def __repr__(self):
         return "<patchmeta %s %r>" % (self.op, self.path)
 
 def readgitpatch(lr):
     """extract git-style metadata about patches from <patchname>"""
 
     # Filter patch for git information
     gp = None
     gitpatches = []
     for line in lr:
         line = line.rstrip(' \r\n')
         if line.startswith('diff --git a/'):
             m = gitre.match(line)
             if m:
                 if gp:
                     gitpatches.append(gp)
                 dst = m.group(2)
                 gp = patchmeta(dst)
         elif gp:
             if line.startswith('--- '):
                 gitpatches.append(gp)
                 gp = None
                 continue
             if line.startswith('rename from '):
                 gp.op = 'RENAME'
                 gp.oldpath = line[12:]
             elif line.startswith('rename to '):
                 gp.path = line[10:]
             elif line.startswith('copy from '):
                 gp.op = 'COPY'
                 gp.oldpath = line[10:]
             elif line.startswith('copy to '):
                 gp.path = line[8:]
             elif line.startswith('deleted file'):
                 gp.op = 'DELETE'
             elif line.startswith('new file mode '):
                 gp.op = 'ADD'
                 gp.setmode(int(line[-6:], 8))
             elif line.startswith('new mode '):
                 gp.setmode(int(line[-6:], 8))
             elif line.startswith('GIT binary patch'):
                 gp.binary = True
     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 = []
 
     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
         return self.fp.readline()
 
     def __iter__(self):
         return iter(self.readline, '')
 
 class abstractbackend(object):
     def __init__(self, ui):
         self.ui = ui
 
     def getfile(self, fname):
         """Return target file data and flags as a (data, (islink,
         isexec)) tuple. Data is None if file is missing/deleted.
         """
         raise NotImplementedError
 
     def setfile(self, fname, data, mode, copysource):
         """Write data to target file fname and set its mode. mode is a
         (islink, isexec) tuple. If data is None, the file content should
         be left unchanged. If the file is modified after being copied,
         copysource is set to the original file name.
         """
         raise NotImplementedError
 
     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.
         """
 
     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)
 
     def getfile(self, fname):
         if self.opener.islink(fname):
             return (self.opener.readlink(fname), (True, False))
 
         isexec = False
         try:
             isexec = self.opener.lstat(fname).st_mode & 0o100 != 0
         except OSError as e:
             if e.errno != errno.ENOENT:
                 raise
         try:
             return (self.opener.read(fname), (False, isexec))
         except IOError as e:
             if e.errno != errno.ENOENT:
                 raise
             return None, None
 
     def setfile(self, fname, data, mode, copysource):
         islink, isexec = mode
         if data is None:
             self.opener.setflags(fname, islink, isexec)
             return
         if islink:
             self.opener.symlink(data, fname)
         else:
             self.opener.write(fname, data)
             if isexec:
                 self.opener.setflags(fname, False, True)
 
     def unlink(self, fname):
         self.opener.unlinkpath(fname, ignoremissing=True)
 
     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()
 
     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
         self.similarity = similarity
         self.removed = set()
         self.changed = set()
         self.copied = []
 
     def _checkknown(self, fname):
         if self.repo.dirstate[fname] == '?' and self.exists(fname):
             raise PatchError(_('cannot patch %s: file is not tracked') % fname)
 
     def setfile(self, fname, data, mode, copysource):
         self._checkknown(fname)
         super(workingbackend, self).setfile(fname, data, mode, copysource)
         if copysource is not None:
             self.copied.append((copysource, fname))
         self.changed.add(fname)
 
     def unlink(self, fname):
         self._checkknown(fname)
         super(workingbackend, self).unlink(fname)
         self.removed.add(fname)
         self.changed.add(fname)
 
     def close(self):
         wctx = self.repo[None]
         changed = set(self.changed)
         for src, dst in self.copied:
             scmutil.dirstatecopy(self.ui, self.repo, wctx, src, dst)
         if self.removed:
             wctx.forget(sorted(self.removed))
             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
                     # marktouched().
                     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.size = 0
         self.data = {}
 
     def setfile(self, fname, data, mode, copied=None):
         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-')
                 self.opener = vfsmod.vfs(root)
             # Avoid filename issues with these simple names
             fn = str(self.created)
             self.opener.write(fn, data)
             self.created += 1
             self.files[fname] = (fn, mode, copied)
 
     def getfile(self, fname):
         if fname in self.data:
             return self.data[fname]
         if not self.opener or fname not in self.files:
             return None, None, None
         fn, mode, copied = self.files[fname]
         return self.opener.read(fn), mode, copied
 
     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
         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:
             return None, None
         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
 
 # @@ -start,len +start,len @@ or @@ -start +start @@ if len is 1
 unidesc = re.compile('@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@')
 contextdesc = re.compile('(?:---|\*\*\*) (\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.eol = None
         self.backend = backend
         self.ui = ui
         self.lines = []
         self.exists = False
         self.missing = True
         self.mode = gp.mode
         self.copysource = gp.oldpath
         self.create = gp.op in ('ADD', 'COPY', 'RENAME')
         self.remove = gp.op == 'DELETE'
         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)
             self.missing = False
             if data:
                 self.lines = mdiff.splitnewlines(data)
             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
         else:
             if self.create:
                 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 "
                            "current directory)\n"))
 
         self.hash = {}
         self.dirty = 0
         self.offset = 0
         self.skew = 0
         self.rej = []
         self.fileprinted = False
         self.printfile(False)
         self.hunks = 0
 
     def writelines(self, fname, lines, mode):
         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
 
         self.backend.setfile(fname, ''.join(lines), mode, self.copysource)
 
     def printfile(self, warn):
         if self.fileprinted:
             return
         if warn or self.ui.verbose:
             self.fileprinted = True
         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
 
         cand = self.hash.get(l, [])
         if len(cand) > 1:
             # resort our list of potentials forward then back.
             cand.sort(key=lambda x: abs(x - linenum))
         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
         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)
                 if l[-1:] != '\n':
                     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)") %
                             (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 "
                                "exists\n") % self.fname)
             else:
                 self.ui.warn(_("file %s already exists\n") % self.fname)
             self.rej.append(h)
             return -1
 
         if isinstance(h, binhunk):
             if self.remove:
                 self.backend.unlink(self.fname)
             else:
                 l = h.new(self.lines)
                 self.lines[:] = l
                 self.offset += len(l)
                 self.dirty = True
             return 0
 
         horig = h
         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.
             h = h.getnormalized()
 
         # fast case first, no offsets, no fuzz
         old, oldstart, new, newstart = h.fuzzit(0, False)
         oldstart += self.offset
         orig_start = oldstart
         # 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
         if (self.skew == 0 and
             diffhelpers.testhunk(old, self.lines, oldstart) == 0):
             if self.remove:
                 self.backend.unlink(self.fname)
             else:
                 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.hash = {}
         for x, s in enumerate(self.lines):
             self.hash.setdefault(s, []).append(x)
 
         for fuzzlen in xrange(self.ui.configint("patch", "fuzz") + 1):
             for toponly in [True, False]:
                 old, oldstart, new, newstart = h.fuzzit(fuzzlen, toponly)
                 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]
 
                 for l in cand:
                     if not old or diffhelpers.testhunk(old, self.lines, l) == 0:
                         self.lines[l : l + len(old)] = new
                         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 "
                                     "with fuzz %d "
                                     "(offset %d lines).\n")
                             self.printfile(True)
                             self.ui.warn(msg %
                                 (h.number, l + 1, fuzzlen, offset))
                         else:
                             msg = _("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)
         return -1
 
     def close(self):
         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) ')
     newfile_re = re.compile('(?:new file)')
 
     def __init__(self, header):
         self.header = header
         self.hunks = []
 
     def binary(self):
         return any(h.startswith('index ') for h in self.header)
 
     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):
         return any(self.allhunks_re.match(h) for h in self.header)
 
     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())))
 
     def isnewfile(self):
         return any(self.newfile_re.match(h) for h in self.header)
 
     def special(self):
         # 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 \
                 any(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,
                  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
 
         self.header = header
         trimedbefore, self.before = trimcontext(before, True)
         self.fromline = fromline + trimedbefore
         self.toline = toline + trimedbefore
         _trimedafter, self.after = trimcontext(after, False)
         self.proc = proc
         self.hunk = hunk
         self.added, self.removed = self.countchanges(self.hunk)
 
     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))
 
     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('-')])
         return add, rem
 
     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.
         """
         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,
                           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' %
                  (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 change %d/%d to '%s'?"),
             'record': _("record change %d/%d to '%s'?"),
         },
         'single': {
             'apply': _("apply this change to '%s'?"),
             'discard': _("discard this change to '%s'?"),
             'record': _("record this change to '%s'?"),
         },
         'help': {
             '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)'),
             '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)'),
         }
     }
 
 def filterpatch(ui, headers, operation=None):
     """Interactively filter patch chunks into applied-only chunks"""
     messages = getmessages()
 
     if operation is None:
         operation = 'record'
 
     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:
             resps = messages['help'][operation]
             r = ui.promptchoice("%s %s" % (query, resps))
             ui.write("\n")
             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
                 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
                 # https://mercurial-scm.org/wiki/RecordExtension)
                 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-",
                         suffix=".diff", text=True)
                 ncpatchfp = None
                 try:
                     # Write the initial patch
                     f = os.fdopen(patchfd, pycompat.sysstr("w"))
                     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()
                     ret = ui.system("%s \"%s\"" % (editor, patchfn),
                                     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)
                     ncpatchfp = stringio()
                     for line in util.iterfile(patchfp):
                         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
                 raise error.Abort(_('user quit'))
             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:
                 msg = messages['single'][operation] % chunk.filename()
             else:
                 idx = pos - len(h.hunks) + i
                 msg = messages['multiple'][operation] % (idx, total,
                                                          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)
             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
     return (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]
         self.a = []
         self.b = []
         self.starta = self.lena = None
         self.startb = self.lenb = None
         if lr is not None:
             if context:
                 self.read_context_hunk(lr)
             else:
                 self.read_unified_hunk(lr)
 
     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
         nh = hunk(self.desc, self.number, None, None)
         nh.number = self.number
         nh.desc = self.desc
         nh.hunk = self.hunk
         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
 
     def read_unified_hunk(self, lr):
         m = unidesc.match(self.desc)
         if not m:
             raise PatchError(_("bad hunk #%d") % self.number)
         self.starta, self.lena, self.startb, self.lenb = m.groups()
         if self.lena is None:
             self.lena = 1
         else:
             self.lena = int(self.lena)
         if self.lenb is None:
             self.lenb = 1
         else:
             self.lenb = int(self.lenb)
         self.starta = int(self.starta)
         self.startb = int(self.startb)
         diffhelpers.addlines(lr, self.hunk, self.lena, self.lenb, self.a,
                              self.b)
         # 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:
             del self.hunk[-1]
             del self.a[-1]
             del self.b[-1]
             self.lena -= 1
             self.lenb -= 1
         self._fixnewline(lr)
 
     def read_context_hunk(self, lr):
         self.desc = lr.readline()
         m = contextdesc.match(self.desc)
         if not m:
             raise PatchError(_("bad hunk #%d") % self.number)
         self.starta, aend = m.groups()
         self.starta = int(self.starta)
         if aend is None:
             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('---'):
                 # lines addition, old block is empty
                 lr.push(l)
                 break
             s = l[2:]
             if l.startswith('- ') or l.startswith('! '):
                 u = '-' + s
             elif l.startswith('  '):
                 u = ' ' + s
             else:
                 raise PatchError(_("bad hunk #%d old text line %d") %
                                  (self.number, x))
             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:
             raise PatchError(_("bad hunk #%d") % self.number)
         self.startb, bend = m.groups()
         self.startb = int(self.startb)
         if bend is None:
             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('\ '):
                 # 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.
                 s = self.b[-1][:-1]
                 self.b[-1] = s
                 self.hunk[hunki - 1] = s
                 continue
             if not l:
                 # line deletions, new block is empty and we hit EOF
                 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:
                 # line deletions, new block is empty
                 lr.push(l)
                 break
             else:
                 raise PatchError(_("bad hunk #%d old text line %d") %
                                  (self.number, x))
             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:
                     self.hunk.insert(hunki - 1, u)
                     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
         self._fixnewline(lr)
 
     def _fixnewline(self, lr):
         l = lr.readline()
         if l.startswith('\ '):
             diffhelpers.fix_newline(self.hunk, self.a, self.b)
         else:
             lr.push(l)
 
     def complete(self):
         return len(self.a) == self.lena and len(self.b) == self.lenb
 
     def _fuzzit(self, old, new, fuzz, toponly):
         # 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.
         fuzz = min(fuzz, len(old))
         if fuzz:
             top = 0
             bot = 0
             hlen = len(self.hunk)
             for x in xrange(hlen - 1):
                 # the hunk starts with the @@ line, so use x+1
                 if self.hunk[x + 1][0] == ' ':
                     top += 1
                 else:
                     break
             if not toponly:
                 for x in xrange(hlen - 1):
                     if self.hunk[hlen - bot - 1][0] == ' ':
                         bot += 1
                     else:
                         break
 
             bot = min(fuzz, bot)
             top = min(fuzz, 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
         newstart = self.startb + top
         # zero length hunk ranges already have their start decremented
         if self.lena and oldstart > 0:
             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
         self._read(lr)
 
     def complete(self):
         return self.text is not None
 
     def new(self, lines):
         if self.delta:
             return [applybindelta(self.text, ''.join(lines))]
         return [self.text]
 
     def _read(self, lr):
         def getline(lr, hunk):
             l = lr.readline()
             hunk.append(l)
             return l.rstrip('\r\n')
 
         size = 0
         while True:
             line = getline(lr, self.hunk)
             if not line:
                 raise PatchError(_('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())
                 self.delta = True
                 break
         dec = []
         line = getline(lr, self.hunk)
         while len(line) > 1:
             l = line[0]
             if l <= 'Z' and l >= 'A':
                 l = ord(l) - ord('A') + 1
             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')
                                  % (self._fname, str(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')
                              % (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
     a list of the form: [header1, hunk1, hunk2, header2...]. Example usage:
 
     >>> rawpatch = b"""diff --git a/folder1/g b/folder1/g
     ... --- a/folder1/g
     ... +++ b/folder1/g
     ... @@ -1,7 +1,7 @@
     ... +firstline
     ...  c
     ...  1
     ...  2
     ... + 3
     ... -4
     ...  5
     ...  d
     ... +lastline"""
     >>> hunks = parsepatch([rawpatch])
     >>> hunkscomingfromfilterpatch = []
     >>> for h in hunks:
     ...     hunkscomingfromfilterpatch.append(h)
     ...     hunkscomingfromfilterpatch.extend(h.hunks)
 
     >>> reversedhunks = reversehunks(hunkscomingfromfilterpatch)
     >>> from . import util
     >>> fp = util.stringio()
     >>> for c in reversedhunks:
     ...      c.write(fp)
     >>> fp.seek(0) or None
     >>> reversedpatch = fp.read()
     >>> print(pycompat.sysstr(reversedpatch))
     diff --git a/folder1/g b/folder1/g
     --- a/folder1/g
     +++ b/folder1/g
     @@ -1,4 +1,3 @@
     -firstline
      c
      1
      2
     @@ -2,6 +1,6 @@
      c
      1
      2
     - 3
     +4
      5
      d
     @@ -6,3 +5,2 @@
      5
      d
     -lastline
 
     '''
 
     newhunks = []
     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.
 
     >>> rawpatch = b'''diff --git a/folder1/g b/folder1/g
     ... --- 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)
     >>> print(pycompat.sysstr(out.getvalue()))
     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
     """
     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,
                         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 = []
             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()
     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' %
                                    (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.
 
     Returns (stripped components, path in repository).
 
     >>> pathtransform(b'a/b/c', 0, b'')
     ('', 'a/b/c')
     >>> pathtransform(b'   a/b/c   ', 0, b'')
     ('', '   a/b/c')
     >>> pathtransform(b'   a/b/c   ', 2, b'')
     ('a/b/', 'c')
     >>> pathtransform(b'a/b/c', 0, b'd/e/')
     ('', 'd/e/a/b/c')
     >>> pathtransform(b'   a//b/c   ', 2, b'd/e/')
     ('a//b/', 'd/e/c')
     >>> pathtransform(b'a/b/c', 3, b'')
     Traceback (most recent call last):
     PatchError: unable to strip away 1 of 3 dirs from a/b/c
     '''
     pathlen = len(path)
     i = 0
     if strip == 0:
         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") %
                              (count, strip, path))
         i += 1
         # consume '//' in the path
         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
     remove = nullb and hunk.startb == 0 and hunk.lenb == 0
     abase, afile = pathtransform(afile_orig, strip, prefix)
     gooda = not nulla and backend.exists(afile)
     bbase, bfile = pathtransform(bfile_orig, strip, prefix)
     if afile == bfile:
         goodb = gooda
     else:
         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]
     bbasedir = bfile[:bfile.rfind('/') + 1]
     if (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))
     fname = None
     if not missing:
         if gooda and goodb:
             if isbackup:
                 fname = afile
             else:
                 fname = bfile
         elif gooda:
             fname = afile
 
     if not fname:
         if not nullb:
             if isbackup:
                 fname = afile
             else:
                 fname = bfile
         elif not nulla:
             fname = afile
         else:
             raise PatchError(_("undefined source and destination files"))
 
     gp = patchmeta(fname)
     if create:
         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])
     - ('hunk',    [hunk_lines])
     - ('range',   (-start,len, +start,len, proc))
     """
     lines_re = re.compile(br'@@ -(\d+),(\d+) \+(\d+),(\d+) @@\s*(.*)')
     lr = linereader(fp)
 
     def scanwhile(first, p):
         """scan lr while predicate holds"""
         lines = [first]
         for line in iter(lr.readline, ''):
             if p(line):
                 lines.append(line)
             else:
                 lr.push(line)
                 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]
             else:
                 lr.push(fromfile)
             yield 'file', header
         elif line[0:1] == ' ':
             yield 'context', scanwhile(line, lambda l: l[0] in ' \\')
         elif line[0] in '-+':
             yield 'hunk', scanwhile(line, lambda l: l[0] in '-+\\')
         else:
             m = lines_re.match(line)
             if m:
                 yield 'range', m.groups()
             else:
                 yield 'other', line
 
 def scangitpatch(lr, firstline):
     """
     Git patches can emit:
     - rename a to b
     - change b
     - copy a to c
     - change c
 
     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:
         fp = stringio(lr.fp.read())
     gitlr = linereader(fp)
     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.
     - ("git", gitchanges): current diff is in git format, gitchanges
     maps filenames to gitpatch records. Unique event.
     """
     afile = ""
     bfile = ""
     state = None
     hunknum = 0
     emitfile = newfile = False
     gitpatches = None
 
     # our states
     BFILE = 1
     context = None
     lr = linereader(fp)
 
     for x in iter(lr.readline, ''):
         if state == BFILE and (
             (not context and x[0] == '@')
             or (context is not False and x.startswith('***************'))
             or x.startswith('GIT binary patch')):
             gp = None
             if (gitpatches and
                 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('***************'):
                     context = True
                 h = hunk(x, hunknum + 1, lr, context)
             hunknum += 1
             if emitfile:
                 emitfile = False
                 yield 'file', (afile, bfile, h, gp and gp.copy() or None)
             yield 'hunk', h
         elif x.startswith('diff --git a/'):
             m = gitre.match(x.rstrip(' \r\n'))
             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
                               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"')
                                  % afile[2:])
             gp = gitpatches[-1]
             newfile = True
         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)
 
         if newfile:
             newfile = False
             emitfile = True
             state = BFILE
             hunknum = 0
 
     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 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
 
 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,
                       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'):
     prefix = _canonprefix(backend.repo, prefix)
     def pstrip(p):
         return pathtransform(p, strip - 1, prefix)[1]
 
     rejects = 0
     err = 0
     current_file = None
 
     for state, values in iterhunks(fp):
         if state == 'hunk':
             if not current_file:
                 continue
             ret = current_file.apply(values)
             if ret > 0:
                 err = 1
         elif state == 'file':
             if current_file:
                 rejects += current_file.close()
                 current_file = None
             afile, bfile, first_hunk, gp = values
             if gp:
                 gp.path = pstrip(gp.path)
                 if gp.oldpath:
                     gp.oldpath = pstrip(gp.oldpath)
             else:
                 gp = makepatchmeta(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)
                     continue
                 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")
                                            % 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')
                         and backend.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,
                                        eolmode=eolmode)
             except PatchError as inst:
                 ui.warn(str(inst) + '\n')
                 current_file = None
                 rejects += 1
                 continue
         elif state == 'git':
             for gp in values:
                 path = pstrip(gp.oldpath)
                 data, mode = backend.getfile(path)
                 if data is None:
                     # The error ignored here will trigger a getfile()
                     # error in a place more appropriate for error
                     # handling, and will not interrupt the patching
                     # process.
                     pass
                 else:
                     store.setfile(path, data, mode)
         else:
             raise error.Abort(_('unsupported parser state: %s') % state)
 
     if current_file:
         rejects += current_file.close()
 
     if rejects:
         return -1
     return err
 
 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' % util.shellquote(cwd))
     fp = util.popen('%s %s -p%d < %s' % (patcher, ' '.join(args), strip,
                                        util.shellquote(patchname)))
     try:
         for line in util.iterfile(fp):
             line = line.rstrip()
             ui.note(line + '\n')
             if line.startswith('patching file '):
                 pf = util.parsepatchoutput(line)
                 printed_file = False
                 files.add(pf)
             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:
             scmutil.marktouched(repo, files, similarity)
     code = fp.close()
     if code:
         raise PatchError(_("patch command failed: %s") %
                          util.explainexit(code)[0])
     return fuzz
 
 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:
         raise error.Abort(_('unsupported line endings type: %s') % eolmode)
     eolmode = eolmode.lower()
 
     store = filestore()
     try:
         fp = open(patchobj, 'rb')
     except TypeError:
         fp = patchobj
     try:
         ret = applydiff(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):
     """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'):
     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):
     """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.
     """
     patcher = ui.config('ui', 'patch')
     if files is None:
         files = set()
     if patcher:
         return _externalpatch(ui, repo, patcher, patchname, strip,
                               files, 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:
         changed = set()
         for state, values in iterhunks(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,
                                                    prefix)[1]
                 else:
                     gp = makepatchmeta(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
 
 def diffallopts(ui, opts=None, untrusted=False, section='diff'):
     '''return diffopts with all features supported and parsed'''
     return difffeatureopts(ui, opts=opts, untrusted=untrusted, section=section,
                            git=True, whitespace=True, formatchanging=True)
 
 diffopts = diffallopts
 
 def difffeatureopts(ui, opts=None, untrusted=False, section='diff', git=False,
                     whitespace=False, formatchanging=False):
     '''return diffopts with only opted-in features parsed
 
     Features:
     - git: git-style diffs
     - whitespace: whitespace options like ignoreblanklines and ignorews
     - formatchanging: options that will likely break or cause correctness issues
       with most diff parsers
     '''
     def get(key, name=None, getter=ui.configbool, forceplain=None):
         if opts:
             v = opts.get(key)
             # 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):
                 return v
         if forceplain is not None and ui.plain():
             return forceplain
         return getter(section, name or key, untrusted=untrusted)
 
     # core options, expected to be understood by every diff parser
     buildopts = {
         'nodates': get('nodates'),
         'showfunc': get('show_function', 'showfunc'),
         'context': get('unified', getter=ui.config),
     }
+    buildopts['worddiff'] = ui.configbool('experimental', 'worddiff')
 
     if git:
         buildopts['git'] = get('git')
 
         # since this is in the experimental section, we need to call
         # ui.configbool directory
         buildopts['showsimilarity'] = ui.configbool('experimental',
                                                     'extendedheader.similarity')
 
         # 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)
                 if hlen < 0 or hlen > 40:
                     msg = _("invalid length for extendedheader.index: '%d'\n")
                     ui.warn(msg % hlen)
             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
 
     if whitespace:
         buildopts['ignorews'] = get('ignore_all_space', 'ignorews')
         buildopts['ignorewsamount'] = get('ignore_space_change',
                                           'ignorewsamount')
         buildopts['ignoreblanklines'] = get('ignore_blank_lines',
                                             'ignoreblanklines')
         buildopts['ignorewseol'] = get('ignore_space_at_eol', 'ignorewseol')
     if formatchanging:
         buildopts['text'] = opts and opts.get('text')
         binary = None if opts is None else opts.get('binary')
         buildopts['nobinary'] = (not binary if binary is not None
                                  else get('nobinary', forceplain=False))
         buildopts['noprefix'] = get('noprefix', forceplain=False)
 
     return mdiff.diffopts(**pycompat.strkwargs(buildopts))
 
 def diff(repo, node1=None, node2=None, match=None, changes=None,
          opts=None, losedatafn=None, prefix='', relroot='', copy=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.
 
     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.
 
     prefix is a filename prefix that is prepended to all filenames on
     display (used for subrepos).
 
     relroot, if not empty, must be normalized with a trailing /. Any match
     patterns that fall outside it will be ignored.
 
     copy, if not empty, should contain mappings {dst@y: src@x} of copy
     information.
 
     hunksfilterfn, if not None, should be a function taking a filectx and
     hunks generator that may yield filtered hunks.
     '''
     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,
     ):
         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
             # cmdutil.getloglinerangerevs() for 'hg log -L'.
             assert 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, 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.
     """
 
     if opts is None:
         opts = mdiff.defaultopts
 
     if not node1 and not node2:
         node1 = repo.dirstate.p1()
 
     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()
 
     ctx1 = repo[node1]
     ctx2 = repo[node2]
 
     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
 
     if not changes:
         changes = repo.status(ctx1, ctx2, match=match)
     modified, added, removed = changes[:3]
 
     if not modified and not added and not removed:
         return []
 
     if repo.ui.debugflag:
         hexfunc = hex
     else:
         hexfunc = short
     revs = [hexfunc(node) for node in [ctx1.node(), ctx2.node()] if node]
 
     if copy is None:
         copy = {}
         if opts.git or opts.upgrade:
             copy = copies.pathcopies(ctx1, ctx2, match=match)
 
     if relroot is not None:
         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
         # 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)))
 
     modifiedset = set(modified)
     addedset = set(added)
     removedset = set(removed)
     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)
     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)
     modified = sorted(modifiedset)
     added = sorted(addedset)
     removed = sorted(removedset)
     for dst, src in copy.items():
         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]
 
     def difffn(opts, losedata):
         return trydiff(repo, revs, ctx1, ctx2, modified, added, removed,
                        copy, getfilectx, opts, losedata, prefix, relroot)
     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 difflabel(func, *args, **kw):
     '''yields 2-tuples of (output, label) based on the output of func()'''
+    inlinecolor = False
+    if kw.get('opts'):
+        inlinecolor = kw['opts'].worddiff
     headprefixes = [('diff', 'diff.diffline'),
                     ('copy', 'diff.extended'),
                     ('rename', 'diff.extended'),
                     ('old', 'diff.extended'),
                     ('new', 'diff.extended'),
                     ('deleted', 'diff.extended'),
                     ('index', 'diff.extended'),
                     ('similarity', 'diff.extended'),
                     ('---', 'diff.file_a'),
                     ('+++', 'diff.file_b')]
     textprefixes = [('@', 'diff.hunk'),
                     ('-', 'diff.deleted'),
                     ('+', 'diff.inserted')]
     head = False
     for chunk in func(*args, **kw):
         lines = chunk.split('\n')
+        matches = {}
+        if inlinecolor:
+            matches = _findmatches(lines)
         for i, line in enumerate(lines):
             if i != 0:
                 yield ('\n', '')
             if head:
                 if line.startswith('@'):
                     head = False
             else:
                 if line and line[0] not in ' +-@\\':
                     head = True
             stripline = line
             diffline = False
             if not head and line and line[0] in '+-':
                 # highlight tabs and trailing whitespace, but only in
                 # changed lines
                 stripline = line.rstrip()
                 diffline = True
 
             prefixes = textprefixes
             if head:
                 prefixes = headprefixes
             for prefix, label in prefixes:
                 if stripline.startswith(prefix):
                     if diffline:
                         for token in tabsplitter.findall(stripline):
                             if '\t' == token[0]:
                                 yield (token, 'diff.tab')
                             else:
-                                yield (token, label)
+                                if i in matches:
+                                    for l, t in _inlinediff(
+                                                  lines[i].rstrip(),
+                                                  lines[matches[i]].rstrip(),
+                                                  label):
+                                        yield (t, l)
+                                else:
+                                    yield (token, label)
                     else:
                         yield (stripline, label)
                     break
             else:
                 yield (line, '')
             if line != stripline:
                 yield (line[len(stripline):], 'diff.trailingwhitespace')
 
+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
+        if line[0] == '-':
+            lastmatch = max(lastmatch, i)
+            newgroup = False
+            for j, newline in enumerate(slist[lastmatch + 1:]):
+                if newline == '':
+                    continue
+                if newline[0] == '-' and newgroup: # too far, no match
+                    break
+                if newline[0] == '+': # potential match
+                    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.'''
+    operation_skip = '+?' if operation == 'diff.deleted' else '-?'
+    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:]
+
+    s = difflib.ndiff(re.split(br'(\W)', s2), re.split(br'(\W)', s1))
+    for part in s:
+        if part[0] in operation_skip:
+            continue
+        l = operation + '.highlight'
+        if part[0] in ' ':
+            l = operation
+        if l == label: # contiguous token with same label
+            token += part[2:]
+            continue
+        else:
+            buff.append((label, token))
+            label = l
+            token = part[2:]
+    buff.append((label, token))
+
+    return buff
+
 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'
     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
 
 def trydiff(repo, revs, ctx1, ctx2, modified, added, removed,
             copy, getfilectx, opts, losedatafn, prefix, relroot):
     '''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.
 
     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.'''
 
     def gitindex(text):
         if not text:
             text = ""
         l = len(text)
         s = hashlib.sha1('blob %d\0' % l)
         s.update(text)
         return s.hexdigest()
 
     if opts.noprefix:
         aprefix = bprefix = ''
     else:
         aprefix = 'a/'
         bprefix = 'b/'
 
     def diffline(f, revs):
         revinfo = ' '.join(["-r %s" % rev for rev in revs])
         return 'diff %s %s' % (revinfo, f)
 
     def isempty(fctx):
         return fctx is None or fctx.size() == 0
 
     date1 = util.datestr(ctx1.date())
     date2 = util.datestr(ctx2.date())
 
     gitmode = {'l': '120000', 'x': '100755', '': '100644'}
 
     if relroot != '' and (repo.ui.configbool('devel', 'all-warnings')
                           or repo.ui.configbool('devel', 'check-relroot')):
         for f in modified + added + removed + list(copy) + list(copy.values()):
             if f is not None and not f.startswith(relroot):
                 raise AssertionError(
                     "file %s doesn't start with relroot %s" % (f, relroot))
 
     for f1, f2, copyop in _filepairs(modified, added, removed, copy, opts):
         content1 = None
         content2 = None
         fctx1 = None
         fctx2 = None
         flag1 = None
         flag2 = None
         if f1:
             fctx1 = getfilectx(f1, ctx1)
             if opts.git or losedatafn:
                 flag1 = ctx1.flags(f1)
         if f2:
             fctx2 = getfilectx(f2, ctx2)
             if opts.git or losedatafn:
                 flag2 = ctx2.flags(f2)
         # if binary is True, output "summary" or "base85", but not "text diff"
         binary = not opts.text and any(f.isbinary()
                                        for f in [fctx1, fctx2] if f is not None)
 
         if losedatafn and not opts.git:
             if (binary or
                 # copy/rename
                 f2 in copy or
                 # empty file creation
                 (not f1 and isempty(fctx2)) or
                 # empty file deletion
                 (isempty(fctx1) and not f2) or
                 # create with flags
                 (not f1 and flag2) or
                 # change flags
                 (f1 and f2 and flag1 != flag2)):
                 losedatafn(f2 or f1)
 
         path1 = f1 or f2
         path2 = f2 or f1
         path1 = posixpath.join(prefix, path1[len(relroot):])
         path2 = posixpath.join(prefix, path2[len(relroot):])
         header = []
         if opts.git:
             header.append('diff --git %s%s %s%s' %
                           (aprefix, path1, bprefix, path2))
             if not f1: # added
                 header.append('new file mode %s' % gitmode[flag2])
             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)
                     header.append('new mode %s' % mode2)
                 if copyop is not None:
                     if opts.showsimilarity:
                         sim = similar.score(ctx1[path1], ctx2[path2]) * 100
                         header.append('similarity index %d%%' % sim)
                     header.append('%s from %s' % (copyop, path1))
                     header.append('%s to %s' % (copyop, path2))
         elif revs and not repo.ui.quiet:
             header.append(diffline(path1, revs))
 
         #  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
         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()
 
         if binary and opts.git and not opts.nobinary:
             text = mdiff.b85diff(content1, content2)
             if text:
                 header.append('index %s..%s' %
                               (gitindex(content1), gitindex(content2)))
             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' %
                               (gitindex(content1)[0:opts.index],
                                gitindex(content2)[0:opts.index],
                                gitmode[flag]))
 
             uheaders, hunks = mdiff.unidiff(content1, date1,
                                             content2, date2,
                                             path1, path2, 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))
         maxtotal = max(maxtotal, a + r)
         addtotal += a
         removetotal += r
         binary = binary or b
 
     return maxfile, maxtotal, addtotal, removetotal, binary
 
 def diffstatdata(lines):
     diffre = re.compile('^diff .*-r [a-z0-9]+\s(.*)$')
 
     results = []
     filename, adds, removes, isbinary = None, 0, 0, False
 
     def addresult():
         if filename:
             results.append((filename, adds, removes, isbinary))
 
     # 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
 
     for line in lines:
         if line.startswith('diff'):
             addresult()
             # starting a new file diff
             # set numbers to 0 and reset inheader
             inheader = True
             adds, removes, isbinary = 0, 0, False
             if line.startswith('diff --git a/'):
                 filename = gitre.search(line).group(2)
             elif line.startswith('diff -r'):
                 # format: "diff -r ... -r ... filename"
                 filename = diffre.search(line).group(1)
         elif line.startswith('@@'):
             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
               line.startswith('Binary file')):
             isbinary = True
     addresult()
     return results
 
 def diffstat(lines, width=80):
     output = []
     stats = diffstatdata(lines)
     maxname, maxtotal, totaladds, totalremoves, hasbinary = diffstatsum(stats)
 
     countwidth = len(str(maxtotal))
     if hasbinary and countwidth < 3:
         countwidth = 3
     graphwidth = width - countwidth - maxname - 6
     if graphwidth < 10:
         graphwidth = 10
 
     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)))
 
     for filename, adds, removes, isbinary in stats:
         if isbinary:
             count = 'Bin'
         else:
             count = '%d' % (adds + removes)
         pluses = '+' * scale(adds)
         minuses = '-' * scale(removes)
         output.append(' %s%s |  %*s %s%s\n' %
                       (filename, ' ' * (maxname - encoding.colwidth(filename)),
                        countwidth, count, pluses, minuses))
 
     if stats:
         output.append(_(' %d files changed, %d insertions(+), '
                         '%d deletions(-)\n')
                       % (len(stats), totaladds, totalremoves))
 
     return ''.join(output)
 
 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 + ' ', '')
             m = re.search(br'\++', graph)
             if m:
                 yield (m.group(0), 'diffstat.inserted')
             m = re.search(br'-+', graph)
             if m:
                 yield (m.group(0), 'diffstat.deleted')
         else:
             yield (line, '')
         yield ('\n', '')

tests/test-diff-color.t

@@ -1,261 +1,353 b''
 Setup
 
   $ cat <<EOF >> $HGRCPATH
   > [ui]
   > color = yes
   > formatted = always
   > paginate = never
   > [color]
   > mode = ansi
   > EOF
   $ hg init repo
   $ cd repo
   $ cat > a <<EOF
   > c
   > c
   > a
   > a
   > b
   > a
   > a
   > c
   > c
   > EOF
   $ hg ci -Am adda
   adding a
   $ cat > a <<EOF
   > c
   > c
   > a
   > a
   > dd
   > a
   > a
   > c
   > c
   > EOF
 
 default context
 
   $ hg diff --nodates
   \x1b[0;1mdiff -r cf9f4ba66af2 a\x1b[0m (esc)
   \x1b[0;31;1m--- a/a\x1b[0m (esc)
   \x1b[0;32;1m+++ b/a\x1b[0m (esc)
   \x1b[0;35m@@ -2,7 +2,7 @@\x1b[0m (esc)
    c
    a
    a
   \x1b[0;31m-b\x1b[0m (esc)
   \x1b[0;32m+dd\x1b[0m (esc)
    a
    a
    c
 
 (check that 'ui.color=yes' match '--color=auto')
 
   $ hg diff --nodates --config ui.formatted=no
   diff -r cf9f4ba66af2 a
   --- a/a
   +++ b/a
   @@ -2,7 +2,7 @@
    c
    a
    a
   -b
   +dd
    a
    a
    c
 
 (check that 'ui.color=no' disable color)
 
   $ hg diff --nodates --config ui.formatted=yes --config ui.color=no
   diff -r cf9f4ba66af2 a
   --- a/a
   +++ b/a
   @@ -2,7 +2,7 @@
    c
    a
    a
   -b
   +dd
    a
    a
    c
 
 (check that 'ui.color=always' force color)
 
   $ hg diff --nodates --config ui.formatted=no --config ui.color=always
   \x1b[0;1mdiff -r cf9f4ba66af2 a\x1b[0m (esc)
   \x1b[0;31;1m--- a/a\x1b[0m (esc)
   \x1b[0;32;1m+++ b/a\x1b[0m (esc)
   \x1b[0;35m@@ -2,7 +2,7 @@\x1b[0m (esc)
    c
    a
    a
   \x1b[0;31m-b\x1b[0m (esc)
   \x1b[0;32m+dd\x1b[0m (esc)
    a
    a
    c
 
 --unified=2
 
   $ hg diff --nodates -U 2
   \x1b[0;1mdiff -r cf9f4ba66af2 a\x1b[0m (esc)
   \x1b[0;31;1m--- a/a\x1b[0m (esc)
   \x1b[0;32;1m+++ b/a\x1b[0m (esc)
   \x1b[0;35m@@ -3,5 +3,5 @@\x1b[0m (esc)
    a
    a
   \x1b[0;31m-b\x1b[0m (esc)
   \x1b[0;32m+dd\x1b[0m (esc)
    a
    a
 
 diffstat
 
   $ hg diff --stat
    a |  2 \x1b[0;32m+\x1b[0m\x1b[0;31m-\x1b[0m (esc)
    1 files changed, 1 insertions(+), 1 deletions(-)
   $ cat <<EOF >> $HGRCPATH
   > [extensions]
   > record =
   > [ui]
   > interactive = true
   > [diff]
   > git = True
   > EOF
 
 #if execbit
 
 record
 
   $ chmod +x a
   $ hg record -m moda a <<EOF
   > y
   > y
   > EOF
   \x1b[0;1mdiff --git a/a b/a\x1b[0m (esc)
   \x1b[0;36;1mold mode 100644\x1b[0m (esc)
   \x1b[0;36;1mnew mode 100755\x1b[0m (esc)
   1 hunks, 1 lines changed
   \x1b[0;33mexamine changes to 'a'? [Ynesfdaq?]\x1b[0m y (esc)
   
   \x1b[0;35m@@ -2,7 +2,7 @@ c\x1b[0m (esc)
    c
    a
    a
   \x1b[0;31m-b\x1b[0m (esc)
   \x1b[0;32m+dd\x1b[0m (esc)
    a
    a
    c
   \x1b[0;33mrecord this change to 'a'? [Ynesfdaq?]\x1b[0m y (esc)
   
 
   $ echo "[extensions]" >> $HGRCPATH
   $ echo "mq=" >> $HGRCPATH
   $ hg rollback
   repository tip rolled back to revision 0 (undo commit)
   working directory now based on revision 0
 
 qrecord
 
   $ hg qrecord -m moda patch <<EOF
   > y
   > y
   > EOF
   \x1b[0;1mdiff --git a/a b/a\x1b[0m (esc)
   \x1b[0;36;1mold mode 100644\x1b[0m (esc)
   \x1b[0;36;1mnew mode 100755\x1b[0m (esc)
   1 hunks, 1 lines changed
   \x1b[0;33mexamine changes to 'a'? [Ynesfdaq?]\x1b[0m y (esc)
   
   \x1b[0;35m@@ -2,7 +2,7 @@ c\x1b[0m (esc)
    c
    a
    a
   \x1b[0;31m-b\x1b[0m (esc)
   \x1b[0;32m+dd\x1b[0m (esc)
    a
    a
    c
   \x1b[0;33mrecord this change to 'a'? [Ynesfdaq?]\x1b[0m y (esc)
   
 
   $ hg qpop -a
   popping patch
   patch queue now empty
 
 #endif
 
 issue3712: test colorization of subrepo diff
 
   $ hg init sub
   $ echo b > sub/b
   $ hg -R sub commit -Am 'create sub'
   adding b
   $ echo 'sub = sub' > .hgsub
   $ hg add .hgsub
   $ hg commit -m 'add subrepo sub'
   $ echo aa >> a
   $ echo bb >> sub/b
 
   $ hg diff -S
   \x1b[0;1mdiff --git a/a b/a\x1b[0m (esc)
   \x1b[0;31;1m--- a/a\x1b[0m (esc)
   \x1b[0;32;1m+++ b/a\x1b[0m (esc)
   \x1b[0;35m@@ -7,3 +7,4 @@\x1b[0m (esc)
    a
    c
    c
   \x1b[0;32m+aa\x1b[0m (esc)
   \x1b[0;1mdiff --git a/sub/b b/sub/b\x1b[0m (esc)
   \x1b[0;31;1m--- a/sub/b\x1b[0m (esc)
   \x1b[0;32;1m+++ b/sub/b\x1b[0m (esc)
   \x1b[0;35m@@ -1,1 +1,2 @@\x1b[0m (esc)
    b
   \x1b[0;32m+bb\x1b[0m (esc)
 
 test tabs
 
   $ cat >> a <<EOF
   > 	one tab
   > 		two tabs
   > end tab	
   > mid	tab
   > 	all		tabs	
   > EOF
   $ hg diff --nodates
   \x1b[0;1mdiff --git a/a b/a\x1b[0m (esc)
   \x1b[0;31;1m--- a/a\x1b[0m (esc)
   \x1b[0;32;1m+++ b/a\x1b[0m (esc)
   \x1b[0;35m@@ -7,3 +7,9 @@\x1b[0m (esc)
    a
    c
    c
   \x1b[0;32m+aa\x1b[0m (esc)
   \x1b[0;32m+\x1b[0m	\x1b[0;32mone tab\x1b[0m (esc)
   \x1b[0;32m+\x1b[0m		\x1b[0;32mtwo tabs\x1b[0m (esc)
   \x1b[0;32m+end tab\x1b[0m\x1b[0;1;41m	\x1b[0m (esc)
   \x1b[0;32m+mid\x1b[0m	\x1b[0;32mtab\x1b[0m (esc)
   \x1b[0;32m+\x1b[0m	\x1b[0;32mall\x1b[0m		\x1b[0;32mtabs\x1b[0m\x1b[0;1;41m	\x1b[0m (esc)
   $ echo "[color]" >> $HGRCPATH
   $ echo "diff.tab = bold magenta" >> $HGRCPATH
   $ hg diff --nodates
   \x1b[0;1mdiff --git a/a b/a\x1b[0m (esc)
   \x1b[0;31;1m--- a/a\x1b[0m (esc)
   \x1b[0;32;1m+++ b/a\x1b[0m (esc)
   \x1b[0;35m@@ -7,3 +7,9 @@\x1b[0m (esc)
    a
    c
    c
   \x1b[0;32m+aa\x1b[0m (esc)
   \x1b[0;32m+\x1b[0m\x1b[0;1;35m	\x1b[0m\x1b[0;32mone tab\x1b[0m (esc)
   \x1b[0;32m+\x1b[0m\x1b[0;1;35m		\x1b[0m\x1b[0;32mtwo tabs\x1b[0m (esc)
   \x1b[0;32m+end tab\x1b[0m\x1b[0;1;41m	\x1b[0m (esc)
   \x1b[0;32m+mid\x1b[0m\x1b[0;1;35m	\x1b[0m\x1b[0;32mtab\x1b[0m (esc)
   \x1b[0;32m+\x1b[0m\x1b[0;1;35m	\x1b[0m\x1b[0;32mall\x1b[0m\x1b[0;1;35m		\x1b[0m\x1b[0;32mtabs\x1b[0m\x1b[0;1;41m	\x1b[0m (esc)
 
   $ cd ..
+
+test inline color diff
+
+  $ hg init inline
+  $ cd inline
+  $ cat > file1 << EOF
+  > this is the first line
+  > this is the second line
+  >     third line starts with space
+  > + starts with a plus sign
+  > 
+  > this line won't change
+  > 
+  > two lines are going to
+  > be changed into three!
+  > 
+  > three of those lines will
+  > collapse onto one
+  > (to see if it works)
+  > EOF
+  $ hg add file1
+  $ hg ci -m 'commit'
+  $ cat > file1 << EOF
+  > that is the first paragraph
+  >     this is the second line
+  > third line starts with space
+  > - starts with a minus sign
+  > 
+  > this line won't change
+  > 
+  > two lines are going to
+  > (entirely magically,
+  >  assuming this works)
+  > be changed into four!
+  > 
+  > three of those lines have
+  > collapsed onto one
+  > EOF
+  $ hg diff --config experimental.worddiff=False --color=debug
+  [diff.diffline|diff --git a/file1 b/file1]
+  [diff.file_a|--- a/file1]
+  [diff.file_b|+++ b/file1]
+  [diff.hunk|@@ -1,13 +1,14 @@]
+  [diff.deleted|-this is the first line]
+  [diff.deleted|-this is the second line]
+  [diff.deleted|-    third line starts with space]
+  [diff.deleted|-+ starts with a plus sign]
+  [diff.inserted|+that is the first paragraph]
+  [diff.inserted|+    this is the second line]
+  [diff.inserted|+third line starts with space]
+  [diff.inserted|+- starts with a minus sign]
+   
+   this line won't change
+   
+   two lines are going to
+  [diff.deleted|-be changed into three!]
+  [diff.inserted|+(entirely magically,]
+  [diff.inserted|+ assuming this works)]
+  [diff.inserted|+be changed into four!]
+   
+  [diff.deleted|-three of those lines will]
+  [diff.deleted|-collapse onto one]
+  [diff.deleted|-(to see if it works)]
+  [diff.inserted|+three of those lines have]
+  [diff.inserted|+collapsed onto one]
+  $ hg diff --config experimental.worddiff=True --color=debug
+  [diff.diffline|diff --git a/file1 b/file1]
+  [diff.file_a|--- a/file1]
+  [diff.file_b|+++ b/file1]
+  [diff.hunk|@@ -1,13 +1,14 @@]
+  [diff.deleted|-this is the ][diff.deleted.highlight|first][diff.deleted| line]
+  [diff.deleted|-this is the second line]
+  [diff.deleted|-][diff.deleted.highlight|    ][diff.deleted|third line starts with space]
+  [diff.deleted|-][diff.deleted.highlight|+][diff.deleted| starts with a ][diff.deleted.highlight|plus][diff.deleted| sign]
+  [diff.inserted|+that is the first paragraph]
+  [diff.inserted|+][diff.inserted.highlight|    ][diff.inserted|this is the ][diff.inserted.highlight|second][diff.inserted| line]
+  [diff.inserted|+third line starts with space]
+  [diff.inserted|+][diff.inserted.highlight|-][diff.inserted| starts with a ][diff.inserted.highlight|minus][diff.inserted| sign]
+   
+   this line won't change
+   
+   two lines are going to
+  [diff.deleted|-be changed into ][diff.deleted.highlight|three][diff.deleted|!]
+  [diff.inserted|+(entirely magically,]
+  [diff.inserted|+ assuming this works)]
+  [diff.inserted|+be changed into ][diff.inserted.highlight|four][diff.inserted|!]
+   
+  [diff.deleted|-three of those lines ][diff.deleted.highlight|will]
+  [diff.deleted|-][diff.deleted.highlight|collapse][diff.deleted| onto one]
+  [diff.deleted|-(to see if it works)]
+  [diff.inserted|+three of those lines ][diff.inserted.highlight|have]
+  [diff.inserted|+][diff.inserted.highlight|collapsed][diff.inserted| onto one]