formatter: remove experimental marker from -T option

I think it's good enough to stabilize the feature, at least for the core
and non-experimental commands.

mercurial/cmdutil.py

@@ -1,3313 +1,3312 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 os
 import re
 
 from .i18n import _
 from .node import (
     hex,
     nullid,
     nullrev,
     short,
 )
 
 from . import (
     bookmarks,
     changelog,
     copies,
     crecord as crecordmod,
     dirstateguard,
     encoding,
     error,
     formatter,
     logcmdutil,
     match as matchmod,
     merge as mergemod,
     mergeutil,
     obsolete,
     patch,
     pathutil,
     phases,
     pycompat,
     revlog,
     rewriteutil,
     scmutil,
     smartset,
     subrepoutil,
     templatekw,
     templater,
     util,
     vfs as vfsmod,
 )
 
 from .utils import (
     dateutil,
     stringutil,
 )
 
 stringio = util.stringio
 
 # templates of common command options
 
 dryrunopts = [
     ('n', 'dry-run', None,
      _('do not perform actions, just print output')),
 ]
 
 confirmopts = [
     ('', 'confirm', None,
      _('ask before applying actions')),
 ]
 
 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')),
+     _('display with template'), _('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(r'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):
     try:
         if usecurses:
             if testfile:
                 recordfn = crecordmod.testdecorator(
                     testfile, crecordmod.testchunkselector)
             else:
                 recordfn = crecordmod.chunkselector
 
             return crecordmod.filterpatch(ui, originalhunks, recordfn,
                                           operation)
     except crecordmod.fallbackerror as e:
         ui.warn('%s\n' % e.message)
         ui.warn(_('falling back to text mode\n'))
 
     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):
     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 = pycompat.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(pycompat.bytestr(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, **pycompat.strkwargs(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, without a trailing '/'
 
     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 = pathutil.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, pathutil.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).  dirpath will end in '/'.
 
         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 + '/'
                 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):
     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, encoding.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 _graftmsg():
     # tweakdefaults requires `update` to have a rev hence the `.`
     return _helpmessage('hg graft --continue', 'hg graft --abort')
 
 def _mergemsg():
     # tweakdefaults requires `update` to have a rev hence the `.`
     return _helpmessage('hg commit', 'hg merge --abort')
 
 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('shelvedstate'), _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:
         state, statedetectionpredicate, helpfulmsg = statetuple
         statemsg = _('The repository is in an unfinished *%s* state.') % state
         fm.plain('%s\n' % _commentlines(statemsg), label=label)
         conmsg = _conflictsmsg(repo)
         if conmsg:
             fm.plain('%s\n' % conmsg, label=label)
         if helpfulmsg:
             helpmsg = helpfulmsg()
             fm.plain('%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 changebranch(ui, repo, revs, label):
     """ Change the branch name of given revs to label """
 
     with repo.wlock(), repo.lock(), repo.transaction('branches'):
         # abort in case of uncommitted merge or dirty wdir
         bailifchanged(repo)
         revs = scmutil.revrange(repo, revs)
         if not revs:
             raise error.Abort("empty revision set")
         roots = repo.revs('roots(%ld)', revs)
         if len(roots) > 1:
             raise error.Abort(_("cannot change branch of non-linear revisions"))
         rewriteutil.precheck(repo, revs, 'change branch of')
 
         root = repo[roots.first()]
         if not root.p1().branch() == label and label in repo.branchmap():
             raise error.Abort(_("a branch of the same name already exists"))
 
         if repo.revs('merge() and %ld', revs):
             raise error.Abort(_("cannot change branch of a merge commit"))
         if repo.revs('obsolete() and %ld', revs):
             raise error.Abort(_("cannot change branch of a obsolete changeset"))
 
         # make sure only topological heads
         if repo.revs('heads(%ld) - head()', revs):
             raise error.Abort(_("cannot change branch in middle of a stack"))
 
         replacements = {}
         # avoid import cycle mercurial.cmdutil -> mercurial.context ->
         # mercurial.subrepo -> mercurial.cmdutil
         from . import context
         for rev in revs:
             ctx = repo[rev]
             oldbranch = ctx.branch()
             # check if ctx has same branch
             if oldbranch == label:
                 continue
 
             def filectxfn(repo, newctx, path):
                 try:
                     return ctx[path]
                 except error.ManifestLookupError:
                     return None
 
             ui.debug("changing branch of '%s' from '%s' to '%s'\n"
                      % (hex(ctx.node()), oldbranch, label))
             extra = ctx.extra()
             extra['branch_change'] = hex(ctx.node())
             # While changing branch of set of linear commits, make sure that
             # we base our commits on new parent rather than old parent which
             # was obsoleted while changing the branch
             p1 = ctx.p1().node()
             p2 = ctx.p2().node()
             if p1 in replacements:
                 p1 = replacements[p1][0]
             if p2 in replacements:
                 p2 = replacements[p2][0]
 
             mc = context.memctx(repo, (p1, p2),
                                 ctx.description(),
                                 ctx.files(),
                                 filectxfn,
                                 user=ctx.user(),
                                 date=ctx.date(),
                                 extra=extra,
                                 branch=label)
 
             newnode = repo.commitctx(mc)
             replacements[ctx.node()] = (newnode,)
             ui.debug('new node id is %s\n' % hex(newnode))
 
         # create obsmarkers and move bookmarks
         scmutil.cleanupnodes(repo, replacements, 'branch-change', fixphase=True)
 
         # move the working copy too
         wctx = repo[None]
         # in-progress merge is a bit too complex for now.
         if len(wctx.parents()) == 1:
             newid = replacements.get(wctx.p1().node())
             if newid is not None:
                 # avoid import cycle mercurial.cmdutil -> mercurial.hg ->
                 # mercurial.cmdutil
                 from . import hg
                 hg.update(repo, newid[0], quietempty=True)
 
         ui.status(_("changed branch on %d changesets\n") % len(replacements))
 
 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 _escapecommandtemplate(tmpl):
     parts = []
     for typ, start, end in templater.scantemplate(tmpl, raw=True):
         if typ == b'string':
             parts.append(stringutil.escapestr(tmpl[start:end]))
         else:
             parts.append(tmpl[start:end])
     return b''.join(parts)
 
 def rendercommandtemplate(ui, tmpl, props):
     r"""Expand a literal template 'tmpl' in a way suitable for command line
 
     '\' in outermost string is not taken as an escape character because it
     is a directory separator on Windows.
 
     >>> from . import ui as uimod
     >>> ui = uimod.ui()
     >>> rendercommandtemplate(ui, b'c:\\{path}', {b'path': b'foo'})
     'c:\\foo'
     >>> rendercommandtemplate(ui, b'{"c:\\{path}"}', {'path': b'foo'})
     'c:{path}'
     """
     if not tmpl:
         return tmpl
     t = formatter.maketemplater(ui, _escapecommandtemplate(tmpl))
     return t.renderdefault(props)
 
 def rendertemplate(ctx, tmpl, props=None):
     """Expand a literal template 'tmpl' byte-string against one changeset
 
     Each props item must be a stringify-able value or a callable returning
     such value, i.e. no bare list nor dict should be passed.
     """
     repo = ctx.repo()
     tres = formatter.templateresources(repo.ui, repo)
     t = formatter.maketemplater(repo.ui, tmpl, defaults=templatekw.keywords,
                                 resources=tres)
     mapping = {'ctx': ctx}
     if props:
         mapping.update(props)
     return t.renderdefault(mapping)
 
 def _buildfntemplate(pat, total=None, seqno=None, revwidth=None, pathname=None):
     r"""Convert old-style filename format string to template string
 
     >>> _buildfntemplate(b'foo-%b-%n.patch', seqno=0)
     'foo-{reporoot|basename}-{seqno}.patch'
     >>> _buildfntemplate(b'%R{tags % "{tag}"}%H')
     '{rev}{tags % "{tag}"}{node}'
 
     '\' in outermost strings has to be escaped because it is a directory
     separator on Windows:
 
     >>> _buildfntemplate(b'c:\\tmp\\%R\\%n.patch', seqno=0)
     'c:\\\\tmp\\\\{rev}\\\\{seqno}.patch'
     >>> _buildfntemplate(b'\\\\foo\\bar.patch')
     '\\\\\\\\foo\\\\bar.patch'
     >>> _buildfntemplate(b'\\{tags % "{tag}"}')
     '\\\\{tags % "{tag}"}'
 
     but inner strings follow the template rules (i.e. '\' is taken as an
     escape character):
 
     >>> _buildfntemplate(br'{"c:\tmp"}', seqno=0)
     '{"c:\\tmp"}'
     """
     expander = {
         b'H': b'{node}',
         b'R': b'{rev}',
         b'h': b'{node|short}',
         b'm': br'{sub(r"[^\w]", "_", desc|firstline)}',
         b'r': b'{if(revwidth, pad(rev, revwidth, "0", left=True), rev)}',
         b'%': b'%',
         b'b': b'{reporoot|basename}',
     }
     if total is not None:
         expander[b'N'] = b'{total}'
     if seqno is not None:
         expander[b'n'] = b'{seqno}'
     if total is not None and seqno is not None:
         expander[b'n'] = b'{pad(seqno, total|stringify|count, "0", left=True)}'
     if pathname is not None:
         expander[b's'] = b'{pathname|basename}'
         expander[b'd'] = b'{if(pathname|dirname, pathname|dirname, ".")}'
         expander[b'p'] = b'{pathname}'
 
     newname = []
     for typ, start, end in templater.scantemplate(pat, raw=True):
         if typ != b'string':
             newname.append(pat[start:end])
             continue
         i = start
         while i < end:
             n = pat.find(b'%', i, end)
             if n < 0:
                 newname.append(stringutil.escapestr(pat[i:end]))
                 break
             newname.append(stringutil.escapestr(pat[i:n]))
             if n + 2 > end:
                 raise error.Abort(_("incomplete format spec in output "
                                     "filename"))
             c = pat[n + 1:n + 2]
             i = n + 2
             try:
                 newname.append(expander[c])
             except KeyError:
                 raise error.Abort(_("invalid format spec '%%%s' in output "
                                     "filename") % c)
     return ''.join(newname)
 
 def makefilename(ctx, pat, **props):
     if not pat:
         return pat
     tmpl = _buildfntemplate(pat, **props)
     # BUG: alias expansion shouldn't be made against template fragments
     # rewritten from %-format strings, but we have no easy way to partially
     # disable the expansion.
     return rendertemplate(ctx, tmpl, pycompat.byteskwargs(props))
 
 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(ctx, pat, mode='wb', **props):
     writable = mode not in ('r', 'rb')
 
     if isstdiofilename(pat):
         repo = ctx.repo()
         if writable:
             fp = repo.ui.fout
         else:
             fp = repo.ui.fin
         return _unclosablefile(fp)
     fn = makefilename(ctx, pat, **props)
     return open(fn, mode)
 
 def openstorage(repo, cmd, file_, opts, returnrevlog=False):
     """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"))
             if not dir.endswith('/'):
                 dir = dir + '/'
             dirlog = repo.manifestlog.getstorage(dir)
             if len(dirlog):
                 r = dirlog
         elif mf:
             r = repo.manifestlog.getstorage(b'')
         elif file_:
             filelog = repo.file(file_)
             if len(filelog):
                 r = filelog
 
         # Not all storage may be revlogs. If requested, try to return an actual
         # revlog instance.
         if returnrevlog:
             if isinstance(r, revlog.revlog):
                 pass
             elif util.safehasattr(r, '_revlog'):
                 r = r._revlog
             elif r is not None:
                 raise error.Abort(_('%r does not appear to be a revlog') % r)
 
     if not r:
         if not returnrevlog:
             raise error.Abort(_('cannot give path to non-revlog'))
 
         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(encoding.getcwd(), audit=False),
                           file_[:-2] + ".i")
     return r
 
 def openrevlog(repo, cmd, file_, opts):
     """Obtain a revlog backing storage of an item.
 
     This is similar to ``openstorage()`` except it always returns a revlog.
 
     In most cases, a caller cares about the main storage object - not the
     revlog backing it. Therefore, this function should only be used by code
     that needs to examine low-level revlog implementation details. e.g. debug
     commands.
     """
     return openstorage(repo, cmd, file_, opts, returnrevlog=True)
 
 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 True # report a failure
 
         # 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 True # report a failure
                 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 True # report a failure
 
         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 True # report a failure
         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:
                     # Preserve stat info on renames, not on copies; this matches
                     # Linux CLI behavior.
                     util.copyfile(src, target, copystat=rename)
                 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)))
                     if rename:
                         hint = _("('hg rename --after' to record the rename)\n")
                     else:
                         hint = _("('hg copy --after' to record the copy)\n")
                     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:
                 rmdir = repo.ui.configbool('experimental', 'removeemptydirs')
                 repo.wvfs.unlinkpath(abssrc, rmdir=rmdir)
             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
 
     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, patchdata, 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.
 
     :patchdata: a dictionary containing parsed patch data (such as from
                 ``patch.extract()``)
     :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
 
     tmpname = patchdata.get('filename')
     message = patchdata.get('message')
     user = opts.get('user') or patchdata.get('user')
     date = opts.get('date') or patchdata.get('date')
     branch = patchdata.get('branch')
     nodeid = patchdata.get('nodeid')
     p1 = patchdata.get('p1')
     p2 = patchdata.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
 
     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 or ''))
 
     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(pycompat.bytestr(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,
                                          **pycompat.strkwargs(opts))
             extra = {}
             for idfunc in extrapreimport:
                 extrapreimportmap[idfunc](repo, patchdata, 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(stringutil.forcebytestr(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 (not n or 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
 
 # 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, fm, match, switch_parent, seqno, 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
 
     fm.context(ctx=ctx)
     fm.plain('# HG changeset patch\n')
     fm.write('user', '# User %s\n', ctx.user())
     fm.plain('# Date %d %d\n' % ctx.date())
     fm.write('date', '#      %s\n', fm.formatdate(ctx.date()))
     fm.condwrite(branch and branch != 'default',
                  'branch', '# Branch %s\n', branch)
     fm.write('node', '# Node ID %s\n', hex(node))
     fm.plain('# Parent  %s\n' % hex(prev))
     if len(parents) > 1:
         fm.plain('# Parent  %s\n' % hex(parents[1]))
     fm.data(parents=fm.formatlist(pycompat.maplist(hex, parents), name='node'))
 
     # TODO: redesign extraexportmap function to support formatter
     for headerid in extraexport:
         header = extraexportmap[headerid](seqno, ctx)
         if header is not None:
             fm.plain('# %s\n' % header)
 
     fm.write('desc', '%s\n', ctx.description().rstrip())
     fm.plain('\n')
 
     if fm.isplain():
         chunkiter = patch.diffui(repo, prev, node, match, opts=diffopts)
         for chunk, label in chunkiter:
             fm.plain(chunk, label=label)
     else:
         chunkiter = patch.diff(repo, prev, node, match, opts=diffopts)
         # TODO: make it structured?
         fm.data(diff=b''.join(chunkiter))
 
 def _exportfile(repo, revs, fm, dest, switch_parent, diffopts, match):
     """Export changesets to stdout or a single file"""
     for seqno, rev in enumerate(revs, 1):
         ctx = repo[rev]
         if not dest.startswith('<'):
             repo.ui.note("%s\n" % dest)
         fm.startitem()
         _exportsingle(repo, ctx, fm, match, switch_parent, seqno, diffopts)
 
 def _exportfntemplate(repo, revs, basefm, fntemplate, switch_parent, diffopts,
                       match):
     """Export changesets to possibly multiple files"""
     total = len(revs)
     revwidth = max(len(str(rev)) for rev in revs)
     filemap = util.sortdict()  # filename: [(seqno, rev), ...]
 
     for seqno, rev in enumerate(revs, 1):
         ctx = repo[rev]
         dest = makefilename(ctx, fntemplate,
                             total=total, seqno=seqno, revwidth=revwidth)
         filemap.setdefault(dest, []).append((seqno, rev))
 
     for dest in filemap:
         with formatter.maybereopen(basefm, dest) as fm:
             repo.ui.note("%s\n" % dest)
             for seqno, rev in filemap[dest]:
                 fm.startitem()
                 ctx = repo[rev]
                 _exportsingle(repo, ctx, fm, match, switch_parent, seqno,
                               diffopts)
 
 def export(repo, revs, basefm, fntemplate='hg-%h.patch', 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.
       basefm: A formatter to which patches should be written.
       fntemplate: An optional string to use for generating patch file names.
       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:
         fntemplate specified: Each rev is written to a unique file named using
                             the given template.
         Otherwise: All revs will be written to basefm.
     '''
     scmutil.prefetchfiles(repo, revs, match)
 
     if not fntemplate:
         _exportfile(repo, revs, basefm, '<unnamed>', switch_parent, opts, match)
     else:
         _exportfntemplate(repo, revs, basefm, fntemplate, switch_parent, opts,
                           match)
 
 def exportfile(repo, revs, fp, switch_parent=False, opts=None, match=None):
     """Export changesets to the given file stream"""
     scmutil.prefetchfiles(repo, revs, match)
 
     dest = getattr(fp, 'name', '<unnamed>')
     with formatter.formatter(repo.ui, fp, 'export', {}) as fm:
         _exportfile(repo, revs, fm, dest, switch_parent, opts, match)
 
 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)
     smeta = pycompat.rapply(pycompat.maybebytestr, meta)
     fm.write('metadata', '{%s}', fm.formatdict(smeta, fmt='%r: %r', sep=', '))
     fm.plain('\n')
 
 def finddate(ui, repo, date):
     """Find the tipmost changeset that matches the given date spec"""
 
     df = dateutil.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, dateutil.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
 
 def _walkrevs(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
 
 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 pycompat.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.'''
 
     allfiles = opts.get('all_files')
     follow = opts.get('follow') or opts.get('follow_first')
     revs = _walkrevs(repo, opts)
     if not revs:
         return []
     wanted = set()
     slowpath = match.anypats() or (not match.always() and opts.get('removed'))
     fncache = {}
     change = repo.__getitem__
 
     # 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() or allfiles:
         # 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 = [f for f in ctx.files() if match(f)]
                     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 pycompat.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 pycompat.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():
                         if allfiles:
                             fiter = iter(ctx)
                         else:
                             fiter = ctx.files()
                         for f in fiter:
                             if match(f):
                                 yield f
                     fns = fns_generator()
                 prepare(ctx, fns)
             for rev in nrevs:
                 yield change(rev)
 
             if stopiteration:
                 break
 
     return iterate()
 
 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),
                           label='addremove.added')
 
     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, dryrun, interactive):
     if dryrun and interactive:
         raise error.Abort(_("cannot specify both --dry-run and --interactive"))
     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, dryrun=dryrun,
                                            interactive=interactive)
             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)
 
     if interactive:
         responses = _('[Ynsa?]'
                       '$$ &Yes, forget this file'
                       '$$ &No, skip this file'
                       '$$ &Skip remaining files'
                       '$$ Include &all remaining files'
                       '$$ &? (display help)')
         for filename in forget[:]:
             r = ui.promptchoice(_('forget %s %s') % (filename, responses))
             if r == 4: # ?
                 while r == 4:
                     for c, t in ui.extractchoices(responses)[1]:
                         ui.write('%s - %s\n' % (c, encoding.lower(t)))
                     r = ui.promptchoice(_('forget %s %s') % (filename,
                                                                  responses))
             if r == 0: # yes
                 continue
             elif r == 1: # no
                 forget.remove(filename)
             elif r == 2: # Skip
                 fnindex = forget.index(filename)
                 del forget[fnindex:]
                 break
             elif r == 3: # All
                 break
 
     for f in forget:
         if ui.verbose or not match.exact(f) or interactive:
             ui.status(_('removing %s\n') % match.rel(f),
                       label='addremove.removed')
 
     if not dryrun:
         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):
     ret = 1
 
     needsfctx = ui.verbose or {'size', 'flags'} & fm.datahint()
     for f in ctx.matches(m):
         fm.startitem()
         fm.context(ctx=ctx)
         if needsfctx:
             fc = ctx[f]
             fm.write('size flags', '% 10d % 1s ', fc.size(), fc.flags())
         fm.data(path=f)
         fm.plain(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, dryrun, 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)
     progress = ui.makeprogress(_('searching'), total=len(subs),
                                unit=_('subrepos'))
     for subpath in subs:
         submatch = matchmod.subdirmatcher(subpath, m)
         if subrepos or m.exact(subpath) or any(submatch.files()):
             progress.increment()
             sub = wctx.sub(subpath)
             try:
                 if sub.removefiles(submatch, prefix, after, force, subrepos,
                                    dryrun, warnings):
                     ret = 1
             except error.LookupError:
                 warnings.append(_("skipping missing subrepository: %s\n")
                                % join(subpath))
     progress.complete()
 
     # warn about failure to delete explicit files/dirs
     deleteddirs = util.dirs(deleted)
     files = m.files()
     progress = ui.makeprogress(_('deleting'), total=len(files),
                                unit=_('files'))
     for f in files:
         def insubrepo():
             for subpath in wctx.substate:
                 if f.startswith(subpath + '/'):
                     return True
             return False
 
         progress.increment()
         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
     progress.complete()
 
     if force:
         list = modified + deleted + clean + added
     elif after:
         list = deleted
         remaining = modified + added + clean
         progress = ui.makeprogress(_('skipping'), total=len(remaining),
                                    unit=_('files'))
         for f in remaining:
             progress.increment()
             if ui.verbose or (f in files):
                 warnings.append(_('not removing %s: file still exists\n')
                                 % m.rel(f))
             ret = 1
         progress.complete()
     else:
         list = deleted + clean
         progress = ui.makeprogress(_('skipping'),
                                    total=(len(modified) + len(added)),
                                    unit=_('files'))
         for f in modified:
             progress.increment()
             warnings.append(_('not removing %s: file is modified (use -f'
                       ' to force removal)\n') % m.rel(f))
             ret = 1
         for f in added:
             progress.increment()
             warnings.append(_("not removing %s: file has been marked for add"
                       " (use 'hg forget' to undo add)\n") % m.rel(f))
             ret = 1
         progress.complete()
 
     list = sorted(list)
     progress = ui.makeprogress(_('deleting'), total=len(list),
                                unit=_('files'))
     for f in list:
         if ui.verbose or not m.exact(f):
             progress.increment()
             ui.status(_('removing %s\n') % m.rel(f),
                       label='addremove.removed')
     progress.complete()
 
     if not dryrun:
         with repo.wlock():
             if not after:
                 for f in list:
                     if f in added:
                         continue # we never unlink added files on remove
                     rmdir = repo.ui.configbool('experimental',
                                                'removeemptydirs')
                     repo.wvfs.unlinkpath(f, ignoremissing=True, rmdir=rmdir)
             repo[None].forget(list)
 
     if warn:
         for warning in warnings:
             ui.warn(warning)
 
     return ret
 
 def _updatecatformatter(fm, ctx, matcher, path, decode):
     """Hook for adding data to the formatter used by ``hg cat``.
 
     Extensions (e.g., lfs) can wrap this to inject keywords/data, but must call
     this method first."""
     data = ctx[path].data()
     if decode:
         data = ctx.repo().wwritedata(path, data)
     fm.startitem()
     fm.context(ctx=ctx)
     fm.write('data', '%s', data)
     fm.data(path=path)
 
 def cat(ui, repo, ctx, matcher, basefm, fntemplate, prefix, **opts):
     err = 1
     opts = pycompat.byteskwargs(opts)
 
     def write(path):
         filename = None
         if fntemplate:
             filename = makefilename(ctx, fntemplate,
                                     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) as fm:
             _updatecatformatter(fm, ctx, matcher, path, opts.get('decode'))
 
     # 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]:
                 scmutil.prefetchfiles(repo, [ctx.rev()], matcher)
                 write(file)
                 return 0
         except KeyError:
             pass
 
     scmutil.prefetchfiles(repo, [ctx.rev()], matcher)
 
     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),
                            **pycompat.strkwargs(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'] = dateutil.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 = dateutil.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 base.status(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:
             subs, commitsubs, newsubstate = subrepoutil.precommit(
                 ui, wctx, wctx._status, matcher)
             # amend should abort if commitsubrepos is enabled
             assert not commitsubs
             if subs:
                 subrepoutil.writestate(repo, newsubstate)
 
         ms = mergemod.mergestate.read(repo)
         mergeutil.checkunresolved(ms)
 
         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, ctx_,
                                               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()
 
         commitphase = None
         if opts.get('secret'):
             commitphase = phases.secret
         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': encoding.fromlocal(opts['note'])}
         backup = ui.configbool('ui', 'history-editing-backup')
         scmutil.cleanupnodes(repo, mapping, 'amend', metadata=obsmetadata,
                              fixphase=True, targetphase=commitphase,
                              backup=backup)
 
         # 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 = encoding.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 = logcmdutil.changesettemplater(ui, repo, spec)
     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.rev())
 
     if repo.ui.debugflag:
         repo.ui.write(_('committed changeset %d:%s\n') % (ctx.rev(), ctx.hex()))
     elif repo.ui.verbose:
         repo.ui.write(_('committed changeset %d:%s\n') % (ctx.rev(), 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:
     #   <abs 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 opts.get('dry_run'):
                         if ui.verbose or not exact:
                             ui.status(msg % rel)
                 elif exact:
                     ui.warn(msg % rel)
                 break
 
         if not opts.get('dry_run'):
             needdata = ('revert', 'add', 'undelete')
             oplist = [actions[name][0] for name in needdata]
             prefetch = scmutil.prefetchfiles
             matchfiles = scmutil.matchfiles
             prefetch(repo, [ctx.rev()],
                      matchfiles(repo,
                                 [f for sublist in oplist for f in sublist]))
             _performrevert(repo, parents, ctx, names, 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 _performrevert(repo, parents, ctx, names, 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 = []
 
     def checkout(f):
         fc = ctx[f]
         repo.wwrite(f, fc.data(), fc.flags())
 
     def doremove(f):
         try:
             rmdir = repo.ui.configbool('experimental', 'removeemptydirs')
             repo.wvfs.unlinkpath(f, rmdir=rmdir)
         except OSError:
             pass
         repo.dirstate.remove(f)
 
     def prntstatusmsg(action, f):
         rel, exact = names[f]
         if repo.ui.verbose or not exact:
             repo.ui.status(actions[action][1] % rel)
 
     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:
                 prntstatusmsg('forget', f)
                 repo.dirstate.drop(f)
             else:
                 excluded_files.append(f)
         else:
             prntstatusmsg('forget', f)
             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:
                 prntstatusmsg('remove', f)
                 doremove(f)
             else:
                 excluded_files.append(f)
         else:
             prntstatusmsg('remove', f)
             doremove(f)
     for f in actions['drop'][0]:
         audit_path(f)
         prntstatusmsg('drop', 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 = [f for f in actions['revert'][0] if f not in excluded_files]
         m = scmutil.matchfiles(repo, torevert)
         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()
         # chunks are serialized per file, but files aren't sorted
         for f in sorted(set(c.header.filename() for c in chunks if ishunk(c))):
             prntstatusmsg('revert', f)
         for c in chunks:
             if ishunk(c):
                 abs = c.header.filename()
                 # Create a backup file only if this hunk should be backed up
                 if c.header.filename() in tobackup:
                     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(pycompat.bytestr(err))
         del fp
     else:
         for f in actions['revert'][0]:
             prntstatusmsg('revert', f)
             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:
             prntstatusmsg('add', f)
             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]:
         prntstatusmsg('undelete', f)
         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)
 
 # 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 graft --stop' to stop")),
     ('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().
     '''
     # Check for non-clearable states first, so things like rebase will take
     # precedence over update.
     for f, clearable, allowcommit, msg, hint in unfinishedstates:
         if clearable or (commit and allowcommit):
             continue
         if repo.vfs.exists(f):
             raise error.Abort(msg, hint=hint)
 
     for f, clearable, allowcommit, msg, hint in unfinishedstates:
         if not clearable or (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)

tests/test-alias.t

@@ -1,717 +1,718 b''
   $ HGFOO=BAR; export HGFOO
   $ cat >> $HGRCPATH <<EOF
   > [alias]
   > # should clobber ci but not commit (issue2993)
   > ci = version
   > myinit = init
   > myinit:doc = This is my documented alias for init.
   > myinit:help = [OPTIONS] [BLA] [BLE]
   > mycommit = commit
   > mycommit:doc = This is my alias with only doc.
   > optionalrepo = showconfig alias.myinit
   > cleanstatus = status -c
   > cleanstatus:help = [ONLYHELPHERE]
   > unknown = bargle
   > ambiguous = s
   > recursive = recursive
   > disabled = email
   > nodefinition =
   > noclosingquotation = '
   > no--cwd = status --cwd elsewhere
   > no-R = status -R elsewhere
   > no--repo = status --repo elsewhere
   > no--repository = status --repository elsewhere
   > no--config = status --config a.config=1
   > mylog = log
   > lognull = log -r null
   > lognull:doc = Logs the null rev
   > lognull:help = foo bar baz
   > shortlog = log --template '{rev} {node|short} | {date|isodate}\n'
   > positional = log --template '{\$2} {\$1} | {date|isodate}\n'
   > dln = lognull --debug
   > recursivedoc = dln
   > recursivedoc:doc = Logs the null rev in debug mode
   > nousage = rollback
   > put = export -r 0 -o "\$FOO/%R.diff"
   > blank = !printf '\n'
   > self = !printf '\$0\n'
   > echoall = !printf '\$@\n'
   > echo1 = !printf '\$1\n'
   > echo2 = !printf '\$2\n'
   > echo13 = !printf '\$1 \$3\n'
   > echotokens = !printf "%s\n" "\$@"
   > count = !hg log -r "\$@" --template=. | wc -c | sed -e 's/ //g'
   > mcount = !hg log \$@ --template=. | wc -c | sed -e 's/ //g'
   > rt = root
   > tglog = log -G --template "{rev}:{node|short}: '{desc}' {branches}\n"
   > idalias = id
   > idaliaslong = id
   > idaliasshell = !echo test
   > parentsshell1 = !echo one
   > parentsshell2 = !echo two
   > escaped1 = !printf 'test\$\$test\n'
   > escaped2 = !sh -c 'echo "HGFOO is \$\$HGFOO"'
   > escaped3 = !sh -c 'echo "\$1 is \$\$\$1"'
   > escaped4 = !printf '\$\$0 \$\$@\n'
   > exit1 = !sh -c 'exit 1'
   > 
   > [defaults]
   > mylog = -q
   > lognull = -q
   > log = -v
   > EOF
 
 basic
 
   $ hg myinit alias
 
 help
 
   $ hg help -c | grep myinit
    myinit             This is my documented alias for init.
   $ hg help -c | grep mycommit
    mycommit           This is my alias with only doc.
   $ hg help -c | grep cleanstatus
    cleanstatus        show changed files in the working directory
   $ hg help -c | grep lognull
    lognull            Logs the null rev
   $ hg help -c | grep dln
    dln                Logs the null rev
   $ hg help -c | grep recursivedoc
    recursivedoc       Logs the null rev in debug mode
   $ hg help myinit
   hg myinit [OPTIONS] [BLA] [BLE]
   
   alias for: hg init
   
   This is my documented alias for init.
   
   defined by: * (glob)
   */* (glob) (?)
   */* (glob) (?)
   */* (glob) (?)
   
   options:
   
    -e --ssh CMD       specify ssh command to use
       --remotecmd CMD specify hg command to run on the remote side
       --insecure      do not verify server certificate (ignoring web.cacerts
                       config)
   
   (some details hidden, use --verbose to show complete help)
 
   $ hg help mycommit
   hg mycommit [OPTION]... [FILE]...
   
   alias for: hg commit
   
   This is my alias with only doc.
   
   defined by: * (glob)
   */* (glob) (?)
   */* (glob) (?)
   */* (glob) (?)
   
   options ([+] can be repeated):
   
    -A --addremove           mark new/missing files as added/removed before
                             committing
       --close-branch        mark a branch head as closed
       --amend               amend the parent of the working directory
    -s --secret              use the secret phase for committing
    -e --edit                invoke editor on commit messages
    -i --interactive         use interactive mode
    -I --include PATTERN [+] include names matching the given patterns
    -X --exclude PATTERN [+] exclude names matching the given patterns
    -m --message TEXT        use text as commit message
    -l --logfile FILE        read commit message from file
    -d --date DATE           record the specified date as commit date
    -u --user USER           record the specified user as committer
    -S --subrepos            recurse into subrepositories
   
   (some details hidden, use --verbose to show complete help)
 
   $ hg help cleanstatus
   hg cleanstatus [ONLYHELPHERE]
   
   alias for: hg status -c
   
   show changed files in the working directory
   
       Show status of files in the repository. If names are given, only files
       that match are shown. Files that are clean or ignored or the source of a
       copy/move operation, are not listed unless -c/--clean, -i/--ignored,
       -C/--copies or -A/--all are given. Unless options described with "show
       only ..." are given, the options -mardu are used.
   
       Option -q/--quiet hides untracked (unknown and ignored) files unless
       explicitly requested with -u/--unknown or -i/--ignored.
   
       Note:
          'hg status' may appear to disagree with diff if permissions have
          changed or a merge has occurred. The standard diff format does not
          report permission changes and diff only reports changes relative to one
          merge parent.
   
       If one revision is given, it is used as the base revision. If two
       revisions are given, the differences between them are shown. The --change
       option can also be used as a shortcut to list the changed files of a
       revision from its first parent.
   
       The codes used to show the status of files are:
   
         M = modified
         A = added
         R = removed
         C = clean
         ! = missing (deleted by non-hg command, but still tracked)
         ? = not tracked
         I = ignored
           = origin of the previous file (with --copies)
   
       Returns 0 on success.
   
   defined by: * (glob)
   */* (glob) (?)
   */* (glob) (?)
   */* (glob) (?)
   
   options ([+] can be repeated):
   
    -A --all                 show status of all files
    -m --modified            show only modified files
    -a --added               show only added files
    -r --removed             show only removed files
    -d --deleted             show only deleted (but tracked) files
    -c --clean               show only files without changes
    -u --unknown             show only unknown (not tracked) files
    -i --ignored             show only ignored files
    -n --no-status           hide status prefix
    -C --copies              show source of copied files
    -0 --print0              end filenames with NUL, for use with xargs
       --rev REV [+]         show difference from revision
       --change REV          list the changed files of a revision
    -I --include PATTERN [+] include names matching the given patterns
    -X --exclude PATTERN [+] exclude names matching the given patterns
    -S --subrepos            recurse into subrepositories
+   -T --template TEMPLATE   display with template
   
   (some details hidden, use --verbose to show complete help)
 
   $ hg help recursivedoc | head -n 5
   hg recursivedoc foo bar baz
   
   alias for: hg dln
   
   Logs the null rev in debug mode
 
 unknown
 
   $ hg unknown
   abort: alias 'unknown' resolves to unknown command 'bargle'
   [255]
   $ hg help unknown
   alias 'unknown' resolves to unknown command 'bargle'
 
 
 ambiguous
 
   $ hg ambiguous
   abort: alias 'ambiguous' resolves to ambiguous command 's'
   [255]
   $ hg help ambiguous
   alias 'ambiguous' resolves to ambiguous command 's'
 
 
 recursive
 
   $ hg recursive
   abort: alias 'recursive' resolves to unknown command 'recursive'
   [255]
   $ hg help recursive
   alias 'recursive' resolves to unknown command 'recursive'
 
 
 disabled
 
   $ hg disabled
   abort: alias 'disabled' resolves to unknown command 'email'
   ('email' is provided by 'patchbomb' extension)
   [255]
   $ hg help disabled
   alias 'disabled' resolves to unknown command 'email'
   
   'email' is provided by the following extension:
   
       patchbomb     command to send changesets as (a series of) patch emails
   
   (use 'hg help extensions' for information on enabling extensions)
 
 
 no definition
 
   $ hg nodef
   abort: no definition for alias 'nodefinition'
   [255]
   $ hg help nodef
   no definition for alias 'nodefinition'
 
 
 no closing quotation
 
   $ hg noclosing
   abort: error in definition for alias 'noclosingquotation': No closing quotation
   [255]
   $ hg help noclosing
   error in definition for alias 'noclosingquotation': No closing quotation
 
 "--" in alias definition should be preserved
 
   $ hg --config alias.dash='cat --' -R alias dash -r0
   abort: -r0 not under root '$TESTTMP/alias'
   (consider using '--cwd alias')
   [255]
 
 invalid options
 
   $ hg no--cwd
   abort: error in definition for alias 'no--cwd': --cwd may only be given on the command line
   [255]
   $ hg help no--cwd
   error in definition for alias 'no--cwd': --cwd may only be given on the
   command line
   $ hg no-R
   abort: error in definition for alias 'no-R': -R may only be given on the command line
   [255]
   $ hg help no-R
   error in definition for alias 'no-R': -R may only be given on the command line
   $ hg no--repo
   abort: error in definition for alias 'no--repo': --repo may only be given on the command line
   [255]
   $ hg help no--repo
   error in definition for alias 'no--repo': --repo may only be given on the
   command line
   $ hg no--repository
   abort: error in definition for alias 'no--repository': --repository may only be given on the command line
   [255]
   $ hg help no--repository
   error in definition for alias 'no--repository': --repository may only be given
   on the command line
   $ hg no--config
   abort: error in definition for alias 'no--config': --config may only be given on the command line
   [255]
   $ hg no --config alias.no='--repo elsewhere --cwd elsewhere status'
   abort: error in definition for alias 'no': --repo/--cwd may only be given on the command line
   [255]
   $ hg no --config alias.no='--repo elsewhere'
   abort: error in definition for alias 'no': --repo may only be given on the command line
   [255]
 
 optional repository
 
 #if no-outer-repo
   $ hg optionalrepo
   init
 #endif
   $ cd alias
   $ cat > .hg/hgrc <<EOF
   > [alias]
   > myinit = init -q
   > EOF
   $ hg optionalrepo
   init -q
 
 no usage
 
   $ hg nousage
   no rollback information available
   [1]
 
   $ echo foo > foo
   $ hg commit -Amfoo
   adding foo
 
 infer repository
 
   $ cd ..
 
 #if no-outer-repo
   $ hg shortlog alias/foo
   0 e63c23eaa88a | 1970-01-01 00:00 +0000
 #endif
 
   $ cd alias
 
 with opts
 
   $ hg cleanst
   C foo
 
 
 with opts and whitespace
 
   $ hg shortlog
   0 e63c23eaa88a | 1970-01-01 00:00 +0000
 
 positional arguments
 
   $ hg positional
   abort: too few arguments for command alias
   [255]
   $ hg positional a
   abort: too few arguments for command alias
   [255]
   $ hg positional 'node|short' rev
   0 e63c23eaa88a | 1970-01-01 00:00 +0000
 
 interaction with defaults
 
   $ hg mylog
   0:e63c23eaa88a
   $ hg lognull
   -1:000000000000
 
 
 properly recursive
 
   $ hg dln
   changeset:   -1:0000000000000000000000000000000000000000
   phase:       public
   parent:      -1:0000000000000000000000000000000000000000
   parent:      -1:0000000000000000000000000000000000000000
   manifest:    -1:0000000000000000000000000000000000000000
   user:        
   date:        Thu Jan 01 00:00:00 1970 +0000
   extra:       branch=default
   
 
 
 path expanding
 
   $ FOO=`pwd` hg put
   $ cat 0.diff
   # HG changeset patch
   # User test
   # Date 0 0
   #      Thu Jan 01 00:00:00 1970 +0000
   # Node ID e63c23eaa88ae77967edcf4ea194d31167c478b0
   # Parent  0000000000000000000000000000000000000000
   foo
   
   diff -r 000000000000 -r e63c23eaa88a foo
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/foo	Thu Jan 01 00:00:00 1970 +0000
   @@ -0,0 +1,1 @@
   +foo
 
 
 simple shell aliases
 
   $ hg blank
   
   $ hg blank foo
   
   $ hg self
   self
   $ hg echoall
   
   $ hg echoall foo
   foo
   $ hg echoall 'test $2' foo
   test $2 foo
   $ hg echoall 'test $@' foo '$@'
   test $@ foo $@
   $ hg echoall 'test "$@"' foo '"$@"'
   test "$@" foo "$@"
   $ hg echo1 foo bar baz
   foo
   $ hg echo2 foo bar baz
   bar
   $ hg echo13 foo bar baz test
   foo baz
   $ hg echo2 foo
   
   $ hg echotokens
   
   $ hg echotokens foo 'bar $1 baz'
   foo
   bar $1 baz
   $ hg echotokens 'test $2' foo
   test $2
   foo
   $ hg echotokens 'test $@' foo '$@'
   test $@
   foo
   $@
   $ hg echotokens 'test "$@"' foo '"$@"'
   test "$@"
   foo
   "$@"
   $ echo bar > bar
   $ hg commit -qA -m bar
   $ hg count .
   1
   $ hg count 'branch(default)'
   2
   $ hg mcount -r '"branch(default)"'
   2
 
   $ hg tglog
   @  1:042423737847: 'bar'
   |
   o  0:e63c23eaa88a: 'foo'
   
 
 
 shadowing
 
   $ hg i
   hg: command 'i' is ambiguous:
       idalias idaliaslong idaliasshell identify import incoming init
   [255]
   $ hg id
   042423737847 tip
   $ hg ida
   hg: command 'ida' is ambiguous:
       idalias idaliaslong idaliasshell
   [255]
   $ hg idalias
   042423737847 tip
   $ hg idaliasl
   042423737847 tip
   $ hg idaliass
   test
   $ hg parentsshell
   hg: command 'parentsshell' is ambiguous:
       parentsshell1 parentsshell2
   [255]
   $ hg parentsshell1
   one
   $ hg parentsshell2
   two
 
 
 shell aliases with global options
 
   $ hg init sub
   $ cd sub
   $ hg count 'branch(default)'
   abort: unknown revision 'default'!
   0
   $ hg -v count 'branch(default)'
   abort: unknown revision 'default'!
   0
   $ hg -R .. count 'branch(default)'
   abort: unknown revision 'default'!
   0
   $ hg --cwd .. count 'branch(default)'
   2
   $ hg echoall --cwd ..
   
 
 "--" passed to shell alias should be preserved
 
   $ hg --config alias.printf='!printf "$@"' printf '%s %s %s\n' -- --cwd ..
   -- --cwd ..
 
 repo specific shell aliases
 
   $ cat >> .hg/hgrc <<EOF
   > [alias]
   > subalias = !echo sub
   > EOF
   $ cat >> ../.hg/hgrc <<EOF
   > [alias]
   > mainalias = !echo main
   > EOF
 
 
 shell alias defined in current repo
 
   $ hg subalias
   sub
   $ hg --cwd .. subalias > /dev/null
   hg: unknown command 'subalias'
   (did you mean idalias?)
   [255]
   $ hg -R .. subalias > /dev/null
   hg: unknown command 'subalias'
   (did you mean idalias?)
   [255]
 
 
 shell alias defined in other repo
 
   $ hg mainalias > /dev/null
   hg: unknown command 'mainalias'
   (did you mean idalias?)
   [255]
   $ hg -R .. mainalias
   main
   $ hg --cwd .. mainalias
   main
 
 typos get useful suggestions
   $ hg --cwd .. manalias
   hg: unknown command 'manalias'
   (did you mean one of idalias, mainalias, manifest?)
   [255]
 
 shell aliases with escaped $ chars
 
   $ hg escaped1
   test$test
   $ hg escaped2
   HGFOO is BAR
   $ hg escaped3 HGFOO
   HGFOO is BAR
   $ hg escaped4 test
   $0 $@
 
 abbreviated name, which matches against both shell alias and the
 command provided extension, should be aborted.
 
   $ cat >> .hg/hgrc <<EOF
   > [extensions]
   > hgext.rebase =
   > EOF
 #if windows
   $ cat >> .hg/hgrc <<EOF
   > [alias]
   > rebate = !echo this is %HG_ARGS%
   > EOF
 #else
   $ cat >> .hg/hgrc <<EOF
   > [alias]
   > rebate = !echo this is \$HG_ARGS
   > EOF
 #endif
   $ cat >> .hg/hgrc <<EOF
   > rebate:doc = This is my alias which just prints something.
   > rebate:help = [MYARGS]
   > EOF
   $ hg reba
   hg: command 'reba' is ambiguous:
       rebase rebate
   [255]
   $ hg rebat
   this is rebate
   $ hg rebat --foo-bar
   this is rebate --foo-bar
 
 help for a shell alias
 
   $ hg help -c | grep rebate
    rebate             This is my alias which just prints something.
   $ hg help rebate
   hg rebate [MYARGS]
   
   shell alias for: echo this is %HG_ARGS% (windows !)
   shell alias for: echo this is $HG_ARGS (no-windows !)
   
   This is my alias which just prints something.
   
   defined by:* (glob)
   */* (glob) (?)
   */* (glob) (?)
   */* (glob) (?)
   
   (some details hidden, use --verbose to show complete help)
 
 invalid character in user-specified help
 
   >>> with open('.hg/hgrc', 'ab') as f:
   ...     f.write(b'[alias]\n'
   ...             b'invaliddoc = log\n'
   ...             b'invaliddoc:doc = \xc0\n'
   ...             b'invalidhelp = log\n'
   ...             b'invalidhelp:help = \xc0\n') and None
   $ hg help invaliddoc
   non-ASCII character in alias definition 'invaliddoc:doc'
   $ hg help invalidhelp
   non-ASCII character in alias definition 'invalidhelp:help'
   $ hg invaliddoc
   abort: non-ASCII character in alias definition 'invaliddoc:doc'
   [255]
   $ hg invalidhelp
   abort: non-ASCII character in alias definition 'invalidhelp:help'
   [255]
 
 invalid arguments
 
   $ hg rt foo
   hg rt: invalid arguments
   hg rt
   
   alias for: hg root
   
   (use 'hg rt -h' to show more help)
   [255]
 
 invalid global arguments for normal commands, aliases, and shell aliases
 
   $ hg --invalid root
   hg: option --invalid not recognized
   (use 'hg help -v' for a list of global options)
   [255]
   $ hg --invalid mylog
   hg: option --invalid not recognized
   (use 'hg help -v' for a list of global options)
   [255]
   $ hg --invalid blank
   hg: option --invalid not recognized
   (use 'hg help -v' for a list of global options)
   [255]
 
 environment variable changes in alias commands
 
   $ cat > $TESTTMP/expandalias.py <<EOF
   > import os
   > from mercurial import cmdutil, commands, registrar
   > cmdtable = {}
   > command = registrar.command(cmdtable)
   > @command(b'expandalias')
   > def expandalias(ui, repo, name):
   >     alias = cmdutil.findcmd(name, commands.table)[1][0]
   >     ui.write(b'%s args: %s\n' % (name, b' '.join(alias.args)))
   >     os.environ['COUNT'] = '2'
   >     ui.write(b'%s args: %s (with COUNT=2)\n' % (name, b' '.join(alias.args)))
   > EOF
 
   $ cat >> $HGRCPATH <<'EOF'
   > [extensions]
   > expandalias = $TESTTMP/expandalias.py
   > [alias]
   > showcount = log -T "$COUNT" -r .
   > EOF
 
   $ COUNT=1 hg expandalias showcount
   showcount args: -T 1 -r .
   showcount args: -T 2 -r . (with COUNT=2)
 
 This should show id:
 
   $ hg --config alias.log='id' log
   000000000000 tip
 
 This shouldn't:
 
   $ hg --config alias.log='id' history
 
   $ cd ../..
 
 return code of command and shell aliases:
 
   $ hg mycommit -R alias
   nothing changed
   [1]
   $ hg exit1
   [1]
 
 #if no-outer-repo
   $ hg root
   abort: no repository found in '$TESTTMP' (.hg not found)!
   [255]
   $ hg --config alias.hgroot='!hg root' hgroot
   abort: no repository found in '$TESTTMP' (.hg not found)!
   [255]
 #endif

tests/test-dispatch.t

@@ -1,219 +1,220 b''
 test command parsing and dispatch
 
   $ hg init a
   $ cd a
 
 Redundant options used to crash (issue436):
   $ hg -v log -v
   $ hg -v log -v x
 
   $ echo a > a
   $ hg ci -Ama
   adding a
 
 Missing arg:
 
   $ hg cat
   hg cat: invalid arguments
   hg cat [OPTION]... FILE...
   
   output the current or given revision of files
   
   options ([+] can be repeated):
   
    -o --output FORMAT       print output to file with formatted name
    -r --rev REV             print the given revision
       --decode              apply any matching decode filter
    -I --include PATTERN [+] include names matching the given patterns
    -X --exclude PATTERN [+] exclude names matching the given patterns
+   -T --template TEMPLATE   display with template
   
   (use 'hg cat -h' to show more help)
   [255]
 
 Missing parameter for early option:
 
   $ hg log -R 2>&1 | grep 'hg log'
   hg log: option -R requires argument
   hg log [OPTION]... [FILE]
   (use 'hg log -h' to show more help)
 
 "--" may be an option value:
 
   $ hg -R -- log
   abort: repository -- not found!
   [255]
   $ hg log -R --
   abort: repository -- not found!
   [255]
   $ hg log -T --
   -- (no-eol)
   $ hg log -T -- -k nomatch
 
 Parsing of early options should stop at "--":
 
   $ hg cat -- --config=hooks.pre-cat=false
   --config=hooks.pre-cat=false: no such file in rev cb9a9f314b8b
   [1]
   $ hg cat -- --debugger
   --debugger: no such file in rev cb9a9f314b8b
   [1]
 
 Unparsable form of early options:
 
   $ hg cat --debugg
   abort: option --debugger may not be abbreviated!
   [255]
 
 Parsing failure of early options should be detected before executing the
 command:
 
   $ hg log -b '--config=hooks.pre-log=false' default
   abort: option --config may not be abbreviated!
   [255]
   $ hg log -b -R. default
   abort: option -R has to be separated from other options (e.g. not -qR) and --repository may only be abbreviated as --repo!
   [255]
   $ hg log --cwd .. -b --cwd=. default
   abort: option --cwd may not be abbreviated!
   [255]
 
 However, we can't prevent it from loading extensions and configs:
 
   $ cat <<EOF > bad.py
   > raise Exception('bad')
   > EOF
   $ hg log -b '--config=extensions.bad=bad.py' default
   *** failed to import extension bad from bad.py: bad
   abort: option --config may not be abbreviated!
   [255]
 
   $ mkdir -p badrepo/.hg
   $ echo 'invalid-syntax' > badrepo/.hg/hgrc
   $ hg log -b -Rbadrepo default
   hg: parse error at badrepo/.hg/hgrc:1: invalid-syntax
   [255]
 
   $ hg log -b --cwd=inexistent default
   abort: $ENOENT$: 'inexistent'
   [255]
 
   $ hg log -b '--config=ui.traceback=yes' 2>&1 | grep '^Traceback'
   Traceback (most recent call last):
   $ hg log -b '--config=profiling.enabled=yes' 2>&1 | grep -i sample
   Sample count: .*|No samples recorded\. (re)
 
 Early options can't be specified in [aliases] and [defaults] because they are
 applied before the command name is resolved:
 
   $ hg log -b '--config=alias.log=log --config=hooks.pre-log=false'
   hg log: option -b not recognized
   error in definition for alias 'log': --config may only be given on the command
   line
   [255]
 
   $ hg log -b '--config=defaults.log=--config=hooks.pre-log=false'
   abort: option --config may not be abbreviated!
   [255]
 
 Shell aliases bypass any command parsing rules but for the early one:
 
   $ hg log -b '--config=alias.log=!echo howdy'
   howdy
 
 Early options must come first if HGPLAIN=+strictflags is specified:
 (BUG: chg cherry-picks early options to pass them as a server command)
 
 #if no-chg
   $ HGPLAIN=+strictflags hg log -b --config='hooks.pre-log=false' default
   abort: unknown revision '--config=hooks.pre-log=false'!
   [255]
   $ HGPLAIN=+strictflags hg log -b -R. default
   abort: unknown revision '-R.'!
   [255]
   $ HGPLAIN=+strictflags hg log -b --cwd=. default
   abort: unknown revision '--cwd=.'!
   [255]
 #endif
   $ HGPLAIN=+strictflags hg log -b --debugger default
   abort: unknown revision '--debugger'!
   [255]
   $ HGPLAIN=+strictflags hg log -b --config='alias.log=!echo pwned' default
   abort: unknown revision '--config=alias.log=!echo pwned'!
   [255]
 
   $ HGPLAIN=+strictflags hg log --config='hooks.pre-log=false' -b default
   abort: option --config may not be abbreviated!
   [255]
   $ HGPLAIN=+strictflags hg log -q --cwd=.. -b default
   abort: option --cwd may not be abbreviated!
   [255]
   $ HGPLAIN=+strictflags hg log -q -R . -b default
   abort: option -R has to be separated from other options (e.g. not -qR) and --repository may only be abbreviated as --repo!
   [255]
 
   $ HGPLAIN=+strictflags hg --config='hooks.pre-log=false' log -b default
   abort: pre-log hook exited with status 1
   [255]
   $ HGPLAIN=+strictflags hg --cwd .. -q -Ra log -b default
   0:cb9a9f314b8b
   $ HGPLAIN=+strictflags hg --cwd .. -q --repository a log -b default
   0:cb9a9f314b8b
   $ HGPLAIN=+strictflags hg --cwd .. -q --repo a log -b default
   0:cb9a9f314b8b
 
 For compatibility reasons, HGPLAIN=+strictflags is not enabled by plain HGPLAIN:
 
   $ HGPLAIN= hg log --config='hooks.pre-log=false' -b default
   abort: pre-log hook exited with status 1
   [255]
   $ HGPLAINEXCEPT= hg log --cwd .. -q -Ra -b default
   0:cb9a9f314b8b
 
 [defaults]
 
   $ hg cat a
   a
   $ cat >> $HGRCPATH <<EOF
   > [defaults]
   > cat = -r null
   > EOF
   $ hg cat a
   a: no such file in rev 000000000000
   [1]
 
   $ cd "$TESTTMP"
 
 OSError "No such file or directory" / "The system cannot find the path
 specified" should include filename even when it is empty
 
   $ hg -R a archive ''
   abort: *: '' (glob)
   [255]
 
 #if no-outer-repo
 
 No repo:
 
   $ hg cat
   abort: no repository found in '$TESTTMP' (.hg not found)!
   [255]
 
 #endif
 
 #if rmcwd
 
 Current directory removed:
 
   $ mkdir $TESTTMP/repo1
   $ cd $TESTTMP/repo1
   $ rm -rf $TESTTMP/repo1
 
 The output could be one of the following and something else:
  chg: abort: failed to getcwd (errno = *) (glob)
  abort: error getting current working directory: * (glob)
  sh: 0: getcwd() failed: $ENOENT$
 Since the exact behavior depends on the shell, only check it returns non-zero.
   $ HGDEMANDIMPORT=disable hg version -q 2>/dev/null || false
   [1]
 
 #endif

tests/test-extension.t

@@ -1,1756 +1,1758 b''
 Test basic extension support
 
   $ cat > foobar.py <<EOF
   > import os
   > from mercurial import commands, registrar
   > cmdtable = {}
   > command = registrar.command(cmdtable)
   > configtable = {}
   > configitem = registrar.configitem(configtable)
   > configitem(b'tests', b'foo', default=b"Foo")
   > def uisetup(ui):
   >     ui.debug(b"uisetup called [debug]\\n")
   >     ui.write(b"uisetup called\\n")
   >     ui.status(b"uisetup called [status]\\n")
   >     ui.flush()
   > def reposetup(ui, repo):
   >     ui.write(b"reposetup called for %s\\n" % os.path.basename(repo.root))
   >     ui.write(b"ui %s= repo.ui\\n" % (ui == repo.ui and b"=" or b"!"))
   >     ui.flush()
   > @command(b'foo', [], b'hg foo')
   > def foo(ui, *args, **kwargs):
   >     foo = ui.config(b'tests', b'foo')
   >     ui.write(foo)
   >     ui.write(b"\\n")
   > @command(b'bar', [], b'hg bar', norepo=True)
   > def bar(ui, *args, **kwargs):
   >     ui.write(b"Bar\\n")
   > EOF
   $ abspath=`pwd`/foobar.py
 
   $ mkdir barfoo
   $ cp foobar.py barfoo/__init__.py
   $ barfoopath=`pwd`/barfoo
 
   $ hg init a
   $ cd a
   $ echo foo > file
   $ hg add file
   $ hg commit -m 'add file'
 
   $ echo '[extensions]' >> $HGRCPATH
   $ echo "foobar = $abspath" >> $HGRCPATH
   $ hg foo
   uisetup called
   uisetup called [status]
   reposetup called for a
   ui == repo.ui
   reposetup called for a (chg !)
   ui == repo.ui (chg !)
   Foo
   $ hg foo --quiet
   uisetup called (no-chg !)
   reposetup called for a (chg !)
   ui == repo.ui
   Foo
   $ hg foo --debug
   uisetup called [debug] (no-chg !)
   uisetup called (no-chg !)
   uisetup called [status] (no-chg !)
   reposetup called for a (chg !)
   ui == repo.ui
   Foo
 
   $ cd ..
   $ hg clone a b
   uisetup called (no-chg !)
   uisetup called [status] (no-chg !)
   reposetup called for a
   ui == repo.ui
   reposetup called for b
   ui == repo.ui
   updating to branch default
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
   $ hg bar
   uisetup called (no-chg !)
   uisetup called [status] (no-chg !)
   Bar
   $ echo 'foobar = !' >> $HGRCPATH
 
 module/__init__.py-style
 
   $ echo "barfoo = $barfoopath" >> $HGRCPATH
   $ cd a
   $ hg foo
   uisetup called
   uisetup called [status]
   reposetup called for a
   ui == repo.ui
   reposetup called for a (chg !)
   ui == repo.ui (chg !)
   Foo
   $ echo 'barfoo = !' >> $HGRCPATH
 
 Check that extensions are loaded in phases:
 
   $ cat > foo.py <<EOF
   > import os
   > name = os.path.basename(__file__).rsplit('.', 1)[0]
   > print("1) %s imported" % name)
   > def uisetup(ui):
   >     print("2) %s uisetup" % name)
   > def extsetup():
   >     print("3) %s extsetup" % name)
   > def reposetup(ui, repo):
   >    print("4) %s reposetup" % name)
   > 
   > bytesname = name.encode('utf-8')
   > # custom predicate to check registration of functions at loading
   > from mercurial import (
   >     registrar,
   >     smartset,
   > )
   > revsetpredicate = registrar.revsetpredicate()
   > @revsetpredicate(bytesname, safe=True) # safe=True for query via hgweb
   > def custompredicate(repo, subset, x):
   >     return smartset.baseset([r for r in subset if r in {0}])
   > EOF
 
   $ cp foo.py bar.py
   $ echo 'foo = foo.py' >> $HGRCPATH
   $ echo 'bar = bar.py' >> $HGRCPATH
 
 Check normal command's load order of extensions and registration of functions
 
   $ hg log -r "foo() and bar()" -q
   1) foo imported
   1) bar imported
   2) foo uisetup
   2) bar uisetup
   3) foo extsetup
   3) bar extsetup
   4) foo reposetup
   4) bar reposetup
   0:c24b9ac61126
 
 Check hgweb's load order of extensions and registration of functions
 
   $ cat > hgweb.cgi <<EOF
   > #!$PYTHON
   > from mercurial import demandimport; demandimport.enable()
   > from mercurial.hgweb import hgweb
   > from mercurial.hgweb import wsgicgi
   > application = hgweb(b'.', b'test repo')
   > wsgicgi.launch(application)
   > EOF
   $ . "$TESTDIR/cgienv"
 
   $ PATH_INFO='/' SCRIPT_NAME='' "$PYTHON" hgweb.cgi \
   >    | grep '^[0-9]) ' # ignores HTML output
   1) foo imported
   1) bar imported
   2) foo uisetup
   2) bar uisetup
   3) foo extsetup
   3) bar extsetup
   4) foo reposetup
   4) bar reposetup
 
 (check that revset predicate foo() and bar() are available)
 
 #if msys
   $ PATH_INFO='//shortlog'
 #else
   $ PATH_INFO='/shortlog'
 #endif
   $ export PATH_INFO
   $ SCRIPT_NAME='' QUERY_STRING='rev=foo() and bar()' "$PYTHON" hgweb.cgi \
   >     | grep '<a href="/rev/[0-9a-z]*">'
      <a href="/rev/c24b9ac61126">add file</a>
 
   $ echo 'foo = !' >> $HGRCPATH
   $ echo 'bar = !' >> $HGRCPATH
 
 Check "from __future__ import absolute_import" support for external libraries
 
 #if windows
   $ PATHSEP=";"
 #else
   $ PATHSEP=":"
 #endif
   $ export PATHSEP
 
   $ mkdir $TESTTMP/libroot
   $ echo "s = 'libroot/ambig.py'" > $TESTTMP/libroot/ambig.py
   $ mkdir $TESTTMP/libroot/mod
   $ touch $TESTTMP/libroot/mod/__init__.py
   $ echo "s = 'libroot/mod/ambig.py'" > $TESTTMP/libroot/mod/ambig.py
 
   $ cat > $TESTTMP/libroot/mod/ambigabs.py <<EOF
   > from __future__ import absolute_import
   > import ambig # should load "libroot/ambig.py"
   > s = ambig.s
   > EOF
   $ cat > loadabs.py <<EOF
   > import mod.ambigabs as ambigabs
   > def extsetup():
   >     print('ambigabs.s=%s' % ambigabs.s)
   > EOF
   $ (PYTHONPATH=${PYTHONPATH}${PATHSEP}${TESTTMP}/libroot; hg --config extensions.loadabs=loadabs.py root)
   ambigabs.s=libroot/ambig.py
   $TESTTMP/a
 
 #if no-py3k
   $ cat > $TESTTMP/libroot/mod/ambigrel.py <<EOF
   > import ambig # should load "libroot/mod/ambig.py"
   > s = ambig.s
   > EOF
   $ cat > loadrel.py <<EOF
   > import mod.ambigrel as ambigrel
   > def extsetup():
   >     print('ambigrel.s=%s' % ambigrel.s)
   > EOF
   $ (PYTHONPATH=${PYTHONPATH}${PATHSEP}${TESTTMP}/libroot; hg --config extensions.loadrel=loadrel.py root)
   ambigrel.s=libroot/mod/ambig.py
   $TESTTMP/a
 #endif
 
 Check absolute/relative import of extension specific modules
 
   $ mkdir $TESTTMP/extroot
   $ cat > $TESTTMP/extroot/bar.py <<EOF
   > s = 'this is extroot.bar'
   > EOF
   $ mkdir $TESTTMP/extroot/sub1
   $ cat > $TESTTMP/extroot/sub1/__init__.py <<EOF
   > s = 'this is extroot.sub1.__init__'
   > EOF
   $ cat > $TESTTMP/extroot/sub1/baz.py <<EOF
   > s = 'this is extroot.sub1.baz'
   > EOF
   $ cat > $TESTTMP/extroot/__init__.py <<EOF
   > s = 'this is extroot.__init__'
   > import foo
   > def extsetup(ui):
   >     ui.write('(extroot) ', foo.func(), '\n')
   >     ui.flush()
   > EOF
 
   $ cat > $TESTTMP/extroot/foo.py <<EOF
   > # test absolute import
   > buf = []
   > def func():
   >     # "not locals" case
   >     import extroot.bar
   >     buf.append('import extroot.bar in func(): %s' % extroot.bar.s)
   >     return '\n(extroot) '.join(buf)
   > # "fromlist == ('*',)" case
   > from extroot.bar import *
   > buf.append('from extroot.bar import *: %s' % s)
   > # "not fromlist" and "if '.' in name" case
   > import extroot.sub1.baz
   > buf.append('import extroot.sub1.baz: %s' % extroot.sub1.baz.s)
   > # "not fromlist" and NOT "if '.' in name" case
   > import extroot
   > buf.append('import extroot: %s' % extroot.s)
   > # NOT "not fromlist" and NOT "level != -1" case
   > from extroot.bar import s
   > buf.append('from extroot.bar import s: %s' % s)
   > EOF
   $ (PYTHONPATH=${PYTHONPATH}${PATHSEP}${TESTTMP}; hg --config extensions.extroot=$TESTTMP/extroot root)
   (extroot) from extroot.bar import *: this is extroot.bar
   (extroot) import extroot.sub1.baz: this is extroot.sub1.baz
   (extroot) import extroot: this is extroot.__init__
   (extroot) from extroot.bar import s: this is extroot.bar
   (extroot) import extroot.bar in func(): this is extroot.bar
   $TESTTMP/a
 
 #if no-py3k
   $ rm "$TESTTMP"/extroot/foo.*
   $ rm -Rf "$TESTTMP/extroot/__pycache__"
   $ cat > $TESTTMP/extroot/foo.py <<EOF
   > # test relative import
   > buf = []
   > def func():
   >     # "not locals" case
   >     import bar
   >     buf.append('import bar in func(): %s' % bar.s)
   >     return '\n(extroot) '.join(buf)
   > # "fromlist == ('*',)" case
   > from bar import *
   > buf.append('from bar import *: %s' % s)
   > # "not fromlist" and "if '.' in name" case
   > import sub1.baz
   > buf.append('import sub1.baz: %s' % sub1.baz.s)
   > # "not fromlist" and NOT "if '.' in name" case
   > import sub1
   > buf.append('import sub1: %s' % sub1.s)
   > # NOT "not fromlist" and NOT "level != -1" case
   > from bar import s
   > buf.append('from bar import s: %s' % s)
   > EOF
   $ hg --config extensions.extroot=$TESTTMP/extroot root
   (extroot) from bar import *: this is extroot.bar
   (extroot) import sub1.baz: this is extroot.sub1.baz
   (extroot) import sub1: this is extroot.sub1.__init__
   (extroot) from bar import s: this is extroot.bar
   (extroot) import bar in func(): this is extroot.bar
   $TESTTMP/a
 #endif
 
 #if demandimport
 
 Examine whether module loading is delayed until actual referring, even
 though module is imported with "absolute_import" feature.
 
 Files below in each packages are used for described purpose:
 
 - "called": examine whether "from MODULE import ATTR" works correctly
 - "unused": examine whether loading is delayed correctly
 - "used":   examine whether "from PACKAGE import MODULE" works correctly
 
 Package hierarchy is needed to examine whether demand importing works
 as expected for "from SUB.PACK.AGE import MODULE".
 
 Setup "external library" to be imported with "absolute_import"
 feature.
 
   $ mkdir -p $TESTTMP/extlibroot/lsub1/lsub2
   $ touch $TESTTMP/extlibroot/__init__.py
   $ touch $TESTTMP/extlibroot/lsub1/__init__.py
   $ touch $TESTTMP/extlibroot/lsub1/lsub2/__init__.py
 
   $ cat > $TESTTMP/extlibroot/lsub1/lsub2/called.py <<EOF
   > def func():
   >     return b"this is extlibroot.lsub1.lsub2.called.func()"
   > EOF
   $ cat > $TESTTMP/extlibroot/lsub1/lsub2/unused.py <<EOF
   > raise Exception("extlibroot.lsub1.lsub2.unused is loaded unintentionally")
   > EOF
   $ cat > $TESTTMP/extlibroot/lsub1/lsub2/used.py <<EOF
   > detail = b"this is extlibroot.lsub1.lsub2.used"
   > EOF
 
 Setup sub-package of "external library", which causes instantiation of
 demandmod in "recurse down the module chain" code path. Relative
 importing with "absolute_import" feature isn't tested, because "level
 >=1 " doesn't cause instantiation of demandmod.
 
   $ mkdir -p $TESTTMP/extlibroot/recursedown/abs
   $ cat > $TESTTMP/extlibroot/recursedown/abs/used.py <<EOF
   > detail = b"this is extlibroot.recursedown.abs.used"
   > EOF
   $ cat > $TESTTMP/extlibroot/recursedown/abs/__init__.py <<EOF
   > from __future__ import absolute_import
   > from extlibroot.recursedown.abs.used import detail
   > EOF
 
   $ mkdir -p $TESTTMP/extlibroot/recursedown/legacy
   $ cat > $TESTTMP/extlibroot/recursedown/legacy/used.py <<EOF
   > detail = b"this is extlibroot.recursedown.legacy.used"
   > EOF
   $ cat > $TESTTMP/extlibroot/recursedown/legacy/__init__.py <<EOF
   > # legacy style (level == -1) import
   > from extlibroot.recursedown.legacy.used import detail
   > EOF
 
   $ cat > $TESTTMP/extlibroot/recursedown/__init__.py <<EOF
   > from __future__ import absolute_import
   > from extlibroot.recursedown.abs import detail as absdetail
   > from .legacy import detail as legacydetail
   > EOF
 
 Setup package that re-exports an attribute of its submodule as the same
 name. This leaves 'shadowing.used' pointing to 'used.detail', but still
 the submodule 'used' should be somehow accessible. (issue5617)
 
   $ mkdir -p $TESTTMP/extlibroot/shadowing
   $ cat > $TESTTMP/extlibroot/shadowing/used.py <<EOF
   > detail = b"this is extlibroot.shadowing.used"
   > EOF
   $ cat > $TESTTMP/extlibroot/shadowing/proxied.py <<EOF
   > from __future__ import absolute_import
   > from extlibroot.shadowing.used import detail
   > EOF
   $ cat > $TESTTMP/extlibroot/shadowing/__init__.py <<EOF
   > from __future__ import absolute_import
   > from .used import detail as used
   > EOF
 
 Setup extension local modules to be imported with "absolute_import"
 feature.
 
   $ mkdir -p $TESTTMP/absextroot/xsub1/xsub2
   $ touch $TESTTMP/absextroot/xsub1/__init__.py
   $ touch $TESTTMP/absextroot/xsub1/xsub2/__init__.py
 
   $ cat > $TESTTMP/absextroot/xsub1/xsub2/called.py <<EOF
   > def func():
   >     return b"this is absextroot.xsub1.xsub2.called.func()"
   > EOF
   $ cat > $TESTTMP/absextroot/xsub1/xsub2/unused.py <<EOF
   > raise Exception("absextroot.xsub1.xsub2.unused is loaded unintentionally")
   > EOF
   $ cat > $TESTTMP/absextroot/xsub1/xsub2/used.py <<EOF
   > detail = b"this is absextroot.xsub1.xsub2.used"
   > EOF
 
 Setup extension local modules to examine whether demand importing
 works as expected in "level > 1" case.
 
   $ cat > $TESTTMP/absextroot/relimportee.py <<EOF
   > detail = b"this is absextroot.relimportee"
   > EOF
   $ cat > $TESTTMP/absextroot/xsub1/xsub2/relimporter.py <<EOF
   > from __future__ import absolute_import
   > from ... import relimportee
   > detail = b"this relimporter imports %r" % (relimportee.detail)
   > EOF
 
 Setup modules, which actually import extension local modules at
 runtime.
 
   $ cat > $TESTTMP/absextroot/absolute.py << EOF
   > from __future__ import absolute_import
   > 
   > # import extension local modules absolutely (level = 0)
   > from absextroot.xsub1.xsub2 import used, unused
   > from absextroot.xsub1.xsub2.called import func
   > 
   > def getresult():
   >     result = []
   >     result.append(used.detail)
   >     result.append(func())
   >     return result
   > EOF
 
   $ cat > $TESTTMP/absextroot/relative.py << EOF
   > from __future__ import absolute_import
   > 
   > # import extension local modules relatively (level == 1)
   > from .xsub1.xsub2 import used, unused
   > from .xsub1.xsub2.called import func
   > 
   > # import a module, which implies "importing with level > 1"
   > from .xsub1.xsub2 import relimporter
   > 
   > def getresult():
   >     result = []
   >     result.append(used.detail)
   >     result.append(func())
   >     result.append(relimporter.detail)
   >     return result
   > EOF
 
 Setup main procedure of extension.
 
   $ cat > $TESTTMP/absextroot/__init__.py <<EOF
   > from __future__ import absolute_import
   > from mercurial import registrar
   > cmdtable = {}
   > command = registrar.command(cmdtable)
   > 
   > # "absolute" and "relative" shouldn't be imported before actual
   > # command execution, because (1) they import same modules, and (2)
   > # preceding import (= instantiate "demandmod" object instead of
   > # real "module" object) might hide problem of succeeding import.
   > 
   > @command(b'showabsolute', [], norepo=True)
   > def showabsolute(ui, *args, **opts):
   >     from absextroot import absolute
   >     ui.write(b'ABS: %s\n' % '\nABS: '.join(absolute.getresult()))
   > 
   > @command(b'showrelative', [], norepo=True)
   > def showrelative(ui, *args, **opts):
   >     from . import relative
   >     ui.write(b'REL: %s\n' % '\nREL: '.join(relative.getresult()))
   > 
   > # import modules from external library
   > from extlibroot.lsub1.lsub2 import used as lused, unused as lunused
   > from extlibroot.lsub1.lsub2.called import func as lfunc
   > from extlibroot.recursedown import absdetail, legacydetail
   > from extlibroot.shadowing import proxied
   > 
   > def uisetup(ui):
   >     result = []
   >     result.append(lused.detail)
   >     result.append(lfunc())
   >     result.append(absdetail)
   >     result.append(legacydetail)
   >     result.append(proxied.detail)
   >     ui.write(b'LIB: %s\n' % '\nLIB: '.join(result))
   > EOF
 
 Examine module importing.
 
   $ (PYTHONPATH=${PYTHONPATH}${PATHSEP}${TESTTMP}; hg --config extensions.absextroot=$TESTTMP/absextroot showabsolute)
   LIB: this is extlibroot.lsub1.lsub2.used
   LIB: this is extlibroot.lsub1.lsub2.called.func()
   LIB: this is extlibroot.recursedown.abs.used
   LIB: this is extlibroot.recursedown.legacy.used
   LIB: this is extlibroot.shadowing.used
   ABS: this is absextroot.xsub1.xsub2.used
   ABS: this is absextroot.xsub1.xsub2.called.func()
 
   $ (PYTHONPATH=${PYTHONPATH}${PATHSEP}${TESTTMP}; hg --config extensions.absextroot=$TESTTMP/absextroot showrelative)
   LIB: this is extlibroot.lsub1.lsub2.used
   LIB: this is extlibroot.lsub1.lsub2.called.func()
   LIB: this is extlibroot.recursedown.abs.used
   LIB: this is extlibroot.recursedown.legacy.used
   LIB: this is extlibroot.shadowing.used
   REL: this is absextroot.xsub1.xsub2.used
   REL: this is absextroot.xsub1.xsub2.called.func()
   REL: this relimporter imports 'this is absextroot.relimportee'
 
 Examine whether sub-module is imported relatively as expected.
 
 See also issue5208 for detail about example case on Python 3.x.
 
   $ f -q $TESTTMP/extlibroot/lsub1/lsub2/notexist.py
   $TESTTMP/extlibroot/lsub1/lsub2/notexist.py: file not found
 
   $ cat > $TESTTMP/notexist.py <<EOF
   > text = 'notexist.py at root is loaded unintentionally\n'
   > EOF
 
   $ cat > $TESTTMP/checkrelativity.py <<EOF
   > from mercurial import registrar
   > cmdtable = {}
   > command = registrar.command(cmdtable)
   > 
   > # demand import avoids failure of importing notexist here
   > import extlibroot.lsub1.lsub2.notexist
   > 
   > @command(b'checkrelativity', [], norepo=True)
   > def checkrelativity(ui, *args, **opts):
   >     try:
   >         ui.write(extlibroot.lsub1.lsub2.notexist.text)
   >         return 1 # unintentional success
   >     except ImportError:
   >         pass # intentional failure
   > EOF
 
   $ (PYTHONPATH=${PYTHONPATH}${PATHSEP}${TESTTMP}; hg --config extensions.checkrelativity=$TESTTMP/checkrelativity.py checkrelativity)
 
 #endif
 
 Make sure a broken uisetup doesn't globally break hg:
   $ cat > $TESTTMP/baduisetup.py <<EOF
   > def uisetup(ui):
   >     1/0
   > EOF
 
 Even though the extension fails during uisetup, hg is still basically usable:
   $ hg --config extensions.baduisetup=$TESTTMP/baduisetup.py version
   Traceback (most recent call last):
     File "*/mercurial/extensions.py", line *, in _runuisetup (glob)
       uisetup(ui)
     File "$TESTTMP/baduisetup.py", line 2, in uisetup
       1/0
   ZeroDivisionError: integer division or modulo by zero
   *** failed to set up extension baduisetup: integer division or modulo by zero
   Mercurial Distributed SCM (version *) (glob)
   (see https://mercurial-scm.org for more information)
   
   Copyright (C) 2005-* Matt Mackall and others (glob)
   This is free software; see the source for copying conditions. There is NO
   warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 
   $ cd ..
 
 hide outer repo
   $ hg init
 
   $ cat > empty.py <<EOF
   > '''empty cmdtable
   > '''
   > cmdtable = {}
   > EOF
   $ emptypath=`pwd`/empty.py
   $ echo "empty = $emptypath" >> $HGRCPATH
   $ hg help empty
   empty extension - empty cmdtable
   
   no commands defined
 
 
   $ echo 'empty = !' >> $HGRCPATH
 
   $ cat > debugextension.py <<EOF
   > '''only debugcommands
   > '''
   > from mercurial import registrar
   > cmdtable = {}
   > command = registrar.command(cmdtable)
   > @command(b'debugfoobar', [], b'hg debugfoobar')
   > def debugfoobar(ui, repo, *args, **opts):
   >     "yet another debug command"
   >     pass
   > @command(b'foo', [], b'hg foo')
   > def foo(ui, repo, *args, **opts):
   >     """yet another foo command
   >     This command has been DEPRECATED since forever.
   >     """
   >     pass
   > EOF
   $ debugpath=`pwd`/debugextension.py
   $ echo "debugextension = $debugpath" >> $HGRCPATH
 
   $ hg help debugextension
   hg debugextensions
   
   show information about active extensions
   
   options:
   
+   -T --template TEMPLATE display with template
+  
   (some details hidden, use --verbose to show complete help)
 
 
   $ hg --verbose help debugextension
   hg debugextensions
   
   show information about active extensions
   
   options:
   
-   -T --template TEMPLATE display with template (EXPERIMENTAL)
+   -T --template TEMPLATE display with template
   
   global options ([+] can be repeated):
   
    -R --repository REPO   repository root directory or name of overlay bundle
                           file
       --cwd DIR           change working directory
    -y --noninteractive    do not prompt, automatically pick the first choice for
                           all prompts
    -q --quiet             suppress output
    -v --verbose           enable additional output
       --color TYPE        when to colorize (boolean, always, auto, never, or
                           debug)
       --config CONFIG [+] set/override config option (use 'section.name=value')
       --debug             enable debugging output
       --debugger          start debugger
       --encoding ENCODE   set the charset encoding (default: ascii)
       --encodingmode MODE set the charset encoding mode (default: strict)
       --traceback         always print a traceback on exception
       --time              time how long the command takes
       --profile           print command execution profile
       --version           output version information and exit
    -h --help              display help and exit
       --hidden            consider hidden changesets
       --pager TYPE        when to paginate (boolean, always, auto, or never)
                           (default: auto)
 
 
 
 
 
 
   $ hg --debug help debugextension
   hg debugextensions
   
   show information about active extensions
   
   options:
   
-   -T --template TEMPLATE display with template (EXPERIMENTAL)
+   -T --template TEMPLATE display with template
   
   global options ([+] can be repeated):
   
    -R --repository REPO   repository root directory or name of overlay bundle
                           file
       --cwd DIR           change working directory
    -y --noninteractive    do not prompt, automatically pick the first choice for
                           all prompts
    -q --quiet             suppress output
    -v --verbose           enable additional output
       --color TYPE        when to colorize (boolean, always, auto, never, or
                           debug)
       --config CONFIG [+] set/override config option (use 'section.name=value')
       --debug             enable debugging output
       --debugger          start debugger
       --encoding ENCODE   set the charset encoding (default: ascii)
       --encodingmode MODE set the charset encoding mode (default: strict)
       --traceback         always print a traceback on exception
       --time              time how long the command takes
       --profile           print command execution profile
       --version           output version information and exit
    -h --help              display help and exit
       --hidden            consider hidden changesets
       --pager TYPE        when to paginate (boolean, always, auto, or never)
                           (default: auto)
 
 
 
 
 
   $ echo 'debugextension = !' >> $HGRCPATH
 
 Asking for help about a deprecated extension should do something useful:
 
   $ hg help glog
   'glog' is provided by the following extension:
   
       graphlog      command to view revision graphs from a shell (DEPRECATED)
   
   (use 'hg help extensions' for information on enabling extensions)
 
 Extension module help vs command help:
 
   $ echo 'extdiff =' >> $HGRCPATH
   $ hg help extdiff
   hg extdiff [OPT]... [FILE]...
   
   use external program to diff repository (or selected files)
   
       Show differences between revisions for the specified files, using an
       external program. The default program used is diff, with default options
       "-Npru".
   
       To select a different program, use the -p/--program option. The program
       will be passed the names of two directories to compare. To pass additional
       options to the program, use -o/--option. These will be passed before the
       names of the directories to compare.
   
       When two revision arguments are given, then changes are shown between
       those revisions. If only one revision is specified then that revision is
       compared to the working directory, and, when no revisions are specified,
       the working directory files are compared to its parent.
   
   (use 'hg help -e extdiff' to show help for the extdiff extension)
   
   options ([+] can be repeated):
   
    -p --program CMD         comparison program to run
    -o --option OPT [+]      pass option to comparison program
    -r --rev REV [+]         revision
    -c --change REV          change made by revision
       --patch               compare patches for two revisions
    -I --include PATTERN [+] include names matching the given patterns
    -X --exclude PATTERN [+] exclude names matching the given patterns
    -S --subrepos            recurse into subrepositories
   
   (some details hidden, use --verbose to show complete help)
 
 
 
 
 
 
 
 
 
 
   $ hg help --extension extdiff
   extdiff extension - command to allow external programs to compare revisions
   
   The extdiff Mercurial extension allows you to use external programs to compare
   revisions, or revision with working directory. The external diff programs are
   called with a configurable set of options and two non-option arguments: paths
   to directories containing snapshots of files to compare.
   
   If there is more than one file being compared and the "child" revision is the
   working directory, any modifications made in the external diff program will be
   copied back to the working directory from the temporary directory.
   
   The extdiff extension also allows you to configure new diff commands, so you
   do not need to type 'hg extdiff -p kdiff3' always.
   
     [extdiff]
     # add new command that runs GNU diff(1) in 'context diff' mode
     cdiff = gdiff -Nprc5
     ## or the old way:
     #cmd.cdiff = gdiff
     #opts.cdiff = -Nprc5
   
     # add new command called meld, runs meld (no need to name twice).  If
     # the meld executable is not available, the meld tool in [merge-tools]
     # will be used, if available
     meld =
   
     # add new command called vimdiff, runs gvimdiff with DirDiff plugin
     # (see http://www.vim.org/scripts/script.php?script_id=102) Non
     # English user, be sure to put "let g:DirDiffDynamicDiffText = 1" in
     # your .vimrc
     vimdiff = gvim -f "+next" \
               "+execute 'DirDiff' fnameescape(argv(0)) fnameescape(argv(1))"
   
   Tool arguments can include variables that are expanded at runtime:
   
     $parent1, $plabel1 - filename, descriptive label of first parent
     $child,   $clabel  - filename, descriptive label of child revision
     $parent2, $plabel2 - filename, descriptive label of second parent
     $root              - repository root
     $parent is an alias for $parent1.
   
   The extdiff extension will look in your [diff-tools] and [merge-tools]
   sections for diff tool arguments, when none are specified in [extdiff].
   
     [extdiff]
     kdiff3 =
   
     [diff-tools]
     kdiff3.diffargs=--L1 '$plabel1' --L2 '$clabel' $parent $child
   
   You can use -I/-X and list of file or directory names like normal 'hg diff'
   command. The extdiff extension makes snapshots of only needed files, so
   running the external diff program will actually be pretty fast (at least
   faster than having to compare the entire tree).
   
   list of commands:
   
    extdiff       use external program to diff repository (or selected files)
   
   (use 'hg help -v -e extdiff' to show built-in aliases and global options)
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
   $ echo 'extdiff = !' >> $HGRCPATH
 
 Test help topic with same name as extension
 
   $ cat > multirevs.py <<EOF
   > from mercurial import commands, registrar
   > cmdtable = {}
   > command = registrar.command(cmdtable)
   > """multirevs extension
   > Big multi-line module docstring."""
   > @command(b'multirevs', [], b'ARG', norepo=True)
   > def multirevs(ui, repo, arg, *args, **opts):
   >     """multirevs command"""
   >     pass
   > EOF
   $ echo "multirevs = multirevs.py" >> $HGRCPATH
 
   $ hg help multirevs | tail
         used):
   
           hg update :@
   
       - Show diff between tags 1.3 and 1.5 (this works because the first and the
         last revisions of the revset are used):
   
           hg diff -r 1.3::1.5
   
   use 'hg help -c multirevs' to see help for the multirevs command
 
 
 
 
 
 
   $ hg help -c multirevs
   hg multirevs ARG
   
   multirevs command
   
   (some details hidden, use --verbose to show complete help)
 
 
 
   $ hg multirevs
   hg multirevs: invalid arguments
   hg multirevs ARG
   
   multirevs command
   
   (use 'hg multirevs -h' to show more help)
   [255]
 
 
 
   $ echo "multirevs = !" >> $HGRCPATH
 
 Issue811: Problem loading extensions twice (by site and by user)
 
   $ cat <<EOF >> $HGRCPATH
   > mq =
   > strip =
   > hgext.mq =
   > hgext/mq =
   > EOF
 
 Show extensions:
 (note that mq force load strip, also checking it's not loaded twice)
 
 #if no-extraextensions
   $ hg debugextensions
   mq
   strip
 #endif
 
 For extensions, which name matches one of its commands, help
 message should ask '-v -e' to get list of built-in aliases
 along with extension help itself
 
   $ mkdir $TESTTMP/d
   $ cat > $TESTTMP/d/dodo.py <<EOF
   > """
   > This is an awesome 'dodo' extension. It does nothing and
   > writes 'Foo foo'
   > """
   > from mercurial import commands, registrar
   > cmdtable = {}
   > command = registrar.command(cmdtable)
   > @command(b'dodo', [], b'hg dodo')
   > def dodo(ui, *args, **kwargs):
   >     """Does nothing"""
   >     ui.write(b"I do nothing. Yay\\n")
   > @command(b'foofoo', [], b'hg foofoo')
   > def foofoo(ui, *args, **kwargs):
   >     """Writes 'Foo foo'"""
   >     ui.write(b"Foo foo\\n")
   > EOF
   $ dodopath=$TESTTMP/d/dodo.py
 
   $ echo "dodo = $dodopath" >> $HGRCPATH
 
 Make sure that user is asked to enter '-v -e' to get list of built-in aliases
   $ hg help -e dodo
   dodo extension -
   
   This is an awesome 'dodo' extension. It does nothing and writes 'Foo foo'
   
   list of commands:
   
    dodo          Does nothing
    foofoo        Writes 'Foo foo'
   
   (use 'hg help -v -e dodo' to show built-in aliases and global options)
 
 Make sure that '-v -e' prints list of built-in aliases along with
 extension help itself
   $ hg help -v -e dodo
   dodo extension -
   
   This is an awesome 'dodo' extension. It does nothing and writes 'Foo foo'
   
   list of commands:
   
    dodo          Does nothing
    foofoo        Writes 'Foo foo'
   
   global options ([+] can be repeated):
   
    -R --repository REPO   repository root directory or name of overlay bundle
                           file
       --cwd DIR           change working directory
    -y --noninteractive    do not prompt, automatically pick the first choice for
                           all prompts
    -q --quiet             suppress output
    -v --verbose           enable additional output
       --color TYPE        when to colorize (boolean, always, auto, never, or
                           debug)
       --config CONFIG [+] set/override config option (use 'section.name=value')
       --debug             enable debugging output
       --debugger          start debugger
       --encoding ENCODE   set the charset encoding (default: ascii)
       --encodingmode MODE set the charset encoding mode (default: strict)
       --traceback         always print a traceback on exception
       --time              time how long the command takes
       --profile           print command execution profile
       --version           output version information and exit
    -h --help              display help and exit
       --hidden            consider hidden changesets
       --pager TYPE        when to paginate (boolean, always, auto, or never)
                           (default: auto)
 
 Make sure that single '-v' option shows help and built-ins only for 'dodo' command
   $ hg help -v dodo
   hg dodo
   
   Does nothing
   
   (use 'hg help -e dodo' to show help for the dodo extension)
   
   options:
   
     --mq operate on patch repository
   
   global options ([+] can be repeated):
   
    -R --repository REPO   repository root directory or name of overlay bundle
                           file
       --cwd DIR           change working directory
    -y --noninteractive    do not prompt, automatically pick the first choice for
                           all prompts
    -q --quiet             suppress output
    -v --verbose           enable additional output
       --color TYPE        when to colorize (boolean, always, auto, never, or
                           debug)
       --config CONFIG [+] set/override config option (use 'section.name=value')
       --debug             enable debugging output
       --debugger          start debugger
       --encoding ENCODE   set the charset encoding (default: ascii)
       --encodingmode MODE set the charset encoding mode (default: strict)
       --traceback         always print a traceback on exception
       --time              time how long the command takes
       --profile           print command execution profile
       --version           output version information and exit
    -h --help              display help and exit
       --hidden            consider hidden changesets
       --pager TYPE        when to paginate (boolean, always, auto, or never)
                           (default: auto)
 
 In case when extension name doesn't match any of its commands,
 help message should ask for '-v' to get list of built-in aliases
 along with extension help
   $ cat > $TESTTMP/d/dudu.py <<EOF
   > """
   > This is an awesome 'dudu' extension. It does something and
   > also writes 'Beep beep'
   > """
   > from mercurial import commands, registrar
   > cmdtable = {}
   > command = registrar.command(cmdtable)
   > @command(b'something', [], b'hg something')
   > def something(ui, *args, **kwargs):
   >     """Does something"""
   >     ui.write(b"I do something. Yaaay\\n")
   > @command(b'beep', [], b'hg beep')
   > def beep(ui, *args, **kwargs):
   >     """Writes 'Beep beep'"""
   >     ui.write(b"Beep beep\\n")
   > EOF
   $ dudupath=$TESTTMP/d/dudu.py
 
   $ echo "dudu = $dudupath" >> $HGRCPATH
 
   $ hg help -e dudu
   dudu extension -
   
   This is an awesome 'dudu' extension. It does something and also writes 'Beep
   beep'
   
   list of commands:
   
    beep          Writes 'Beep beep'
    something     Does something
   
   (use 'hg help -v dudu' to show built-in aliases and global options)
 
 In case when extension name doesn't match any of its commands,
 help options '-v' and '-v -e' should be equivalent
   $ hg help -v dudu
   dudu extension -
   
   This is an awesome 'dudu' extension. It does something and also writes 'Beep
   beep'
   
   list of commands:
   
    beep          Writes 'Beep beep'
    something     Does something
   
   global options ([+] can be repeated):
   
    -R --repository REPO   repository root directory or name of overlay bundle
                           file
       --cwd DIR           change working directory
    -y --noninteractive    do not prompt, automatically pick the first choice for
                           all prompts
    -q --quiet             suppress output
    -v --verbose           enable additional output
       --color TYPE        when to colorize (boolean, always, auto, never, or
                           debug)
       --config CONFIG [+] set/override config option (use 'section.name=value')
       --debug             enable debugging output
       --debugger          start debugger
       --encoding ENCODE   set the charset encoding (default: ascii)
       --encodingmode MODE set the charset encoding mode (default: strict)
       --traceback         always print a traceback on exception
       --time              time how long the command takes
       --profile           print command execution profile
       --version           output version information and exit
    -h --help              display help and exit
       --hidden            consider hidden changesets
       --pager TYPE        when to paginate (boolean, always, auto, or never)
                           (default: auto)
 
   $ hg help -v -e dudu
   dudu extension -
   
   This is an awesome 'dudu' extension. It does something and also writes 'Beep
   beep'
   
   list of commands:
   
    beep          Writes 'Beep beep'
    something     Does something
   
   global options ([+] can be repeated):
   
    -R --repository REPO   repository root directory or name of overlay bundle
                           file
       --cwd DIR           change working directory
    -y --noninteractive    do not prompt, automatically pick the first choice for
                           all prompts
    -q --quiet             suppress output
    -v --verbose           enable additional output
       --color TYPE        when to colorize (boolean, always, auto, never, or
                           debug)
       --config CONFIG [+] set/override config option (use 'section.name=value')
       --debug             enable debugging output
       --debugger          start debugger
       --encoding ENCODE   set the charset encoding (default: ascii)
       --encodingmode MODE set the charset encoding mode (default: strict)
       --traceback         always print a traceback on exception
       --time              time how long the command takes
       --profile           print command execution profile
       --version           output version information and exit
    -h --help              display help and exit
       --hidden            consider hidden changesets
       --pager TYPE        when to paginate (boolean, always, auto, or never)
                           (default: auto)
 
 Disabled extension commands:
 
   $ ORGHGRCPATH=$HGRCPATH
   $ HGRCPATH=
   $ export HGRCPATH
   $ hg help email
   'email' is provided by the following extension:
   
       patchbomb     command to send changesets as (a series of) patch emails
   
   (use 'hg help extensions' for information on enabling extensions)
 
 
   $ hg qdel
   hg: unknown command 'qdel'
   'qdelete' is provided by the following extension:
   
       mq            manage a stack of patches
   
   (use 'hg help extensions' for information on enabling extensions)
   [255]
 
 
   $ hg churn
   hg: unknown command 'churn'
   'churn' is provided by the following extension:
   
       churn         command to display statistics about repository history
   
   (use 'hg help extensions' for information on enabling extensions)
   [255]
 
 
 
 Disabled extensions:
 
   $ hg help churn
   churn extension - command to display statistics about repository history
   
   (use 'hg help extensions' for information on enabling extensions)
 
   $ hg help patchbomb
   patchbomb extension - command to send changesets as (a series of) patch emails
   
   The series is started off with a "[PATCH 0 of N]" introduction, which
   describes the series as a whole.
   
   Each patch email has a Subject line of "[PATCH M of N] ...", using the first
   line of the changeset description as the subject text. The message contains
   two or three body parts:
   
   - The changeset description.
   - [Optional] The result of running diffstat on the patch.
   - The patch itself, as generated by 'hg export'.
   
   Each message refers to the first in the series using the In-Reply-To and
   References headers, so they will show up as a sequence in threaded mail and
   news readers, and in mail archives.
   
   To configure other defaults, add a section like this to your configuration
   file:
   
     [email]
     from = My Name <my@email>
     to = recipient1, recipient2, ...
     cc = cc1, cc2, ...
     bcc = bcc1, bcc2, ...
     reply-to = address1, address2, ...
   
   Use "[patchbomb]" as configuration section name if you need to override global
   "[email]" address settings.
   
   Then you can use the 'hg email' command to mail a series of changesets as a
   patchbomb.
   
   You can also either configure the method option in the email section to be a
   sendmail compatible mailer or fill out the [smtp] section so that the
   patchbomb extension can automatically send patchbombs directly from the
   commandline. See the [email] and [smtp] sections in hgrc(5) for details.
   
   By default, 'hg email' will prompt for a "To" or "CC" header if you do not
   supply one via configuration or the command line.  You can override this to
   never prompt by configuring an empty value:
   
     [email]
     cc =
   
   You can control the default inclusion of an introduction message with the
   "patchbomb.intro" configuration option. The configuration is always
   overwritten by command line flags like --intro and --desc:
   
     [patchbomb]
     intro=auto   # include introduction message if more than 1 patch (default)
     intro=never  # never include an introduction message
     intro=always # always include an introduction message
   
   You can specify a template for flags to be added in subject prefixes. Flags
   specified by --flag option are exported as "{flags}" keyword:
   
     [patchbomb]
     flagtemplate = "{separate(' ',
                               ifeq(branch, 'default', '', branch|upper),
                               flags)}"
   
   You can set patchbomb to always ask for confirmation by setting
   "patchbomb.confirm" to true.
   
   (use 'hg help extensions' for information on enabling extensions)
 
 
 Broken disabled extension and command:
 
   $ mkdir hgext
   $ echo > hgext/__init__.py
   $ cat > hgext/broken.py <<EOF
   > "broken extension'
   > EOF
   $ cat > path.py <<EOF
   > import os, sys
   > sys.path.insert(0, os.environ['HGEXTPATH'])
   > EOF
   $ HGEXTPATH=`pwd`
   $ export HGEXTPATH
 
   $ hg --config extensions.path=./path.py help broken
   broken extension - (no help text available)
   
   (use 'hg help extensions' for information on enabling extensions)
 
 
   $ cat > hgext/forest.py <<EOF
   > cmdtable = None
   > @command()
   > def f():
   >     pass
   > @command(123)
   > def g():
   >     pass
   > EOF
   $ hg --config extensions.path=./path.py help foo
   abort: no such help topic: foo
   (try 'hg help --keyword foo')
   [255]
 
   $ cat > throw.py <<EOF
   > from mercurial import commands, registrar, util
   > cmdtable = {}
   > command = registrar.command(cmdtable)
   > class Bogon(Exception): pass
   > @command(b'throw', [], b'hg throw', norepo=True)
   > def throw(ui, **opts):
   >     """throws an exception"""
   >     raise Bogon()
   > EOF
 
 No declared supported version, extension complains:
   $ hg --config extensions.throw=throw.py throw 2>&1 | egrep '^\*\*'
   ** Unknown exception encountered with possibly-broken third-party extension throw
   ** which supports versions unknown of Mercurial.
   ** Please disable throw and try your action again.
   ** If that fixes the bug please report it to the extension author.
   ** Python * (glob)
   ** Mercurial Distributed SCM * (glob)
   ** Extensions loaded: throw
 
 empty declaration of supported version, extension complains:
   $ echo "testedwith = ''" >> throw.py
   $ hg --config extensions.throw=throw.py throw 2>&1 | egrep '^\*\*'
   ** Unknown exception encountered with possibly-broken third-party extension throw
   ** which supports versions unknown of Mercurial.
   ** Please disable throw and try your action again.
   ** If that fixes the bug please report it to the extension author.
   ** Python * (glob)
   ** Mercurial Distributed SCM (*) (glob)
   ** Extensions loaded: throw
 
 If the extension specifies a buglink, show that:
   $ echo 'buglink = "http://example.com/bts"' >> throw.py
   $ rm -f throw.pyc throw.pyo
   $ rm -Rf __pycache__
   $ hg --config extensions.throw=throw.py throw 2>&1 | egrep '^\*\*'
   ** Unknown exception encountered with possibly-broken third-party extension throw
   ** which supports versions unknown of Mercurial.
   ** Please disable throw and try your action again.
   ** If that fixes the bug please report it to http://example.com/bts
   ** Python * (glob)
   ** Mercurial Distributed SCM (*) (glob)
   ** Extensions loaded: throw
 
 If the extensions declare outdated versions, accuse the older extension first:
   $ echo "from mercurial import util" >> older.py
   $ echo "util.version = lambda:b'2.2'" >> older.py
   $ echo "testedwith = b'1.9.3'" >> older.py
   $ echo "testedwith = b'2.1.1'" >> throw.py
   $ rm -f throw.pyc throw.pyo
   $ rm -Rf __pycache__
   $ hg --config extensions.throw=throw.py --config extensions.older=older.py \
   >   throw 2>&1 | egrep '^\*\*'
   ** Unknown exception encountered with possibly-broken third-party extension older
   ** which supports versions 1.9 of Mercurial.
   ** Please disable older and try your action again.
   ** If that fixes the bug please report it to the extension author.
   ** Python * (glob)
   ** Mercurial Distributed SCM (version 2.2)
   ** Extensions loaded: throw, older
 
 One extension only tested with older, one only with newer versions:
   $ echo "util.version = lambda:b'2.1'" >> older.py
   $ rm -f older.pyc older.pyo
   $ rm -Rf __pycache__
   $ hg --config extensions.throw=throw.py --config extensions.older=older.py \
   >   throw 2>&1 | egrep '^\*\*'
   ** Unknown exception encountered with possibly-broken third-party extension older
   ** which supports versions 1.9 of Mercurial.
   ** Please disable older and try your action again.
   ** If that fixes the bug please report it to the extension author.
   ** Python * (glob)
   ** Mercurial Distributed SCM (version 2.1)
   ** Extensions loaded: throw, older
 
 Older extension is tested with current version, the other only with newer:
   $ echo "util.version = lambda:b'1.9.3'" >> older.py
   $ rm -f older.pyc older.pyo
   $ rm -Rf __pycache__
   $ hg --config extensions.throw=throw.py --config extensions.older=older.py \
   >   throw 2>&1 | egrep '^\*\*'
   ** Unknown exception encountered with possibly-broken third-party extension throw
   ** which supports versions 2.1 of Mercurial.
   ** Please disable throw and try your action again.
   ** If that fixes the bug please report it to http://example.com/bts
   ** Python * (glob)
   ** Mercurial Distributed SCM (version 1.9.3)
   ** Extensions loaded: throw, older
 
 Ability to point to a different point
   $ hg --config extensions.throw=throw.py --config extensions.older=older.py \
   >   --config ui.supportcontact='Your Local Goat Lenders' throw 2>&1 | egrep '^\*\*'
   ** unknown exception encountered, please report by visiting
   ** Your Local Goat Lenders
   ** Python * (glob)
   ** Mercurial Distributed SCM (*) (glob)
   ** Extensions loaded: throw, older
 
 Declare the version as supporting this hg version, show regular bts link:
   $ hgver=`hg debuginstall -T '{hgver}'`
   $ echo 'testedwith = """'"$hgver"'"""' >> throw.py
   $ if [ -z "$hgver" ]; then
   >   echo "unable to fetch a mercurial version. Make sure __version__ is correct";
   > fi
   $ rm -f throw.pyc throw.pyo
   $ rm -Rf __pycache__
   $ hg --config extensions.throw=throw.py throw 2>&1 | egrep '^\*\*'
   ** unknown exception encountered, please report by visiting
   ** https://mercurial-scm.org/wiki/BugTracker
   ** Python * (glob)
   ** Mercurial Distributed SCM (*) (glob)
   ** Extensions loaded: throw
 
 Patch version is ignored during compatibility check
   $ echo "testedwith = b'3.2'" >> throw.py
   $ echo "util.version = lambda:b'3.2.2'" >> throw.py
   $ rm -f throw.pyc throw.pyo
   $ rm -Rf __pycache__
   $ hg --config extensions.throw=throw.py throw 2>&1 | egrep '^\*\*'
   ** unknown exception encountered, please report by visiting
   ** https://mercurial-scm.org/wiki/BugTracker
   ** Python * (glob)
   ** Mercurial Distributed SCM (*) (glob)
   ** Extensions loaded: throw
 
 Test version number support in 'hg version':
   $ echo '__version__ = (1, 2, 3)' >> throw.py
   $ rm -f throw.pyc throw.pyo
   $ rm -Rf __pycache__
   $ hg version -v
   Mercurial Distributed SCM (version *) (glob)
   (see https://mercurial-scm.org for more information)
   
   Copyright (C) 2005-* Matt Mackall and others (glob)
   This is free software; see the source for copying conditions. There is NO
   warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
   
   Enabled extensions:
   
 
   $ hg version -v --config extensions.throw=throw.py
   Mercurial Distributed SCM (version *) (glob)
   (see https://mercurial-scm.org for more information)
   
   Copyright (C) 2005-* Matt Mackall and others (glob)
   This is free software; see the source for copying conditions. There is NO
   warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
   
   Enabled extensions:
   
     throw  external  1.2.3
   $ echo 'getversion = lambda: b"1.twentythree"' >> throw.py
   $ rm -f throw.pyc throw.pyo
   $ rm -Rf __pycache__
   $ hg version -v --config extensions.throw=throw.py --config extensions.strip=
   Mercurial Distributed SCM (version *) (glob)
   (see https://mercurial-scm.org for more information)
   
   Copyright (C) 2005-* Matt Mackall and others (glob)
   This is free software; see the source for copying conditions. There is NO
   warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
   
   Enabled extensions:
   
     throw  external  1.twentythree
     strip  internal  
 
   $ hg version -q --config extensions.throw=throw.py
   Mercurial Distributed SCM (version *) (glob)
 
 Test template output:
 
   $ hg version --config extensions.strip= -T'{extensions}'
   strip
 
 Test JSON output of version:
 
   $ hg version -Tjson
   [
    {
     "extensions": [],
     "ver": "*" (glob)
    }
   ]
 
   $ hg version --config extensions.throw=throw.py -Tjson
   [
    {
     "extensions": [{"bundled": false, "name": "throw", "ver": "1.twentythree"}],
     "ver": "3.2.2"
    }
   ]
 
   $ hg version --config extensions.strip= -Tjson
   [
    {
     "extensions": [{"bundled": true, "name": "strip", "ver": null}],
     "ver": "*" (glob)
    }
   ]
 
 Test template output of version:
 
   $ hg version --config extensions.throw=throw.py --config extensions.strip= \
   > -T'{extensions % "{name}  {pad(ver, 16)}  ({if(bundled, "internal", "external")})\n"}'
   throw  1.twentythree     (external)
   strip                    (internal)
 
 Refuse to load extensions with minimum version requirements
 
   $ cat > minversion1.py << EOF
   > from mercurial import util
   > util.version = lambda: b'3.5.2'
   > minimumhgversion = b'3.6'
   > EOF
   $ hg --config extensions.minversion=minversion1.py version
   (third party extension minversion requires version 3.6 or newer of Mercurial; disabling)
   Mercurial Distributed SCM (version 3.5.2)
   (see https://mercurial-scm.org for more information)
   
   Copyright (C) 2005-* Matt Mackall and others (glob)
   This is free software; see the source for copying conditions. There is NO
   warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 
   $ cat > minversion2.py << EOF
   > from mercurial import util
   > util.version = lambda: b'3.6'
   > minimumhgversion = b'3.7'
   > EOF
   $ hg --config extensions.minversion=minversion2.py version 2>&1 | egrep '\(third'
   (third party extension minversion requires version 3.7 or newer of Mercurial; disabling)
 
 Can load version that is only off by point release
 
   $ cat > minversion2.py << EOF
   > from mercurial import util
   > util.version = lambda: b'3.6.1'
   > minimumhgversion = b'3.6'
   > EOF
   $ hg --config extensions.minversion=minversion3.py version 2>&1 | egrep '\(third'
   [1]
 
 Can load minimum version identical to current
 
   $ cat > minversion3.py << EOF
   > from mercurial import util
   > util.version = lambda: b'3.5'
   > minimumhgversion = b'3.5'
   > EOF
   $ hg --config extensions.minversion=minversion3.py version 2>&1 | egrep '\(third'
   [1]
 
 Restore HGRCPATH
 
   $ HGRCPATH=$ORGHGRCPATH
   $ export HGRCPATH
 
 Commands handling multiple repositories at a time should invoke only
 "reposetup()" of extensions enabling in the target repository.
 
   $ mkdir reposetup-test
   $ cd reposetup-test
 
   $ cat > $TESTTMP/reposetuptest.py <<EOF
   > from mercurial import extensions
   > def reposetup(ui, repo):
   >     ui.write(b'reposetup() for %s\n' % (repo.root))
   >     ui.flush()
   > EOF
   $ hg init src
   $ echo a > src/a
   $ hg -R src commit -Am '#0 at src/a'
   adding a
   $ echo '[extensions]' >> src/.hg/hgrc
   $ echo '# enable extension locally' >> src/.hg/hgrc
   $ echo "reposetuptest = $TESTTMP/reposetuptest.py" >> src/.hg/hgrc
   $ hg -R src status
   reposetup() for $TESTTMP/reposetup-test/src
   reposetup() for $TESTTMP/reposetup-test/src (chg !)
 
 #if no-extraextensions
   $ hg --cwd src debugextensions
   reposetup() for $TESTTMP/reposetup-test/src
   dodo (untested!)
   dudu (untested!)
   mq
   reposetuptest (untested!)
   strip
 #endif
 
   $ hg clone -U src clone-dst1
   reposetup() for $TESTTMP/reposetup-test/src
   $ hg init push-dst1
   $ hg -q -R src push push-dst1
   reposetup() for $TESTTMP/reposetup-test/src
   $ hg init pull-src1
   $ hg -q -R pull-src1 pull src
   reposetup() for $TESTTMP/reposetup-test/src
 
   $ cat <<EOF >> $HGRCPATH
   > [extensions]
   > # disable extension globally and explicitly
   > reposetuptest = !
   > EOF
   $ hg clone -U src clone-dst2
   reposetup() for $TESTTMP/reposetup-test/src
   $ hg init push-dst2
   $ hg -q -R src push push-dst2
   reposetup() for $TESTTMP/reposetup-test/src
   $ hg init pull-src2
   $ hg -q -R pull-src2 pull src
   reposetup() for $TESTTMP/reposetup-test/src
 
   $ cat <<EOF >> $HGRCPATH
   > [extensions]
   > # enable extension globally
   > reposetuptest = $TESTTMP/reposetuptest.py
   > EOF
   $ hg clone -U src clone-dst3
   reposetup() for $TESTTMP/reposetup-test/src
   reposetup() for $TESTTMP/reposetup-test/clone-dst3
   $ hg init push-dst3
   reposetup() for $TESTTMP/reposetup-test/push-dst3
   $ hg -q -R src push push-dst3
   reposetup() for $TESTTMP/reposetup-test/src
   reposetup() for $TESTTMP/reposetup-test/push-dst3
   $ hg init pull-src3
   reposetup() for $TESTTMP/reposetup-test/pull-src3
   $ hg -q -R pull-src3 pull src
   reposetup() for $TESTTMP/reposetup-test/pull-src3
   reposetup() for $TESTTMP/reposetup-test/src
 
   $ echo '[extensions]' >> src/.hg/hgrc
   $ echo '# disable extension locally' >> src/.hg/hgrc
   $ echo 'reposetuptest = !' >> src/.hg/hgrc
   $ hg clone -U src clone-dst4
   reposetup() for $TESTTMP/reposetup-test/clone-dst4
   $ hg init push-dst4
   reposetup() for $TESTTMP/reposetup-test/push-dst4
   $ hg -q -R src push push-dst4
   reposetup() for $TESTTMP/reposetup-test/push-dst4
   $ hg init pull-src4
   reposetup() for $TESTTMP/reposetup-test/pull-src4
   $ hg -q -R pull-src4 pull src
   reposetup() for $TESTTMP/reposetup-test/pull-src4
 
 disabling in command line overlays with all configuration
   $ hg --config extensions.reposetuptest=! clone -U src clone-dst5
   $ hg --config extensions.reposetuptest=! init push-dst5
   $ hg --config extensions.reposetuptest=! -q -R src push push-dst5
   $ hg --config extensions.reposetuptest=! init pull-src5
   $ hg --config extensions.reposetuptest=! -q -R pull-src5 pull src
 
   $ cat <<EOF >> $HGRCPATH
   > [extensions]
   > # disable extension globally and explicitly
   > reposetuptest = !
   > EOF
   $ hg init parent
   $ hg init parent/sub1
   $ echo 1 > parent/sub1/1
   $ hg -R parent/sub1 commit -Am '#0 at parent/sub1'
   adding 1
   $ hg init parent/sub2
   $ hg init parent/sub2/sub21
   $ echo 21 > parent/sub2/sub21/21
   $ hg -R parent/sub2/sub21 commit -Am '#0 at parent/sub2/sub21'
   adding 21
   $ cat > parent/sub2/.hgsub <<EOF
   > sub21 = sub21
   > EOF
   $ hg -R parent/sub2 commit -Am '#0 at parent/sub2'
   adding .hgsub
   $ hg init parent/sub3
   $ echo 3 > parent/sub3/3
   $ hg -R parent/sub3 commit -Am '#0 at parent/sub3'
   adding 3
   $ cat > parent/.hgsub <<EOF
   > sub1 = sub1
   > sub2 = sub2
   > sub3 = sub3
   > EOF
   $ hg -R parent commit -Am '#0 at parent'
   adding .hgsub
   $ echo '[extensions]' >> parent/.hg/hgrc
   $ echo '# enable extension locally' >> parent/.hg/hgrc
   $ echo "reposetuptest = $TESTTMP/reposetuptest.py" >> parent/.hg/hgrc
   $ cp parent/.hg/hgrc parent/sub2/.hg/hgrc
   $ hg -R parent status -S -A
   reposetup() for $TESTTMP/reposetup-test/parent
   reposetup() for $TESTTMP/reposetup-test/parent/sub2
   C .hgsub
   C .hgsubstate
   C sub1/1
   C sub2/.hgsub
   C sub2/.hgsubstate
   C sub2/sub21/21
   C sub3/3
 
   $ cd ..
 
 Prohibit registration of commands that don't use @command (issue5137)
 
   $ hg init deprecated
   $ cd deprecated
 
   $ cat <<EOF > deprecatedcmd.py
   > def deprecatedcmd(repo, ui):
   >     pass
   > cmdtable = {
   >     b'deprecatedcmd': (deprecatedcmd, [], b''),
   > }
   > EOF
   $ cat <<EOF > .hg/hgrc
   > [extensions]
   > deprecatedcmd = `pwd`/deprecatedcmd.py
   > mq = !
   > hgext.mq = !
   > hgext/mq = !
   > EOF
 
   $ hg deprecatedcmd > /dev/null
   *** failed to import extension deprecatedcmd from $TESTTMP/deprecated/deprecatedcmd.py: missing attributes: norepo, optionalrepo, inferrepo
   *** (use @command decorator to register 'deprecatedcmd')
   hg: unknown command 'deprecatedcmd'
   (use 'hg help' for a list of commands)
   [255]
 
  the extension shouldn't be loaded at all so the mq works:
 
   $ hg qseries --config extensions.mq= > /dev/null
   *** failed to import extension deprecatedcmd from $TESTTMP/deprecated/deprecatedcmd.py: missing attributes: norepo, optionalrepo, inferrepo
   *** (use @command decorator to register 'deprecatedcmd')
 
   $ cd ..
 
 Test synopsis and docstring extending
 
   $ hg init exthelp
   $ cat > exthelp.py <<EOF
   > from mercurial import commands, extensions
   > def exbookmarks(orig, *args, **opts):
   >     return orig(*args, **opts)
   > def uisetup(ui):
   >     synopsis = b' GREPME [--foo] [-x]'
   >     docstring = '''
   >     GREPME make sure that this is in the help!
   >     '''
   >     extensions.wrapcommand(commands.table, b'bookmarks', exbookmarks,
   >                            synopsis, docstring)
   > EOF
   $ abspath=`pwd`/exthelp.py
   $ echo '[extensions]' >> $HGRCPATH
   $ echo "exthelp = $abspath" >> $HGRCPATH
   $ cd exthelp
   $ hg help bookmarks | grep GREPME
   hg bookmarks [OPTIONS]... [NAME]... GREPME [--foo] [-x]
       GREPME make sure that this is in the help!
   $ cd ..
 
 Show deprecation warning for the use of cmdutil.command
 
   $ cat > nonregistrar.py <<EOF
   > from mercurial import cmdutil
   > cmdtable = {}
   > command = cmdutil.command(cmdtable)
   > @command(b'foo', [], norepo=True)
   > def foo(ui):
   >     pass
   > EOF
 
 Prohibit the use of unicode strings as the default value of options
 
   $ hg init $TESTTMP/opt-unicode-default
 
   $ cat > $TESTTMP/test_unicode_default_value.py << EOF
   > from mercurial import registrar
   > cmdtable = {}
   > command = registrar.command(cmdtable)
   > @command(b'dummy', [(b'', b'opt', u'value', u'help')], 'ext [OPTIONS]')
   > def ext(*args, **opts):
   >     print(opts[b'opt'])
   > EOF
   $ cat > $TESTTMP/opt-unicode-default/.hg/hgrc << EOF
   > [extensions]
   > test_unicode_default_value = $TESTTMP/test_unicode_default_value.py
   > EOF
   $ hg -R $TESTTMP/opt-unicode-default dummy
   *** failed to import extension test_unicode_default_value from $TESTTMP/test_unicode_default_value.py: unicode u'value' found in cmdtable.dummy
   *** (use b'' to make it byte string)
   hg: unknown command 'dummy'
   (did you mean summary?)
   [255]

tests/test-help.t

@@ -1,3719 +1,3720 b''
 Short help:
 
   $ hg
   Mercurial Distributed SCM
   
   basic commands:
   
    add           add the specified files on the next commit
    annotate      show changeset information by line for each file
    clone         make a copy of an existing repository
    commit        commit the specified files or all outstanding changes
    diff          diff repository (or selected files)
    export        dump the header and diffs for one or more changesets
    forget        forget the specified files on the next commit
    init          create a new repository in the given directory
    log           show revision history of entire repository or files
    merge         merge another revision into working directory
    pull          pull changes from the specified source
    push          push changes to the specified destination
    remove        remove the specified files on the next commit
    serve         start stand-alone webserver
    status        show changed files in the working directory
    summary       summarize working directory state
    update        update working directory (or switch revisions)
   
   (use 'hg help' for the full list of commands or 'hg -v' for details)
 
   $ hg -q
    add           add the specified files on the next commit
    annotate      show changeset information by line for each file
    clone         make a copy of an existing repository
    commit        commit the specified files or all outstanding changes
    diff          diff repository (or selected files)
    export        dump the header and diffs for one or more changesets
    forget        forget the specified files on the next commit
    init          create a new repository in the given directory
    log           show revision history of entire repository or files
    merge         merge another revision into working directory
    pull          pull changes from the specified source
    push          push changes to the specified destination
    remove        remove the specified files on the next commit
    serve         start stand-alone webserver
    status        show changed files in the working directory
    summary       summarize working directory state
    update        update working directory (or switch revisions)
 
 Extra extensions will be printed in help output in a non-reliable order since
 the extension is unknown.
 #if no-extraextensions
 
   $ hg help
   Mercurial Distributed SCM
   
   list of commands:
   
    add           add the specified files on the next commit
    addremove     add all new files, delete all missing files
    annotate      show changeset information by line for each file
    archive       create an unversioned archive of a repository revision
    backout       reverse effect of earlier changeset
    bisect        subdivision search of changesets
    bookmarks     create a new bookmark or list existing bookmarks
    branch        set or show the current branch name
    branches      list repository named branches
    bundle        create a bundle file
    cat           output the current or given revision of files
    clone         make a copy of an existing repository
    commit        commit the specified files or all outstanding changes
    config        show combined config settings from all hgrc files
    copy          mark files as copied for the next commit
    diff          diff repository (or selected files)
    export        dump the header and diffs for one or more changesets
    files         list tracked files
    forget        forget the specified files on the next commit
    graft         copy changes from other branches onto the current branch
    grep          search revision history for a pattern in specified files
    heads         show branch heads
    help          show help for a given topic or a help overview
    identify      identify the working directory or specified revision
    import        import an ordered set of patches
    incoming      show new changesets found in source
    init          create a new repository in the given directory
    log           show revision history of entire repository or files
    manifest      output the current or given revision of the project manifest
    merge         merge another revision into working directory
    outgoing      show changesets not found in the destination
    paths         show aliases for remote repositories
    phase         set or show the current phase name
    pull          pull changes from the specified source
    push          push changes to the specified destination
    recover       roll back an interrupted transaction
    remove        remove the specified files on the next commit
    rename        rename files; equivalent of copy + remove
    resolve       redo merges or set/view the merge status of files
    revert        restore files to their checkout state
    root          print the root (top) of the current working directory
    serve         start stand-alone webserver
    status        show changed files in the working directory
    summary       summarize working directory state
    tag           add one or more tags for the current or given revision
    tags          list repository tags
    unbundle      apply one or more bundle files
    update        update working directory (or switch revisions)
    verify        verify the integrity of the repository
    version       output version and copyright information
   
   additional help topics:
   
    bundlespec    Bundle File Formats
    color         Colorizing Outputs
    config        Configuration Files
    dates         Date Formats
    deprecated    Deprecated Features
    diffs         Diff Formats
    environment   Environment Variables
    extensions    Using Additional Features
    filesets      Specifying File Sets
    flags         Command-line flags
    glossary      Glossary
    hgignore      Syntax for Mercurial Ignore Files
    hgweb         Configuring hgweb
    internals     Technical implementation topics
    merge-tools   Merge Tools
    pager         Pager Support
    patterns      File Name Patterns
    phases        Working with Phases
    revisions     Specifying Revisions
    scripting     Using Mercurial from scripts and automation
    subrepos      Subrepositories
    templating    Template Usage
    urls          URL Paths
   
   (use 'hg help -v' to show built-in aliases and global options)
 
   $ hg -q help
    add           add the specified files on the next commit
    addremove     add all new files, delete all missing files
    annotate      show changeset information by line for each file
    archive       create an unversioned archive of a repository revision
    backout       reverse effect of earlier changeset
    bisect        subdivision search of changesets
    bookmarks     create a new bookmark or list existing bookmarks
    branch        set or show the current branch name
    branches      list repository named branches
    bundle        create a bundle file
    cat           output the current or given revision of files
    clone         make a copy of an existing repository
    commit        commit the specified files or all outstanding changes
    config        show combined config settings from all hgrc files
    copy          mark files as copied for the next commit
    diff          diff repository (or selected files)
    export        dump the header and diffs for one or more changesets
    files         list tracked files
    forget        forget the specified files on the next commit
    graft         copy changes from other branches onto the current branch
    grep          search revision history for a pattern in specified files
    heads         show branch heads
    help          show help for a given topic or a help overview
    identify      identify the working directory or specified revision
    import        import an ordered set of patches
    incoming      show new changesets found in source
    init          create a new repository in the given directory
    log           show revision history of entire repository or files
    manifest      output the current or given revision of the project manifest
    merge         merge another revision into working directory
    outgoing      show changesets not found in the destination
    paths         show aliases for remote repositories
    phase         set or show the current phase name
    pull          pull changes from the specified source
    push          push changes to the specified destination
    recover       roll back an interrupted transaction
    remove        remove the specified files on the next commit
    rename        rename files; equivalent of copy + remove
    resolve       redo merges or set/view the merge status of files
    revert        restore files to their checkout state
    root          print the root (top) of the current working directory
    serve         start stand-alone webserver
    status        show changed files in the working directory
    summary       summarize working directory state
    tag           add one or more tags for the current or given revision
    tags          list repository tags
    unbundle      apply one or more bundle files
    update        update working directory (or switch revisions)
    verify        verify the integrity of the repository
    version       output version and copyright information
   
   additional help topics:
   
    bundlespec    Bundle File Formats
    color         Colorizing Outputs
    config        Configuration Files
    dates         Date Formats
    deprecated    Deprecated Features
    diffs         Diff Formats
    environment   Environment Variables
    extensions    Using Additional Features
    filesets      Specifying File Sets
    flags         Command-line flags
    glossary      Glossary
    hgignore      Syntax for Mercurial Ignore Files
    hgweb         Configuring hgweb
    internals     Technical implementation topics
    merge-tools   Merge Tools
    pager         Pager Support
    patterns      File Name Patterns
    phases        Working with Phases
    revisions     Specifying Revisions
    scripting     Using Mercurial from scripts and automation
    subrepos      Subrepositories
    templating    Template Usage
    urls          URL Paths
 
 Test extension help:
   $ hg help extensions --config extensions.rebase= --config extensions.children=
   Using Additional Features
   """""""""""""""""""""""""
   
       Mercurial has the ability to add new features through the use of
       extensions. Extensions may add new commands, add options to existing
       commands, change the default behavior of commands, or implement hooks.
   
       To enable the "foo" extension, either shipped with Mercurial or in the
       Python search path, create an entry for it in your configuration file,
       like this:
   
         [extensions]
         foo =
   
       You may also specify the full path to an extension:
   
         [extensions]
         myfeature = ~/.hgext/myfeature.py
   
       See 'hg help config' for more information on configuration files.
   
       Extensions are not loaded by default for a variety of reasons: they can
       increase startup overhead; they may be meant for advanced usage only; they
       may provide potentially dangerous abilities (such as letting you destroy
       or modify history); they might not be ready for prime time; or they may
       alter some usual behaviors of stock Mercurial. It is thus up to the user
       to activate extensions as needed.
   
       To explicitly disable an extension enabled in a configuration file of
       broader scope, prepend its path with !:
   
         [extensions]
         # disabling extension bar residing in /path/to/extension/bar.py
         bar = !/path/to/extension/bar.py
         # ditto, but no path was supplied for extension baz
         baz = !
   
       enabled extensions:
   
        children      command to display child changesets (DEPRECATED)
        rebase        command to move sets of revisions to a different ancestor
   
       disabled extensions:
   
        acl           hooks for controlling repository access
        blackbox      log repository events to a blackbox for debugging
        bugzilla      hooks for integrating with the Bugzilla bug tracker
        censor        erase file content at a given revision
        churn         command to display statistics about repository history
        clonebundles  advertise pre-generated bundles to seed clones
        convert       import revisions from foreign VCS repositories into
                      Mercurial
        eol           automatically manage newlines in repository files
        extdiff       command to allow external programs to compare revisions
        factotum      http authentication with factotum
        githelp       try mapping git commands to Mercurial commands
        gpg           commands to sign and verify changesets
        hgk           browse the repository in a graphical way
        highlight     syntax highlighting for hgweb (requires Pygments)
        histedit      interactive history editing
        keyword       expand keywords in tracked files
        largefiles    track large binary files
        mq            manage a stack of patches
        notify        hooks for sending email push notifications
        patchbomb     command to send changesets as (a series of) patch emails
        purge         command to delete untracked files from the working
                      directory
        relink        recreates hardlinks between repository clones
        schemes       extend schemes with shortcuts to repository swarms
        share         share a common history between several working directories
        shelve        save and restore changes to the working directory
        strip         strip changesets and their descendants from history
        transplant    command to transplant changesets from another branch
        win32mbcs     allow the use of MBCS paths with problematic encodings
        zeroconf      discover and advertise repositories on the local network
 
 #endif
 
 Verify that deprecated extensions are included if --verbose:
 
   $ hg -v help extensions | grep children
        children      command to display child changesets (DEPRECATED)
 
 Verify that extension keywords appear in help templates
 
   $ hg help --config extensions.transplant= templating|grep transplant > /dev/null
 
 Test short command list with verbose option
 
   $ hg -v help shortlist
   Mercurial Distributed SCM
   
   basic commands:
   
    add           add the specified files on the next commit
    annotate, blame
                  show changeset information by line for each file
    clone         make a copy of an existing repository
    commit, ci    commit the specified files or all outstanding changes
    diff          diff repository (or selected files)
    export        dump the header and diffs for one or more changesets
    forget        forget the specified files on the next commit
    init          create a new repository in the given directory
    log, history  show revision history of entire repository or files
    merge         merge another revision into working directory
    pull          pull changes from the specified source
    push          push changes to the specified destination
    remove, rm    remove the specified files on the next commit
    serve         start stand-alone webserver
    status, st    show changed files in the working directory
    summary, sum  summarize working directory state
    update, up, checkout, co
                  update working directory (or switch revisions)
   
   global options ([+] can be repeated):
   
    -R --repository REPO   repository root directory or name of overlay bundle
                           file
       --cwd DIR           change working directory
    -y --noninteractive    do not prompt, automatically pick the first choice for
                           all prompts
    -q --quiet             suppress output
    -v --verbose           enable additional output
       --color TYPE        when to colorize (boolean, always, auto, never, or
                           debug)
       --config CONFIG [+] set/override config option (use 'section.name=value')
       --debug             enable debugging output
       --debugger          start debugger
       --encoding ENCODE   set the charset encoding (default: ascii)
       --encodingmode MODE set the charset encoding mode (default: strict)
       --traceback         always print a traceback on exception
       --time              time how long the command takes
       --profile           print command execution profile
       --version           output version information and exit
    -h --help              display help and exit
       --hidden            consider hidden changesets
       --pager TYPE        when to paginate (boolean, always, auto, or never)
                           (default: auto)
   
   (use 'hg help' for the full list of commands)
 
   $ hg add -h
   hg add [OPTION]... [FILE]...
   
   add the specified files on the next commit
   
       Schedule files to be version controlled and added to the repository.
   
       The files will be added to the repository at the next commit. To undo an
       add before that, see 'hg forget'.
   
       If no names are given, add all files to the repository (except files
       matching ".hgignore").
   
       Returns 0 if all files are successfully added.
   
   options ([+] can be repeated):
   
    -I --include PATTERN [+] include names matching the given patterns
    -X --exclude PATTERN [+] exclude names matching the given patterns
    -S --subrepos            recurse into subrepositories
    -n --dry-run             do not perform actions, just print output
   
   (some details hidden, use --verbose to show complete help)
 
 Verbose help for add
 
   $ hg add -hv
   hg add [OPTION]... [FILE]...
   
   add the specified files on the next commit
   
       Schedule files to be version controlled and added to the repository.
   
       The files will be added to the repository at the next commit. To undo an
       add before that, see 'hg forget'.
   
       If no names are given, add all files to the repository (except files
       matching ".hgignore").
   
       Examples:
   
         - New (unknown) files are added automatically by 'hg add':
   
             $ ls
             foo.c
             $ hg status
             ? foo.c
             $ hg add
             adding foo.c
             $ hg status
             A foo.c
   
         - Specific files to be added can be specified:
   
             $ ls
             bar.c  foo.c
             $ hg status
             ? bar.c
             ? foo.c
             $ hg add bar.c
             $ hg status
             A bar.c
             ? foo.c
   
       Returns 0 if all files are successfully added.
   
   options ([+] can be repeated):
   
    -I --include PATTERN [+] include names matching the given patterns
    -X --exclude PATTERN [+] exclude names matching the given patterns
    -S --subrepos            recurse into subrepositories
    -n --dry-run             do not perform actions, just print output
   
   global options ([+] can be repeated):
   
    -R --repository REPO   repository root directory or name of overlay bundle
                           file
       --cwd DIR           change working directory
    -y --noninteractive    do not prompt, automatically pick the first choice for
                           all prompts
    -q --quiet             suppress output
    -v --verbose           enable additional output
       --color TYPE        when to colorize (boolean, always, auto, never, or
                           debug)
       --config CONFIG [+] set/override config option (use 'section.name=value')
       --debug             enable debugging output
       --debugger          start debugger
       --encoding ENCODE   set the charset encoding (default: ascii)
       --encodingmode MODE set the charset encoding mode (default: strict)
       --traceback         always print a traceback on exception
       --time              time how long the command takes
       --profile           print command execution profile
       --version           output version information and exit
    -h --help              display help and exit
       --hidden            consider hidden changesets
       --pager TYPE        when to paginate (boolean, always, auto, or never)
                           (default: auto)
 
 Test the textwidth config option
 
   $ hg root -h  --config ui.textwidth=50
   hg root
   
   print the root (top) of the current working
   directory
   
       Print the root directory of the current
       repository.
   
       Returns 0 on success.
   
   (some details hidden, use --verbose to show
   complete help)
 
 Test help option with version option
 
   $ hg add -h --version
   Mercurial Distributed SCM (version *) (glob)
   (see https://mercurial-scm.org for more information)
   
   Copyright (C) 2005-* Matt Mackall and others (glob)
   This is free software; see the source for copying conditions. There is NO
   warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 
   $ hg add --skjdfks
   hg add: option --skjdfks not recognized
   hg add [OPTION]... [FILE]...
   
   add the specified files on the next commit
   
   options ([+] can be repeated):
   
    -I --include PATTERN [+] include names matching the given patterns
    -X --exclude PATTERN [+] exclude names matching the given patterns
    -S --subrepos            recurse into subrepositories
    -n --dry-run             do not perform actions, just print output
   
   (use 'hg add -h' to show more help)
   [255]
 
 Test ambiguous command help
 
   $ hg help ad
   list of commands:
   
    add           add the specified files on the next commit
    addremove     add all new files, delete all missing files
   
   (use 'hg help -v ad' to show built-in aliases and global options)
 
 Test command without options
 
   $ hg help verify
   hg verify
   
   verify the integrity of the repository
   
       Verify the integrity of the current repository.
   
       This will perform an extensive check of the repository's integrity,
       validating the hashes and checksums of each entry in the changelog,
       manifest, and tracked files, as well as the integrity of their crosslinks
       and indices.
   
       Please see https://mercurial-scm.org/wiki/RepositoryCorruption for more
       information about recovery from corruption of the repository.
   
       Returns 0 on success, 1 if errors are encountered.
   
   (some details hidden, use --verbose to show complete help)
 
   $ hg help diff
   hg diff [OPTION]... ([-c REV] | [-r REV1 [-r REV2]]) [FILE]...
   
   diff repository (or selected files)
   
       Show differences between revisions for the specified files.
   
       Differences between files are shown using the unified diff format.
   
       Note:
          'hg diff' may generate unexpected results for merges, as it will
          default to comparing against the working directory's first parent
          changeset if no revisions are specified.
   
       When two revision arguments are given, then changes are shown between
       those revisions. If only one revision is specified then that revision is
       compared to the working directory, and, when no revisions are specified,
       the working directory files are compared to its first parent.
   
       Alternatively you can specify -c/--change with a revision to see the
       changes in that changeset relative to its first parent.
   
       Without the -a/--text option, diff will avoid generating diffs of files it
       detects as binary. With -a, diff will generate a diff anyway, probably
       with undesirable results.
   
       Use the -g/--git option to generate diffs in the git extended diff format.
       For more information, read 'hg help diffs'.
   
       Returns 0 on success.
   
   options ([+] can be repeated):
   
    -r --rev REV [+]         revision
    -c --change REV          change made by revision
    -a --text                treat all files as text
    -g --git                 use git extended diff format
       --binary              generate binary diffs in git mode (default)
       --nodates             omit dates from diff headers
       --noprefix            omit a/ and b/ prefixes from filenames
    -p --show-function       show which function each change is in
       --reverse             produce a diff that undoes the changes
    -w --ignore-all-space    ignore white space when comparing lines
    -b --ignore-space-change ignore changes in the amount of white space
    -B --ignore-blank-lines  ignore changes whose lines are all blank
    -Z --ignore-space-at-eol ignore changes in whitespace at EOL
    -U --unified NUM         number of lines of context to show
       --stat                output diffstat-style summary of changes
       --root DIR            produce diffs relative to subdirectory
    -I --include PATTERN [+] include names matching the given patterns
    -X --exclude PATTERN [+] exclude names matching the given patterns
    -S --subrepos            recurse into subrepositories
   
   (some details hidden, use --verbose to show complete help)
 
   $ hg help status
   hg status [OPTION]... [FILE]...
   
   aliases: st
   
   show changed files in the working directory
   
       Show status of files in the repository. If names are given, only files
       that match are shown. Files that are clean or ignored or the source of a
       copy/move operation, are not listed unless -c/--clean, -i/--ignored,
       -C/--copies or -A/--all are given. Unless options described with "show
       only ..." are given, the options -mardu are used.
   
       Option -q/--quiet hides untracked (unknown and ignored) files unless
       explicitly requested with -u/--unknown or -i/--ignored.
   
       Note:
          'hg status' may appear to disagree with diff if permissions have
          changed or a merge has occurred. The standard diff format does not
          report permission changes and diff only reports changes relative to one
          merge parent.
   
       If one revision is given, it is used as the base revision. If two
       revisions are given, the differences between them are shown. The --change
       option can also be used as a shortcut to list the changed files of a
       revision from its first parent.
   
       The codes used to show the status of files are:
   
         M = modified
         A = added
         R = removed
         C = clean
         ! = missing (deleted by non-hg command, but still tracked)
         ? = not tracked
         I = ignored
           = origin of the previous file (with --copies)
   
       Returns 0 on success.
   
   options ([+] can be repeated):
   
    -A --all                 show status of all files
    -m --modified            show only modified files
    -a --added               show only added files
    -r --removed             show only removed files
    -d --deleted             show only deleted (but tracked) files
    -c --clean               show only files without changes
    -u --unknown             show only unknown (not tracked) files
    -i --ignored             show only ignored files
    -n --no-status           hide status prefix
    -C --copies              show source of copied files
    -0 --print0              end filenames with NUL, for use with xargs
       --rev REV [+]         show difference from revision
       --change REV          list the changed files of a revision
    -I --include PATTERN [+] include names matching the given patterns
    -X --exclude PATTERN [+] exclude names matching the given patterns
    -S --subrepos            recurse into subrepositories
+   -T --template TEMPLATE   display with template
   
   (some details hidden, use --verbose to show complete help)
 
   $ hg -q help status
   hg status [OPTION]... [FILE]...
   
   show changed files in the working directory
 
   $ hg help foo
   abort: no such help topic: foo
   (try 'hg help --keyword foo')
   [255]
 
   $ hg skjdfks
   hg: unknown command 'skjdfks'
   (use 'hg help' for a list of commands)
   [255]
 
 Typoed command gives suggestion
   $ hg puls
   hg: unknown command 'puls'
   (did you mean one of pull, push?)
   [255]
 
 Not enabled extension gets suggested
 
   $ hg rebase
   hg: unknown command 'rebase'
   'rebase' is provided by the following extension:
   
       rebase        command to move sets of revisions to a different ancestor
   
   (use 'hg help extensions' for information on enabling extensions)
   [255]
 
 Disabled extension gets suggested
   $ hg --config extensions.rebase=! rebase
   hg: unknown command 'rebase'
   'rebase' is provided by the following extension:
   
       rebase        command to move sets of revisions to a different ancestor
   
   (use 'hg help extensions' for information on enabling extensions)
   [255]
 
 Make sure that we don't run afoul of the help system thinking that
 this is a section and erroring out weirdly.
 
   $ hg .log
   hg: unknown command '.log'
   (did you mean log?)
   [255]
 
   $ hg log.
   hg: unknown command 'log.'
   (did you mean log?)
   [255]
   $ hg pu.lh
   hg: unknown command 'pu.lh'
   (did you mean one of pull, push?)
   [255]
 
   $ cat > helpext.py <<EOF
   > import os
   > from mercurial import commands, fancyopts, registrar
   > 
   > def func(arg):
   >     return '%sfoo' % arg
   > class customopt(fancyopts.customopt):
   >     def newstate(self, oldstate, newparam, abort):
   >         return '%sbar' % oldstate
   > cmdtable = {}
   > command = registrar.command(cmdtable)
   > 
   > @command(b'nohelp',
   >     [(b'', b'longdesc', 3, b'x'*67),
   >     (b'n', b'', None, b'normal desc'),
   >     (b'', b'newline', b'', b'line1\nline2'),
   >     (b'', b'callableopt', func, b'adds foo'),
   >     (b'', b'customopt', customopt(''), b'adds bar'),
   >     (b'', b'customopt-withdefault', customopt('foo'), b'adds bar')],
   >     b'hg nohelp',
   >     norepo=True)
   > @command(b'debugoptADV', [(b'', b'aopt', None, b'option is (ADVANCED)')])
   > @command(b'debugoptDEP', [(b'', b'dopt', None, b'option is (DEPRECATED)')])
   > @command(b'debugoptEXP', [(b'', b'eopt', None, b'option is (EXPERIMENTAL)')])
   > def nohelp(ui, *args, **kwargs):
   >     pass
   > 
   > def uisetup(ui):
   >     ui.setconfig(b'alias', b'shellalias', b'!echo hi', b'helpext')
   >     ui.setconfig(b'alias', b'hgalias', b'summary', b'helpext')
   > 
   > EOF
   $ echo '[extensions]' >> $HGRCPATH
   $ echo "helpext = `pwd`/helpext.py" >> $HGRCPATH
 
 Test for aliases
 
   $ hg help hgalias
   hg hgalias [--remote]
   
   alias for: hg summary
   
   summarize working directory state
   
       This generates a brief summary of the working directory state, including
       parents, branch, commit status, phase and available updates.
   
       With the --remote option, this will check the default paths for incoming
       and outgoing changes. This can be time-consuming.
   
       Returns 0 on success.
   
   defined by: helpext
   
   options:
   
     --remote check for push and pull
   
   (some details hidden, use --verbose to show complete help)
 
   $ hg help shellalias
   hg shellalias
   
   shell alias for: echo hi
   
   (no help text available)
   
   defined by: helpext
   
   (some details hidden, use --verbose to show complete help)
 
 Test command with no help text
 
   $ hg help nohelp
   hg nohelp
   
   (no help text available)
   
   options:
   
       --longdesc VALUE
                                     xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
                                     xxxxxxxxxxxxxxxxxxxxxxx (default: 3)
    -n --                            normal desc
       --newline VALUE               line1 line2
       --callableopt VALUE           adds foo
       --customopt VALUE             adds bar
       --customopt-withdefault VALUE adds bar (default: foo)
   
   (some details hidden, use --verbose to show complete help)
 
   $ hg help -k nohelp
   Commands:
   
    nohelp hg nohelp
   
   Extension Commands:
   
    nohelp (no help text available)
 
 Test that default list of commands omits extension commands
 
 #if no-extraextensions
 
   $ hg help
   Mercurial Distributed SCM
   
   list of commands:
   
    add           add the specified files on the next commit
    addremove     add all new files, delete all missing files
    annotate      show changeset information by line for each file
    archive       create an unversioned archive of a repository revision
    backout       reverse effect of earlier changeset
    bisect        subdivision search of changesets
    bookmarks     create a new bookmark or list existing bookmarks
    branch        set or show the current branch name
    branches      list repository named branches
    bundle        create a bundle file
    cat           output the current or given revision of files
    clone         make a copy of an existing repository
    commit        commit the specified files or all outstanding changes
    config        show combined config settings from all hgrc files
    copy          mark files as copied for the next commit
    diff          diff repository (or selected files)
    export        dump the header and diffs for one or more changesets
    files         list tracked files
    forget        forget the specified files on the next commit
    graft         copy changes from other branches onto the current branch
    grep          search revision history for a pattern in specified files
    heads         show branch heads
    help          show help for a given topic or a help overview
    identify      identify the working directory or specified revision
    import        import an ordered set of patches
    incoming      show new changesets found in source
    init          create a new repository in the given directory
    log           show revision history of entire repository or files
    manifest      output the current or given revision of the project manifest
    merge         merge another revision into working directory
    outgoing      show changesets not found in the destination
    paths         show aliases for remote repositories
    phase         set or show the current phase name
    pull          pull changes from the specified source
    push          push changes to the specified destination
    recover       roll back an interrupted transaction
    remove        remove the specified files on the next commit
    rename        rename files; equivalent of copy + remove
    resolve       redo merges or set/view the merge status of files
    revert        restore files to their checkout state
    root          print the root (top) of the current working directory
    serve         start stand-alone webserver
    status        show changed files in the working directory
    summary       summarize working directory state
    tag           add one or more tags for the current or given revision
    tags          list repository tags
    unbundle      apply one or more bundle files
    update        update working directory (or switch revisions)
    verify        verify the integrity of the repository
    version       output version and copyright information
   
   enabled extensions:
   
    helpext       (no help text available)
   
   additional help topics:
   
    bundlespec    Bundle File Formats
    color         Colorizing Outputs
    config        Configuration Files
    dates         Date Formats
    deprecated    Deprecated Features
    diffs         Diff Formats
    environment   Environment Variables
    extensions    Using Additional Features
    filesets      Specifying File Sets
    flags         Command-line flags
    glossary      Glossary
    hgignore      Syntax for Mercurial Ignore Files
    hgweb         Configuring hgweb
    internals     Technical implementation topics
    merge-tools   Merge Tools
    pager         Pager Support
    patterns      File Name Patterns
    phases        Working with Phases
    revisions     Specifying Revisions
    scripting     Using Mercurial from scripts and automation
    subrepos      Subrepositories
    templating    Template Usage
    urls          URL Paths
   
   (use 'hg help -v' to show built-in aliases and global options)
 
 #endif
 
 Test list of internal help commands
 
   $ hg help debug
   debug commands (internal and unsupported):
   
    debugancestor
                  find the ancestor revision of two revisions in a given index
    debugapplystreamclonebundle
                  apply a stream clone bundle file
    debugbuilddag
                  builds a repo with a given DAG from scratch in the current
                  empty repo
    debugbundle   lists the contents of a bundle
    debugcapabilities
                  lists the capabilities of a remote peer
    debugcheckstate
                  validate the correctness of the current dirstate
    debugcolor    show available color, effects or style
    debugcommands
                  list all available commands and options
    debugcomplete
                  returns the completion list associated with the given command
    debugcreatestreamclonebundle
                  create a stream clone bundle file
    debugdag      format the changelog or an index DAG as a concise textual
                  description
    debugdata     dump the contents of a data file revision
    debugdate     parse and display a date
    debugdeltachain
                  dump information about delta chains in a revlog
    debugdirstate
                  show the contents of the current dirstate
    debugdiscovery
                  runs the changeset discovery protocol in isolation
    debugdownload
                  download a resource using Mercurial logic and config
    debugextensions
                  show information about active extensions
    debugfileset  parse and apply a fileset specification
    debugformat   display format information about the current repository
    debugfsinfo   show information detected about current filesystem
    debuggetbundle
                  retrieves a bundle from a repo
    debugignore   display the combined ignore pattern and information about
                  ignored files
    debugindex    dump index data for a storage primitive
    debugindexdot
                  dump an index DAG as a graphviz dot file
    debuginstall  test Mercurial installation
    debugknown    test whether node ids are known to a repo
    debuglocks    show or modify state of locks
    debugmanifestfulltextcache
                  show, clear or amend the contents of the manifest fulltext
                  cache
    debugmergestate
                  print merge state
    debugnamecomplete
                  complete "names" - tags, open branch names, bookmark names
    debugobsolete
                  create arbitrary obsolete marker
    debugoptADV   (no help text available)
    debugoptDEP   (no help text available)
    debugoptEXP   (no help text available)
    debugpathcomplete
                  complete part or all of a tracked path
    debugpeer     establish a connection to a peer repository
    debugpickmergetool
                  examine which merge tool is chosen for specified file
    debugpushkey  access the pushkey key/value protocol
    debugpvec     (no help text available)
    debugrebuilddirstate
                  rebuild the dirstate as it would look like for the given
                  revision
    debugrebuildfncache
                  rebuild the fncache file
    debugrename   dump rename information
    debugrevlog   show data and statistics about a revlog
    debugrevlogindex
                  dump the contents of a revlog index
    debugrevspec  parse and apply a revision specification
    debugserve    run a server with advanced settings
    debugsetparents
                  manually set the parents of the current working directory
    debugssl      test a secure connection to a server
    debugsub      (no help text available)
    debugsuccessorssets
                  show set of successors for revision
    debugtemplate
                  parse and apply a template
    debuguigetpass
                  show prompt to type password
    debuguiprompt
                  show plain prompt
    debugupdatecaches
                  warm all known caches in the repository
    debugupgraderepo
                  upgrade a repository to use different features
    debugwalk     show how files match on given patterns
    debugwhyunstable
                  explain instabilities of a changeset
    debugwireargs
                  (no help text available)
    debugwireproto
                  send wire protocol commands to a server
   
   (use 'hg help -v debug' to show built-in aliases and global options)
 
 internals topic renders index of available sub-topics
 
   $ hg help internals
   Technical implementation topics
   """""""""""""""""""""""""""""""
   
       To access a subtopic, use "hg help internals.{subtopic-name}"
   
        bundle2       Bundle2
        bundles       Bundles
        cbor          CBOR
        censor        Censor
        changegroups  Changegroups
        config        Config Registrar
        requirements  Repository Requirements
        revlogs       Revision Logs
        wireprotocol  Wire Protocol
        wireprotocolrpc
                      Wire Protocol RPC
        wireprotocolv2
                      Wire Protocol Version 2
 
 sub-topics can be accessed
 
   $ hg help internals.changegroups
   Changegroups
   """"""""""""
   
       Changegroups are representations of repository revlog data, specifically
       the changelog data, root/flat manifest data, treemanifest data, and
       filelogs.
   
       There are 3 versions of changegroups: "1", "2", and "3". From a high-
       level, versions "1" and "2" are almost exactly the same, with the only
       difference being an additional item in the *delta header*.  Version "3"
       adds support for revlog flags in the *delta header* and optionally
       exchanging treemanifests (enabled by setting an option on the
       "changegroup" part in the bundle2).
   
       Changegroups when not exchanging treemanifests consist of 3 logical
       segments:
   
         +---------------------------------+
         |           |          |          |
         | changeset | manifest | filelogs |
         |           |          |          |
         |           |          |          |
         +---------------------------------+
   
       When exchanging treemanifests, there are 4 logical segments:
   
         +-------------------------------------------------+
         |           |          |               |          |
         | changeset |   root   | treemanifests | filelogs |
         |           | manifest |               |          |
         |           |          |               |          |
         +-------------------------------------------------+
   
       The principle building block of each segment is a *chunk*. A *chunk* is a
       framed piece of data:
   
         +---------------------------------------+
         |           |                           |
         |  length   |           data            |
         | (4 bytes) |   (<length - 4> bytes)    |
         |           |                           |
         +---------------------------------------+
   
       All integers are big-endian signed integers. Each chunk starts with a
       32-bit integer indicating the length of the entire chunk (including the
       length field itself).
   
       There is a special case chunk that has a value of 0 for the length
       ("0x00000000"). We call this an *empty chunk*.
   
       Delta Groups
       ============
   
       A *delta group* expresses the content of a revlog as a series of deltas,
       or patches against previous revisions.
   
       Delta groups consist of 0 or more *chunks* followed by the *empty chunk*
       to signal the end of the delta group:
   
         +------------------------------------------------------------------------+
         |                |             |               |             |           |
         | chunk0 length  | chunk0 data | chunk1 length | chunk1 data |    0x0    |
         |   (4 bytes)    |  (various)  |   (4 bytes)   |  (various)  | (4 bytes) |
         |                |             |               |             |           |
         +------------------------------------------------------------------------+
   
       Each *chunk*'s data consists of the following:
   
         +---------------------------------------+
         |                        |              |
         |     delta header       |  delta data  |
         |  (various by version)  |  (various)   |
         |                        |              |
         +---------------------------------------+
   
       The *delta data* is a series of *delta*s that describe a diff from an
       existing entry (either that the recipient already has, or previously
       specified in the bundle/changegroup).
   
       The *delta header* is different between versions "1", "2", and "3" of the
       changegroup format.
   
       Version 1 (headerlen=80):
   
         +------------------------------------------------------+
         |            |             |             |             |
         |    node    |   p1 node   |   p2 node   |  link node  |
         | (20 bytes) |  (20 bytes) |  (20 bytes) |  (20 bytes) |
         |            |             |             |             |
         +------------------------------------------------------+
   
       Version 2 (headerlen=100):
   
         +------------------------------------------------------------------+
         |            |             |             |            |            |
         |    node    |   p1 node   |   p2 node   | base node  | link node  |
         | (20 bytes) |  (20 bytes) |  (20 bytes) | (20 bytes) | (20 bytes) |
         |            |             |             |            |            |
         +------------------------------------------------------------------+
   
       Version 3 (headerlen=102):
   
         +------------------------------------------------------------------------------+
         |            |             |             |            |            |           |
         |    node    |   p1 node   |   p2 node   | base node  | link node  |   flags   |
         | (20 bytes) |  (20 bytes) |  (20 bytes) | (20 bytes) | (20 bytes) | (2 bytes) |
         |            |             |             |            |            |           |
         +------------------------------------------------------------------------------+
   
       The *delta data* consists of "chunklen - 4 - headerlen" bytes, which
       contain a series of *delta*s, densely packed (no separators). These deltas
       describe a diff from an existing entry (either that the recipient already
       has, or previously specified in the bundle/changegroup). The format is
       described more fully in "hg help internals.bdiff", but briefly:
   
         +---------------------------------------------------------------+
         |              |            |            |                      |
         | start offset | end offset | new length |        content       |
         |  (4 bytes)   |  (4 bytes) |  (4 bytes) | (<new length> bytes) |
         |              |            |            |                      |
         +---------------------------------------------------------------+
   
       Please note that the length field in the delta data does *not* include
       itself.
   
       In version 1, the delta is always applied against the previous node from
       the changegroup or the first parent if this is the first entry in the
       changegroup.
   
       In version 2 and up, the delta base node is encoded in the entry in the
       changegroup. This allows the delta to be expressed against any parent,
       which can result in smaller deltas and more efficient encoding of data.
   
       Changeset Segment
       =================
   
       The *changeset segment* consists of a single *delta group* holding
       changelog data. The *empty chunk* at the end of the *delta group* denotes
       the boundary to the *manifest segment*.
   
       Manifest Segment
       ================
   
       The *manifest segment* consists of a single *delta group* holding manifest
       data. If treemanifests are in use, it contains only the manifest for the
       root directory of the repository. Otherwise, it contains the entire
       manifest data. The *empty chunk* at the end of the *delta group* denotes
       the boundary to the next segment (either the *treemanifests segment* or
       the *filelogs segment*, depending on version and the request options).
   
       Treemanifests Segment
       ---------------------
   
       The *treemanifests segment* only exists in changegroup version "3", and
       only if the 'treemanifest' param is part of the bundle2 changegroup part
       (it is not possible to use changegroup version 3 outside of bundle2).
       Aside from the filenames in the *treemanifests segment* containing a
       trailing "/" character, it behaves identically to the *filelogs segment*
       (see below). The final sub-segment is followed by an *empty chunk*
       (logically, a sub-segment with filename size 0). This denotes the boundary
       to the *filelogs segment*.
   
       Filelogs Segment
       ================
   
       The *filelogs segment* consists of multiple sub-segments, each
       corresponding to an individual file whose data is being described:
   
         +--------------------------------------------------+
         |          |          |          |     |           |
         | filelog0 | filelog1 | filelog2 | ... |    0x0    |
         |          |          |          |     | (4 bytes) |
         |          |          |          |     |           |
         +--------------------------------------------------+
   
       The final filelog sub-segment is followed by an *empty chunk* (logically,
       a sub-segment with filename size 0). This denotes the end of the segment
       and of the overall changegroup.
   
       Each filelog sub-segment consists of the following:
   
         +------------------------------------------------------+
         |                 |                      |             |
         | filename length |       filename       | delta group |
         |    (4 bytes)    | (<length - 4> bytes) |  (various)  |
         |                 |                      |             |
         +------------------------------------------------------+
   
       That is, a *chunk* consisting of the filename (not terminated or padded)
       followed by N chunks constituting the *delta group* for this file. The
       *empty chunk* at the end of each *delta group* denotes the boundary to the
       next filelog sub-segment.
 
 Test list of commands with command with no help text
 
   $ hg help helpext
   helpext extension - no help text available
   
   list of commands:
   
    nohelp        (no help text available)
   
   (use 'hg help -v helpext' to show built-in aliases and global options)
 
 
 test advanced, deprecated and experimental options are hidden in command help
   $ hg help debugoptADV
   hg debugoptADV
   
   (no help text available)
   
   options:
   
   (some details hidden, use --verbose to show complete help)
   $ hg help debugoptDEP
   hg debugoptDEP
   
   (no help text available)
   
   options:
   
   (some details hidden, use --verbose to show complete help)
 
   $ hg help debugoptEXP
   hg debugoptEXP
   
   (no help text available)
   
   options:
   
   (some details hidden, use --verbose to show complete help)
 
 test advanced, deprecated and experimental options are shown with -v
   $ hg help -v debugoptADV | grep aopt
     --aopt option is (ADVANCED)
   $ hg help -v debugoptDEP | grep dopt
     --dopt option is (DEPRECATED)
   $ hg help -v debugoptEXP | grep eopt
     --eopt option is (EXPERIMENTAL)
 
 #if gettext
 test deprecated option is hidden with translation with untranslated description
 (use many globy for not failing on changed transaction)
   $ LANGUAGE=sv hg help debugoptDEP
   hg debugoptDEP
   
   (*) (glob)
   
   options:
   
   (some details hidden, use --verbose to show complete help)
 #endif
 
 Test commands that collide with topics (issue4240)
 
   $ hg config -hq
   hg config [-u] [NAME]...
   
   show combined config settings from all hgrc files
   $ hg showconfig -hq
   hg config [-u] [NAME]...
   
   show combined config settings from all hgrc files
 
 Test a help topic
 
   $ hg help dates
   Date Formats
   """"""""""""
   
       Some commands allow the user to specify a date, e.g.:
   
       - backout, commit, import, tag: Specify the commit date.
       - log, revert, update: Select revision(s) by date.
   
       Many date formats are valid. Here are some examples:
   
       - "Wed Dec 6 13:18:29 2006" (local timezone assumed)
       - "Dec 6 13:18 -0600" (year assumed, time offset provided)
       - "Dec 6 13:18 UTC" (UTC and GMT are aliases for +0000)
       - "Dec 6" (midnight)
       - "13:18" (today assumed)
       - "3:39" (3:39AM assumed)
       - "3:39pm" (15:39)
       - "2006-12-06 13:18:29" (ISO 8601 format)
       - "2006-12-6 13:18"
       - "2006-12-6"
       - "12-6"
       - "12/6"
       - "12/6/6" (Dec 6 2006)
       - "today" (midnight)
       - "yesterday" (midnight)
       - "now" - right now
   
       Lastly, there is Mercurial's internal format:
   
       - "1165411109 0" (Wed Dec 6 13:18:29 2006 UTC)
   
       This is the internal representation format for dates. The first number is
       the number of seconds since the epoch (1970-01-01 00:00 UTC). The second
       is the offset of the local timezone, in seconds west of UTC (negative if
       the timezone is east of UTC).
   
       The log command also accepts date ranges:
   
       - "<DATE" - at or before a given date/time
       - ">DATE" - on or after a given date/time
       - "DATE to DATE" - a date range, inclusive
       - "-DAYS" - within a given number of days of today
 
 Test repeated config section name
 
   $ hg help config.host
       "http_proxy.host"
           Host name and (optional) port of the proxy server, for example
           "myproxy:8000".
   
       "smtp.host"
           Host name of mail server, e.g. "mail.example.com".
   
 
 Test section name with dot
 
   $ hg help config.ui.username
       "ui.username"
           The committer of a changeset created when running "commit". Typically
           a person's name and email address, e.g. "Fred Widget
           <[e-mail]>". Environment variables in the username are
           expanded.
   
           (default: "$EMAIL" or "username@hostname". If the username in hgrc is
           empty, e.g. if the system admin set "username =" in the system hgrc,
           it has to be specified manually or in a different hgrc file)
   
 
   $ hg help config.annotate.git
   abort: help section not found: config.annotate.git
   [255]
 
   $ hg help config.update.check
       "commands.update.check"
           Determines what level of checking 'hg update' will perform before
           moving to a destination revision. Valid values are "abort", "none",
           "linear", and "noconflict". "abort" always fails if the working
           directory has uncommitted changes. "none" performs no checking, and
           may result in a merge with uncommitted changes. "linear" allows any
           update as long as it follows a straight line in the revision history,
           and may trigger a merge with uncommitted changes. "noconflict" will
           allow any update which would not trigger a merge with uncommitted
           changes, if any are present. (default: "linear")
   
 
   $ hg help config.commands.update.check
       "commands.update.check"
           Determines what level of checking 'hg update' will perform before
           moving to a destination revision. Valid values are "abort", "none",
           "linear", and "noconflict". "abort" always fails if the working
           directory has uncommitted changes. "none" performs no checking, and
           may result in a merge with uncommitted changes. "linear" allows any
           update as long as it follows a straight line in the revision history,
           and may trigger a merge with uncommitted changes. "noconflict" will
           allow any update which would not trigger a merge with uncommitted
           changes, if any are present. (default: "linear")
   
 
   $ hg help config.ommands.update.check
   abort: help section not found: config.ommands.update.check
   [255]
 
 Unrelated trailing paragraphs shouldn't be included
 
   $ hg help config.extramsg | grep '^$'
   
 
 Test capitalized section name
 
   $ hg help scripting.HGPLAIN > /dev/null
 
 Help subsection:
 
   $ hg help config.charsets |grep "Email example:" > /dev/null
   [1]
 
 Show nested definitions
 ("profiling.type"[break]"ls"[break]"stat"[break])
 
   $ hg help config.type | egrep '^$'|wc -l
   \s*3 (re)
 
   $ hg help config.profiling.type.ls
           "profiling.type.ls"
             Use Python's built-in instrumenting profiler. This profiler works on
             all platforms, but each line number it reports is the first line of
             a function. This restriction makes it difficult to identify the
             expensive parts of a non-trivial function.
   
 
 Separate sections from subsections
 
   $ hg help config.format | egrep '^    ("|-)|^\s*$' | uniq
       "format"
       --------
   
       "usegeneraldelta"
   
       "dotencode"
   
       "usefncache"
   
       "usestore"
   
       "profiling"
       -----------
   
       "format"
   
       "progress"
       ----------
   
       "format"
   
 
 Last item in help config.*:
 
   $ hg help config.`hg help config|grep '^    "'| \
   >       tail -1|sed 's![ "]*!!g'`| \
   >   grep 'hg help -c config' > /dev/null
   [1]
 
 note to use help -c for general hg help config:
 
   $ hg help config |grep 'hg help -c config' > /dev/null
 
 Test templating help
 
   $ hg help templating | egrep '(desc|diffstat|firstline|nonempty)  '
       desc          String. The text of the changeset description.
       diffstat      String. Statistics of changes with the following format:
       firstline     Any text. Returns the first line of text.
       nonempty      Any text. Returns '(none)' if the string is empty.
 
 Test deprecated items
 
   $ hg help -v templating | grep currentbookmark
       currentbookmark
   $ hg help templating | (grep currentbookmark || true)
 
 Test help hooks
 
   $ cat > helphook1.py <<EOF
   > from mercurial import help
   > 
   > def rewrite(ui, topic, doc):
   >     return doc + '\nhelphook1\n'
   > 
   > def extsetup(ui):
   >     help.addtopichook('revisions', rewrite)
   > EOF
   $ cat > helphook2.py <<EOF
   > from mercurial import help
   > 
   > def rewrite(ui, topic, doc):
   >     return doc + '\nhelphook2\n'
   > 
   > def extsetup(ui):
   >     help.addtopichook('revisions', rewrite)
   > EOF
   $ echo '[extensions]' >> $HGRCPATH
   $ echo "helphook1 = `pwd`/helphook1.py" >> $HGRCPATH
   $ echo "helphook2 = `pwd`/helphook2.py" >> $HGRCPATH
   $ hg help revsets | grep helphook
       helphook1
       helphook2
 
 help -c should only show debug --debug
 
   $ hg help -c --debug|egrep debug|wc -l|egrep '^\s*0\s*$'
   [1]
 
 help -c should only show deprecated for -v
 
   $ hg help -c -v|egrep DEPRECATED|wc -l|egrep '^\s*0\s*$'
   [1]
 
 Test -s / --system
 
   $ hg help config.files -s windows |grep 'etc/mercurial' | \
   > wc -l | sed -e 's/ //g'
   0
   $ hg help config.files --system unix | grep 'USER' | \
   > wc -l | sed -e 's/ //g'
   0
 
 Test -e / -c / -k combinations
 
   $ hg help -c|egrep '^[A-Z].*:|^ debug'
   Commands:
   $ hg help -e|egrep '^[A-Z].*:|^ debug'
   Extensions:
   $ hg help -k|egrep '^[A-Z].*:|^ debug'
   Topics:
   Commands:
   Extensions:
   Extension Commands:
   $ hg help -c schemes
   abort: no such help topic: schemes
   (try 'hg help --keyword schemes')
   [255]
   $ hg help -e schemes |head -1
   schemes extension - extend schemes with shortcuts to repository swarms
   $ hg help -c -k dates |egrep '^(Topics|Extensions|Commands):'
   Commands:
   $ hg help -e -k a |egrep '^(Topics|Extensions|Commands):'
   Extensions:
   $ hg help -e -c -k date |egrep '^(Topics|Extensions|Commands):'
   Extensions:
   Commands:
   $ hg help -c commit > /dev/null
   $ hg help -e -c commit > /dev/null
   $ hg help -e commit
   abort: no such help topic: commit
   (try 'hg help --keyword commit')
   [255]
 
 Test keyword search help
 
   $ cat > prefixedname.py <<EOF
   > '''matched against word "clone"
   > '''
   > EOF
   $ echo '[extensions]' >> $HGRCPATH
   $ echo "dot.dot.prefixedname = `pwd`/prefixedname.py" >> $HGRCPATH
   $ hg help -k clone
   Topics:
   
    config     Configuration Files
    extensions Using Additional Features
    glossary   Glossary
    phases     Working with Phases
    subrepos   Subrepositories
    urls       URL Paths
   
   Commands:
   
    bookmarks create a new bookmark or list existing bookmarks
    clone     make a copy of an existing repository
    paths     show aliases for remote repositories
    pull      pull changes from the specified source
    update    update working directory (or switch revisions)
   
   Extensions:
   
    clonebundles advertise pre-generated bundles to seed clones
    narrow       create clones which fetch history data for subset of files
                 (EXPERIMENTAL)
    prefixedname matched against word "clone"
    relink       recreates hardlinks between repository clones
   
   Extension Commands:
   
    qclone clone main and patch repository at same time
 
 Test unfound topic
 
   $ hg help nonexistingtopicthatwillneverexisteverever
   abort: no such help topic: nonexistingtopicthatwillneverexisteverever
   (try 'hg help --keyword nonexistingtopicthatwillneverexisteverever')
   [255]
 
 Test unfound keyword
 
   $ hg help --keyword nonexistingwordthatwillneverexisteverever
   abort: no matches
   (try 'hg help' for a list of topics)
   [255]
 
 Test omit indicating for help
 
   $ cat > addverboseitems.py <<EOF
   > '''extension to test omit indicating.
   > 
   > This paragraph is never omitted (for extension)
   > 
   > .. container:: verbose
   > 
   >   This paragraph is omitted,
   >   if :hg:\`help\` is invoked without \`\`-v\`\` (for extension)
   > 
   > This paragraph is never omitted, too (for extension)
   > '''
   > from __future__ import absolute_import
   > from mercurial import commands, help
   > testtopic = """This paragraph is never omitted (for topic).
   > 
   > .. container:: verbose
   > 
   >   This paragraph is omitted,
   >   if :hg:\`help\` is invoked without \`\`-v\`\` (for topic)
   > 
   > This paragraph is never omitted, too (for topic)
   > """
   > def extsetup(ui):
   >     help.helptable.append((["topic-containing-verbose"],
   >                            "This is the topic to test omit indicating.",
   >                            lambda ui: testtopic))
   > EOF
   $ echo '[extensions]' >> $HGRCPATH
   $ echo "addverboseitems = `pwd`/addverboseitems.py" >> $HGRCPATH
   $ hg help addverboseitems
   addverboseitems extension - extension to test omit indicating.
   
   This paragraph is never omitted (for extension)
   
   This paragraph is never omitted, too (for extension)
   
   (some details hidden, use --verbose to show complete help)
   
   no commands defined
   $ hg help -v addverboseitems
   addverboseitems extension - extension to test omit indicating.
   
   This paragraph is never omitted (for extension)
   
   This paragraph is omitted, if 'hg help' is invoked without "-v" (for
   extension)
   
   This paragraph is never omitted, too (for extension)
   
   no commands defined
   $ hg help topic-containing-verbose
   This is the topic to test omit indicating.
   """"""""""""""""""""""""""""""""""""""""""
   
       This paragraph is never omitted (for topic).
   
       This paragraph is never omitted, too (for topic)
   
   (some details hidden, use --verbose to show complete help)
   $ hg help -v topic-containing-verbose
   This is the topic to test omit indicating.
   """"""""""""""""""""""""""""""""""""""""""
   
       This paragraph is never omitted (for topic).
   
       This paragraph is omitted, if 'hg help' is invoked without "-v" (for
       topic)
   
       This paragraph is never omitted, too (for topic)
 
 Test section lookup
 
   $ hg help revset.merge
       "merge()"
         Changeset is a merge changeset.
   
   $ hg help glossary.dag
       DAG
           The repository of changesets of a distributed version control system
           (DVCS) can be described as a directed acyclic graph (DAG), consisting
           of nodes and edges, where nodes correspond to changesets and edges
           imply a parent -> child relation. This graph can be visualized by
           graphical tools such as 'hg log --graph'. In Mercurial, the DAG is
           limited by the requirement for children to have at most two parents.
   
 
   $ hg help hgrc.paths
       "paths"
       -------
   
       Assigns symbolic names and behavior to repositories.
   
       Options are symbolic names defining the URL or directory that is the
       location of the repository. Example:
   
         [paths]
         my_server = https://example.com/my_repo
         local_path = /home/me/repo
   
       These symbolic names can be used from the command line. To pull from
       "my_server": 'hg pull my_server'. To push to "local_path": 'hg push
       local_path'.
   
       Options containing colons (":") denote sub-options that can influence
       behavior for that specific path. Example:
   
         [paths]
         my_server = https://example.com/my_path
         my_server:pushurl = ssh://example.com/my_path
   
       The following sub-options can be defined:
   
       "pushurl"
          The URL to use for push operations. If not defined, the location
          defined by the path's main entry is used.
   
       "pushrev"
          A revset defining which revisions to push by default.
   
          When 'hg push' is executed without a "-r" argument, the revset defined
          by this sub-option is evaluated to determine what to push.
   
          For example, a value of "." will push the working directory's revision
          by default.
   
          Revsets specifying bookmarks will not result in the bookmark being
          pushed.
   
       The following special named paths exist:
   
       "default"
          The URL or directory to use when no source or remote is specified.
   
          'hg clone' will automatically define this path to the location the
          repository was cloned from.
   
       "default-push"
          (deprecated) The URL or directory for the default 'hg push' location.
          "default:pushurl" should be used instead.
   
   $ hg help glossary.mcguffin
   abort: help section not found: glossary.mcguffin
   [255]
 
   $ hg help glossary.mc.guffin
   abort: help section not found: glossary.mc.guffin
   [255]
 
   $ hg help template.files
       files         List of strings. All files modified, added, or removed by
                     this changeset.
       files(pattern)
                     All files of the current changeset matching the pattern. See
                     'hg help patterns'.
 
 Test section lookup by translated message
 
 str.lower() instead of encoding.lower(str) on translated message might
 make message meaningless, because some encoding uses 0x41(A) - 0x5a(Z)
 as the second or later byte of multi-byte character.
 
 For example, "\x8bL\x98^" (translation of "record" in ja_JP.cp932)
 contains 0x4c (L). str.lower() replaces 0x4c(L) by 0x6c(l) and this
 replacement makes message meaningless.
 
 This tests that section lookup by translated string isn't broken by
 such str.lower().
 
   $ "$PYTHON" <<EOF
   > def escape(s):
   >     return ''.join('\u%x' % ord(uc) for uc in s.decode('cp932'))
   > # translation of "record" in ja_JP.cp932
   > upper = "\x8bL\x98^"
   > # str.lower()-ed section name should be treated as different one
   > lower = "\x8bl\x98^"
   > with open('ambiguous.py', 'w') as fp:
   >     fp.write("""# ambiguous section names in ja_JP.cp932
   > u'''summary of extension
   > 
   > %s
   > ----
   > 
   > Upper name should show only this message
   > 
   > %s
   > ----
   > 
   > Lower name should show only this message
   > 
   > subsequent section
   > ------------------
   > 
   > This should be hidden at 'hg help ambiguous' with section name.
   > '''
   > """ % (escape(upper), escape(lower)))
   > EOF
 
   $ cat >> $HGRCPATH <<EOF
   > [extensions]
   > ambiguous = ./ambiguous.py
   > EOF
 
   $ "$PYTHON" <<EOF | sh
   > upper = "\x8bL\x98^"
   > print("hg --encoding cp932 help -e ambiguous.%s" % upper)
   > EOF
   \x8bL\x98^ (esc)
   ----
   
   Upper name should show only this message
   
 
   $ "$PYTHON" <<EOF | sh
   > lower = "\x8bl\x98^"
   > print("hg --encoding cp932 help -e ambiguous.%s" % lower)
   > EOF
   \x8bl\x98^ (esc)
   ----
   
   Lower name should show only this message
   
 
   $ cat >> $HGRCPATH <<EOF
   > [extensions]
   > ambiguous = !
   > EOF
 
 Show help content of disabled extensions
 
   $ cat >> $HGRCPATH <<EOF
   > [extensions]
   > ambiguous = !./ambiguous.py
   > EOF
   $ hg help -e ambiguous
   ambiguous extension - (no help text available)
   
   (use 'hg help extensions' for information on enabling extensions)
 
 Test dynamic list of merge tools only shows up once
   $ hg help merge-tools
   Merge Tools
   """""""""""
   
       To merge files Mercurial uses merge tools.
   
       A merge tool combines two different versions of a file into a merged file.
       Merge tools are given the two files and the greatest common ancestor of
       the two file versions, so they can determine the changes made on both
       branches.
   
       Merge tools are used both for 'hg resolve', 'hg merge', 'hg update', 'hg
       backout' and in several extensions.
   
       Usually, the merge tool tries to automatically reconcile the files by
       combining all non-overlapping changes that occurred separately in the two
       different evolutions of the same initial base file. Furthermore, some
       interactive merge programs make it easier to manually resolve conflicting
       merges, either in a graphical way, or by inserting some conflict markers.
       Mercurial does not include any interactive merge programs but relies on
       external tools for that.
   
       Available merge tools
       =====================
   
       External merge tools and their properties are configured in the merge-
       tools configuration section - see hgrc(5) - but they can often just be
       named by their executable.
   
       A merge tool is generally usable if its executable can be found on the
       system and if it can handle the merge. The executable is found if it is an
       absolute or relative executable path or the name of an application in the
       executable search path. The tool is assumed to be able to handle the merge
       if it can handle symlinks if the file is a symlink, if it can handle
       binary files if the file is binary, and if a GUI is available if the tool
       requires a GUI.
   
       There are some internal merge tools which can be used. The internal merge
       tools are:
   
       ":dump"
         Creates three versions of the files to merge, containing the contents of
         local, other and base. These files can then be used to perform a merge
         manually. If the file to be merged is named "a.txt", these files will
         accordingly be named "a.txt.local", "a.txt.other" and "a.txt.base" and
         they will be placed in the same directory as "a.txt".
   
         This implies premerge. Therefore, files aren't dumped, if premerge runs
         successfully. Use :forcedump to forcibly write files out.
   
         (actual capabilities: binary, symlink)
   
       ":fail"
         Rather than attempting to merge files that were modified on both
         branches, it marks them as unresolved. The resolve command must be used
         to resolve these conflicts.
   
         (actual capabilities: binary, symlink)
   
       ":forcedump"
         Creates three versions of the files as same as :dump, but omits
         premerge.
   
         (actual capabilities: binary, symlink)
   
       ":local"
         Uses the local 'p1()' version of files as the merged version.
   
         (actual capabilities: binary, symlink)
   
       ":merge"
         Uses the internal non-interactive simple merge algorithm for merging
         files. It will fail if there are any conflicts and leave markers in the
         partially merged file. Markers will have two sections, one for each side
         of merge.
   
       ":merge-local"
         Like :merge, but resolve all conflicts non-interactively in favor of the
         local 'p1()' changes.
   
       ":merge-other"
         Like :merge, but resolve all conflicts non-interactively in favor of the
         other 'p2()' changes.
   
       ":merge3"
         Uses the internal non-interactive simple merge algorithm for merging
         files. It will fail if there are any conflicts and leave markers in the
         partially merged file. Marker will have three sections, one from each
         side of the merge and one for the base content.
   
       ":other"
         Uses the other 'p2()' version of files as the merged version.
   
         (actual capabilities: binary, symlink)
   
       ":prompt"
         Asks the user which of the local 'p1()' or the other 'p2()' version to
         keep as the merged version.
   
         (actual capabilities: binary, symlink)
   
       ":tagmerge"
         Uses the internal tag merge algorithm (experimental).
   
       ":union"
         Uses the internal non-interactive simple merge algorithm for merging
         files. It will use both left and right sides for conflict regions. No
         markers are inserted.
   
       Internal tools are always available and do not require a GUI but will by
       default not handle symlinks or binary files. See next section for detail
       about "actual capabilities" described above.
   
       Choosing a merge tool
       =====================
   
       Mercurial uses these rules when deciding which merge tool to use:
   
       1. If a tool has been specified with the --tool option to merge or
          resolve, it is used.  If it is the name of a tool in the merge-tools
          configuration, its configuration is used. Otherwise the specified tool
          must be executable by the shell.
       2. If the "HGMERGE" environment variable is present, its value is used and
          must be executable by the shell.
       3. If the filename of the file to be merged matches any of the patterns in
          the merge-patterns configuration section, the first usable merge tool
          corresponding to a matching pattern is used.
       4. If ui.merge is set it will be considered next. If the value is not the
          name of a configured tool, the specified value is used and must be
          executable by the shell. Otherwise the named tool is used if it is
          usable.
       5. If any usable merge tools are present in the merge-tools configuration
          section, the one with the highest priority is used.
       6. If a program named "hgmerge" can be found on the system, it is used -
          but it will by default not be used for symlinks and binary files.
       7. If the file to be merged is not binary and is not a symlink, then
          internal ":merge" is used.
       8. Otherwise, ":prompt" is used.
   
       For historical reason, Mercurial treats merge tools as below while
       examining rules above.
   
       step specified via  binary symlink
       ----------------------------------
       1.   --tool         o/o    o/o
       2.   HGMERGE        o/o    o/o
       3.   merge-patterns o/o(*) x/?(*)
       4.   ui.merge       x/?(*) x/?(*)
   
       Each capability column indicates Mercurial behavior for internal/external
       merge tools at examining each rule.
   
       - "o": "assume that a tool has capability"
       - "x": "assume that a tool does not have capability"
       - "?": "check actual capability of a tool"
   
       If "merge.strict-capability-check" configuration is true, Mercurial checks
       capabilities of merge tools strictly in (*) cases above (= each capability
       column becomes "?/?"). It is false by default for backward compatibility.
   
       Note:
          After selecting a merge program, Mercurial will by default attempt to
          merge the files using a simple merge algorithm first. Only if it
          doesn't succeed because of conflicting changes will Mercurial actually
          execute the merge program. Whether to use the simple merge algorithm
          first can be controlled by the premerge setting of the merge tool.
          Premerge is enabled by default unless the file is binary or a symlink.
   
       See the merge-tools and ui sections of hgrc(5) for details on the
       configuration of merge tools.
 
 Compression engines listed in `hg help bundlespec`
 
   $ hg help bundlespec | grep gzip
           "v1" bundles can only use the "gzip", "bzip2", and "none" compression
         An algorithm that produces smaller bundles than "gzip".
         This engine will likely produce smaller bundles than "gzip" but will be
       "gzip"
         better compression than "gzip". It also frequently yields better (?)
 
 Test usage of section marks in help documents
 
   $ cd "$TESTDIR"/../doc
   $ "$PYTHON" check-seclevel.py
   $ cd $TESTTMP
 
 #if serve
 
 Test the help pages in hgweb.
 
 Dish up an empty repo; serve it cold.
 
   $ hg init "$TESTTMP/test"
   $ hg serve -R "$TESTTMP/test" -n test -p $HGPORT -d --pid-file=hg.pid
   $ cat hg.pid >> $DAEMON_PIDS
 
   $ get-with-headers.py $LOCALIP:$HGPORT "help"
   200 Script output follows
   
   <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
   <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en-US">
   <head>
   <link rel="icon" href="/static/hgicon.png" type="image/png" />
   <meta name="robots" content="index, nofollow" />
   <link rel="stylesheet" href="/static/style-paper.css" type="text/css" />
   <script type="text/javascript" src="/static/mercurial.js"></script>
   
   <title>Help: Index</title>
   </head>
   <body>
   
   <div class="container">
   <div class="menu">
   <div class="logo">
   <a href="https://mercurial-scm.org/">
   <img src="/static/hglogo.png" alt="mercurial" /></a>
   </div>
   <ul>
   <li><a href="/shortlog">log</a></li>
   <li><a href="/graph">graph</a></li>
   <li><a href="/tags">tags</a></li>
   <li><a href="/bookmarks">bookmarks</a></li>
   <li><a href="/branches">branches</a></li>
   </ul>
   <ul>
   <li class="active">help</li>
   </ul>
   </div>
   
   <div class="main">
   <h2 class="breadcrumb"><a href="/">Mercurial</a> </h2>
   
   <form class="search" action="/log">
   
   <p><input name="rev" id="search1" type="text" size="30" value="" /></p>
   <div id="hint">Find changesets by keywords (author, files, the commit message), revision
   number or hash, or <a href="/help/revsets">revset expression</a>.</div>
   </form>
   <table class="bigtable">
   <tr><td colspan="2"><h2><a name="topics" href="#topics">Topics</a></h2></td></tr>
   
   <tr><td>
   <a href="/help/bundlespec">
   bundlespec
   </a>
   </td><td>
   Bundle File Formats
   </td></tr>
   <tr><td>
   <a href="/help/color">
   color
   </a>
   </td><td>
   Colorizing Outputs
   </td></tr>
   <tr><td>
   <a href="/help/config">
   config
   </a>
   </td><td>
   Configuration Files
   </td></tr>
   <tr><td>
   <a href="/help/dates">
   dates
   </a>
   </td><td>
   Date Formats
   </td></tr>
   <tr><td>
   <a href="/help/deprecated">
   deprecated
   </a>
   </td><td>
   Deprecated Features
   </td></tr>
   <tr><td>
   <a href="/help/diffs">
   diffs
   </a>
   </td><td>
   Diff Formats
   </td></tr>
   <tr><td>
   <a href="/help/environment">
   environment
   </a>
   </td><td>
   Environment Variables
   </td></tr>
   <tr><td>
   <a href="/help/extensions">
   extensions
   </a>
   </td><td>
   Using Additional Features
   </td></tr>
   <tr><td>
   <a href="/help/filesets">
   filesets
   </a>
   </td><td>
   Specifying File Sets
   </td></tr>
   <tr><td>
   <a href="/help/flags">
   flags
   </a>
   </td><td>
   Command-line flags
   </td></tr>
   <tr><td>
   <a href="/help/glossary">
   glossary
   </a>
   </td><td>
   Glossary
   </td></tr>
   <tr><td>
   <a href="/help/hgignore">
   hgignore
   </a>
   </td><td>
   Syntax for Mercurial Ignore Files
   </td></tr>
   <tr><td>
   <a href="/help/hgweb">
   hgweb
   </a>
   </td><td>
   Configuring hgweb
   </td></tr>
   <tr><td>
   <a href="/help/internals">
   internals
   </a>
   </td><td>
   Technical implementation topics
   </td></tr>
   <tr><td>
   <a href="/help/merge-tools">
   merge-tools
   </a>
   </td><td>
   Merge Tools
   </td></tr>
   <tr><td>
   <a href="/help/pager">
   pager
   </a>
   </td><td>
   Pager Support
   </td></tr>
   <tr><td>
   <a href="/help/patterns">
   patterns
   </a>
   </td><td>
   File Name Patterns
   </td></tr>
   <tr><td>
   <a href="/help/phases">
   phases
   </a>
   </td><td>
   Working with Phases
   </td></tr>
   <tr><td>
   <a href="/help/revisions">
   revisions
   </a>
   </td><td>
   Specifying Revisions
   </td></tr>
   <tr><td>
   <a href="/help/scripting">
   scripting
   </a>
   </td><td>
   Using Mercurial from scripts and automation
   </td></tr>
   <tr><td>
   <a href="/help/subrepos">
   subrepos
   </a>
   </td><td>
   Subrepositories
   </td></tr>
   <tr><td>
   <a href="/help/templating">
   templating
   </a>
   </td><td>
   Template Usage
   </td></tr>
   <tr><td>
   <a href="/help/urls">
   urls
   </a>
   </td><td>
   URL Paths
   </td></tr>
   <tr><td>
   <a href="/help/topic-containing-verbose">
   topic-containing-verbose
   </a>
   </td><td>
   This is the topic to test omit indicating.
   </td></tr>
   
   
   <tr><td colspan="2"><h2><a name="main" href="#main">Main Commands</a></h2></td></tr>
   
   <tr><td>
   <a href="/help/add">
   add
   </a>
   </td><td>
   add the specified files on the next commit
   </td></tr>
   <tr><td>
   <a href="/help/annotate">
   annotate
   </a>
   </td><td>
   show changeset information by line for each file
   </td></tr>
   <tr><td>
   <a href="/help/clone">
   clone
   </a>
   </td><td>
   make a copy of an existing repository
   </td></tr>
   <tr><td>
   <a href="/help/commit">
   commit
   </a>
   </td><td>
   commit the specified files or all outstanding changes
   </td></tr>
   <tr><td>
   <a href="/help/diff">
   diff
   </a>
   </td><td>
   diff repository (or selected files)
   </td></tr>
   <tr><td>
   <a href="/help/export">
   export
   </a>
   </td><td>
   dump the header and diffs for one or more changesets
   </td></tr>
   <tr><td>
   <a href="/help/forget">
   forget
   </a>
   </td><td>
   forget the specified files on the next commit
   </td></tr>
   <tr><td>
   <a href="/help/init">
   init
   </a>
   </td><td>
   create a new repository in the given directory
   </td></tr>
   <tr><td>
   <a href="/help/log">
   log
   </a>
   </td><td>
   show revision history of entire repository or files
   </td></tr>
   <tr><td>
   <a href="/help/merge">
   merge
   </a>
   </td><td>
   merge another revision into working directory
   </td></tr>
   <tr><td>
   <a href="/help/pull">
   pull
   </a>
   </td><td>
   pull changes from the specified source
   </td></tr>
   <tr><td>
   <a href="/help/push">
   push
   </a>
   </td><td>
   push changes to the specified destination
   </td></tr>
   <tr><td>
   <a href="/help/remove">
   remove
   </a>
   </td><td>
   remove the specified files on the next commit
   </td></tr>
   <tr><td>
   <a href="/help/serve">
   serve
   </a>
   </td><td>
   start stand-alone webserver
   </td></tr>
   <tr><td>
   <a href="/help/status">
   status
   </a>
   </td><td>
   show changed files in the working directory
   </td></tr>
   <tr><td>
   <a href="/help/summary">
   summary
   </a>
   </td><td>
   summarize working directory state
   </td></tr>
   <tr><td>
   <a href="/help/update">
   update
   </a>
   </td><td>
   update working directory (or switch revisions)
   </td></tr>
   
   
   
   <tr><td colspan="2"><h2><a name="other" href="#other">Other Commands</a></h2></td></tr>
   
   <tr><td>
   <a href="/help/addremove">
   addremove
   </a>
   </td><td>
   add all new files, delete all missing files
   </td></tr>
   <tr><td>
   <a href="/help/archive">
   archive
   </a>
   </td><td>
   create an unversioned archive of a repository revision
   </td></tr>
   <tr><td>
   <a href="/help/backout">
   backout
   </a>
   </td><td>
   reverse effect of earlier changeset
   </td></tr>
   <tr><td>
   <a href="/help/bisect">
   bisect
   </a>
   </td><td>
   subdivision search of changesets
   </td></tr>
   <tr><td>
   <a href="/help/bookmarks">
   bookmarks
   </a>
   </td><td>
   create a new bookmark or list existing bookmarks
   </td></tr>
   <tr><td>
   <a href="/help/branch">
   branch
   </a>
   </td><td>
   set or show the current branch name
   </td></tr>
   <tr><td>
   <a href="/help/branches">
   branches
   </a>
   </td><td>
   list repository named branches
   </td></tr>
   <tr><td>
   <a href="/help/bundle">
   bundle
   </a>
   </td><td>
   create a bundle file
   </td></tr>
   <tr><td>
   <a href="/help/cat">
   cat
   </a>
   </td><td>
   output the current or given revision of files
   </td></tr>
   <tr><td>
   <a href="/help/config">
   config
   </a>
   </td><td>
   show combined config settings from all hgrc files
   </td></tr>
   <tr><td>
   <a href="/help/copy">
   copy
   </a>
   </td><td>
   mark files as copied for the next commit
   </td></tr>
   <tr><td>
   <a href="/help/files">
   files
   </a>
   </td><td>
   list tracked files
   </td></tr>
   <tr><td>
   <a href="/help/graft">
   graft
   </a>
   </td><td>
   copy changes from other branches onto the current branch
   </td></tr>
   <tr><td>
   <a href="/help/grep">
   grep
   </a>
   </td><td>
   search revision history for a pattern in specified files
   </td></tr>
   <tr><td>
   <a href="/help/heads">
   heads
   </a>
   </td><td>
   show branch heads
   </td></tr>
   <tr><td>
   <a href="/help/help">
   help
   </a>
   </td><td>
   show help for a given topic or a help overview
   </td></tr>
   <tr><td>
   <a href="/help/hgalias">
   hgalias
   </a>
   </td><td>
   summarize working directory state
   </td></tr>
   <tr><td>
   <a href="/help/identify">
   identify
   </a>
   </td><td>
   identify the working directory or specified revision
   </td></tr>
   <tr><td>
   <a href="/help/import">
   import
   </a>
   </td><td>
   import an ordered set of patches
   </td></tr>
   <tr><td>
   <a href="/help/incoming">
   incoming
   </a>
   </td><td>
   show new changesets found in source
   </td></tr>
   <tr><td>
   <a href="/help/manifest">
   manifest
   </a>
   </td><td>
   output the current or given revision of the project manifest
   </td></tr>
   <tr><td>
   <a href="/help/nohelp">
   nohelp
   </a>
   </td><td>
   (no help text available)
   </td></tr>
   <tr><td>
   <a href="/help/outgoing">
   outgoing
   </a>
   </td><td>
   show changesets not found in the destination
   </td></tr>
   <tr><td>
   <a href="/help/paths">
   paths
   </a>
   </td><td>
   show aliases for remote repositories
   </td></tr>
   <tr><td>
   <a href="/help/phase">
   phase
   </a>
   </td><td>
   set or show the current phase name
   </td></tr>
   <tr><td>
   <a href="/help/recover">
   recover
   </a>
   </td><td>
   roll back an interrupted transaction
   </td></tr>
   <tr><td>
   <a href="/help/rename">
   rename
   </a>
   </td><td>
   rename files; equivalent of copy + remove
   </td></tr>
   <tr><td>
   <a href="/help/resolve">
   resolve
   </a>
   </td><td>
   redo merges or set/view the merge status of files
   </td></tr>
   <tr><td>
   <a href="/help/revert">
   revert
   </a>
   </td><td>
   restore files to their checkout state
   </td></tr>
   <tr><td>
   <a href="/help/root">
   root
   </a>
   </td><td>
   print the root (top) of the current working directory
   </td></tr>
   <tr><td>
   <a href="/help/shellalias">
   shellalias
   </a>
   </td><td>
   (no help text available)
   </td></tr>
   <tr><td>
   <a href="/help/tag">
   tag
   </a>
   </td><td>
   add one or more tags for the current or given revision
   </td></tr>
   <tr><td>
   <a href="/help/tags">
   tags
   </a>
   </td><td>
   list repository tags
   </td></tr>
   <tr><td>
   <a href="/help/unbundle">
   unbundle
   </a>
   </td><td>
   apply one or more bundle files
   </td></tr>
   <tr><td>
   <a href="/help/verify">
   verify
   </a>
   </td><td>
   verify the integrity of the repository
   </td></tr>
   <tr><td>
   <a href="/help/version">
   version
   </a>
   </td><td>
   output version and copyright information
   </td></tr>
   
   
   </table>
   </div>
   </div>
   
   
   
   </body>
   </html>
   
 
   $ get-with-headers.py $LOCALIP:$HGPORT "help/add"
   200 Script output follows
   
   <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
   <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en-US">
   <head>
   <link rel="icon" href="/static/hgicon.png" type="image/png" />
   <meta name="robots" content="index, nofollow" />
   <link rel="stylesheet" href="/static/style-paper.css" type="text/css" />
   <script type="text/javascript" src="/static/mercurial.js"></script>
   
   <title>Help: add</title>
   </head>
   <body>
   
   <div class="container">
   <div class="menu">
   <div class="logo">
   <a href="https://mercurial-scm.org/">
   <img src="/static/hglogo.png" alt="mercurial" /></a>
   </div>
   <ul>
   <li><a href="/shortlog">log</a></li>
   <li><a href="/graph">graph</a></li>
   <li><a href="/tags">tags</a></li>
   <li><a href="/bookmarks">bookmarks</a></li>
   <li><a href="/branches">branches</a></li>
   </ul>
   <ul>
    <li class="active"><a href="/help">help</a></li>
   </ul>
   </div>
   
   <div class="main">
   <h2 class="breadcrumb"><a href="/">Mercurial</a> </h2>
   <h3>Help: add</h3>
   
   <form class="search" action="/log">
   
   <p><input name="rev" id="search1" type="text" size="30" value="" /></p>
   <div id="hint">Find changesets by keywords (author, files, the commit message), revision
   number or hash, or <a href="/help/revsets">revset expression</a>.</div>
   </form>
   <div id="doc">
   <p>
   hg add [OPTION]... [FILE]...
   </p>
   <p>
   add the specified files on the next commit
   </p>
   <p>
   Schedule files to be version controlled and added to the
   repository.
   </p>
   <p>
   The files will be added to the repository at the next commit. To
   undo an add before that, see 'hg forget'.
   </p>
   <p>
   If no names are given, add all files to the repository (except
   files matching &quot;.hgignore&quot;).
   </p>
   <p>
   Examples:
   </p>
   <ul>
    <li> New (unknown) files are added   automatically by 'hg add':
   <pre>
   \$ ls (re)
   foo.c
   \$ hg status (re)
   ? foo.c
   \$ hg add (re)
   adding foo.c
   \$ hg status (re)
   A foo.c
   </pre>
    <li> Specific files to be added can be specified:
   <pre>
   \$ ls (re)
   bar.c  foo.c
   \$ hg status (re)
   ? bar.c
   ? foo.c
   \$ hg add bar.c (re)
   \$ hg status (re)
   A bar.c
   ? foo.c
   </pre>
   </ul>
   <p>
   Returns 0 if all files are successfully added.
   </p>
   <p>
   options ([+] can be repeated):
   </p>
   <table>
   <tr><td>-I</td>
   <td>--include PATTERN [+]</td>
   <td>include names matching the given patterns</td></tr>
   <tr><td>-X</td>
   <td>--exclude PATTERN [+]</td>
   <td>exclude names matching the given patterns</td></tr>
   <tr><td>-S</td>
   <td>--subrepos</td>
   <td>recurse into subrepositories</td></tr>
   <tr><td>-n</td>
   <td>--dry-run</td>
   <td>do not perform actions, just print output</td></tr>
   </table>
   <p>
   global options ([+] can be repeated):
   </p>
   <table>
   <tr><td>-R</td>
   <td>--repository REPO</td>
   <td>repository root directory or name of overlay bundle file</td></tr>
   <tr><td></td>
   <td>--cwd DIR</td>
   <td>change working directory</td></tr>
   <tr><td>-y</td>
   <td>--noninteractive</td>
   <td>do not prompt, automatically pick the first choice for all prompts</td></tr>
   <tr><td>-q</td>
   <td>--quiet</td>
   <td>suppress output</td></tr>
   <tr><td>-v</td>
   <td>--verbose</td>
   <td>enable additional output</td></tr>
   <tr><td></td>
   <td>--color TYPE</td>
   <td>when to colorize (boolean, always, auto, never, or debug)</td></tr>
   <tr><td></td>
   <td>--config CONFIG [+]</td>
   <td>set/override config option (use 'section.name=value')</td></tr>
   <tr><td></td>
   <td>--debug</td>
   <td>enable debugging output</td></tr>
   <tr><td></td>
   <td>--debugger</td>
   <td>start debugger</td></tr>
   <tr><td></td>
   <td>--encoding ENCODE</td>
   <td>set the charset encoding (default: ascii)</td></tr>
   <tr><td></td>
   <td>--encodingmode MODE</td>
   <td>set the charset encoding mode (default: strict)</td></tr>
   <tr><td></td>
   <td>--traceback</td>
   <td>always print a traceback on exception</td></tr>
   <tr><td></td>
   <td>--time</td>
   <td>time how long the command takes</td></tr>
   <tr><td></td>
   <td>--profile</td>
   <td>print command execution profile</td></tr>
   <tr><td></td>
   <td>--version</td>
   <td>output version information and exit</td></tr>
   <tr><td>-h</td>
   <td>--help</td>
   <td>display help and exit</td></tr>
   <tr><td></td>
   <td>--hidden</td>
   <td>consider hidden changesets</td></tr>
   <tr><td></td>
   <td>--pager TYPE</td>
   <td>when to paginate (boolean, always, auto, or never) (default: auto)</td></tr>
   </table>
   
   </div>
   </div>
   </div>
   
   
   
   </body>
   </html>
   
 
   $ get-with-headers.py $LOCALIP:$HGPORT "help/remove"
   200 Script output follows
   
   <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
   <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en-US">
   <head>
   <link rel="icon" href="/static/hgicon.png" type="image/png" />
   <meta name="robots" content="index, nofollow" />
   <link rel="stylesheet" href="/static/style-paper.css" type="text/css" />
   <script type="text/javascript" src="/static/mercurial.js"></script>
   
   <title>Help: remove</title>
   </head>
   <body>
   
   <div class="container">
   <div class="menu">
   <div class="logo">
   <a href="https://mercurial-scm.org/">
   <img src="/static/hglogo.png" alt="mercurial" /></a>
   </div>
   <ul>
   <li><a href="/shortlog">log</a></li>
   <li><a href="/graph">graph</a></li>
   <li><a href="/tags">tags</a></li>
   <li><a href="/bookmarks">bookmarks</a></li>
   <li><a href="/branches">branches</a></li>
   </ul>
   <ul>
    <li class="active"><a href="/help">help</a></li>
   </ul>
   </div>
   
   <div class="main">
   <h2 class="breadcrumb"><a href="/">Mercurial</a> </h2>
   <h3>Help: remove</h3>
   
   <form class="search" action="/log">
   
   <p><input name="rev" id="search1" type="text" size="30" value="" /></p>
   <div id="hint">Find changesets by keywords (author, files, the commit message), revision
   number or hash, or <a href="/help/revsets">revset expression</a>.</div>
   </form>
   <div id="doc">
   <p>
   hg remove [OPTION]... FILE...
   </p>
   <p>
   aliases: rm
   </p>
   <p>
   remove the specified files on the next commit
   </p>
   <p>
   Schedule the indicated files for removal from the current branch.
   </p>
   <p>
   This command schedules the files to be removed at the next commit.
   To undo a remove before that, see 'hg revert'. To undo added
   files, see 'hg forget'.
   </p>
   <p>
   -A/--after can be used to remove only files that have already
   been deleted, -f/--force can be used to force deletion, and -Af
   can be used to remove files from the next revision without
   deleting them from the working directory.
   </p>
   <p>
   The following table details the behavior of remove for different
   file states (columns) and option combinations (rows). The file
   states are Added [A], Clean [C], Modified [M] and Missing [!]
   (as reported by 'hg status'). The actions are Warn, Remove
   (from branch) and Delete (from disk):
   </p>
   <table>
   <tr><td>opt/state</td>
   <td>A</td>
   <td>C</td>
   <td>M</td>
   <td>!</td></tr>
   <tr><td>none</td>
   <td>W</td>
   <td>RD</td>
   <td>W</td>
   <td>R</td></tr>
   <tr><td>-f</td>
   <td>R</td>
   <td>RD</td>
   <td>RD</td>
   <td>R</td></tr>
   <tr><td>-A</td>
   <td>W</td>
   <td>W</td>
   <td>W</td>
   <td>R</td></tr>
   <tr><td>-Af</td>
   <td>R</td>
   <td>R</td>
   <td>R</td>
   <td>R</td></tr>
   </table>
   <p>
   <b>Note:</b> 
   </p>
   <p>
   'hg remove' never deletes files in Added [A] state from the
   working directory, not even if &quot;--force&quot; is specified.
   </p>
   <p>
   Returns 0 on success, 1 if any warnings encountered.
   </p>
   <p>
   options ([+] can be repeated):
   </p>
   <table>
   <tr><td>-A</td>
   <td>--after</td>
   <td>record delete for missing files</td></tr>
   <tr><td>-f</td>
   <td>--force</td>
   <td>forget added files, delete modified files</td></tr>
   <tr><td>-S</td>
   <td>--subrepos</td>
   <td>recurse into subrepositories</td></tr>
   <tr><td>-I</td>
   <td>--include PATTERN [+]</td>
   <td>include names matching the given patterns</td></tr>
   <tr><td>-X</td>
   <td>--exclude PATTERN [+]</td>
   <td>exclude names matching the given patterns</td></tr>
   <tr><td>-n</td>
   <td>--dry-run</td>
   <td>do not perform actions, just print output</td></tr>
   </table>
   <p>
   global options ([+] can be repeated):
   </p>
   <table>
   <tr><td>-R</td>
   <td>--repository REPO</td>
   <td>repository root directory or name of overlay bundle file</td></tr>
   <tr><td></td>
   <td>--cwd DIR</td>
   <td>change working directory</td></tr>
   <tr><td>-y</td>
   <td>--noninteractive</td>
   <td>do not prompt, automatically pick the first choice for all prompts</td></tr>
   <tr><td>-q</td>
   <td>--quiet</td>
   <td>suppress output</td></tr>
   <tr><td>-v</td>
   <td>--verbose</td>
   <td>enable additional output</td></tr>
   <tr><td></td>
   <td>--color TYPE</td>
   <td>when to colorize (boolean, always, auto, never, or debug)</td></tr>
   <tr><td></td>
   <td>--config CONFIG [+]</td>
   <td>set/override config option (use 'section.name=value')</td></tr>
   <tr><td></td>
   <td>--debug</td>
   <td>enable debugging output</td></tr>
   <tr><td></td>
   <td>--debugger</td>
   <td>start debugger</td></tr>
   <tr><td></td>
   <td>--encoding ENCODE</td>
   <td>set the charset encoding (default: ascii)</td></tr>
   <tr><td></td>
   <td>--encodingmode MODE</td>
   <td>set the charset encoding mode (default: strict)</td></tr>
   <tr><td></td>
   <td>--traceback</td>
   <td>always print a traceback on exception</td></tr>
   <tr><td></td>
   <td>--time</td>
   <td>time how long the command takes</td></tr>
   <tr><td></td>
   <td>--profile</td>
   <td>print command execution profile</td></tr>
   <tr><td></td>
   <td>--version</td>
   <td>output version information and exit</td></tr>
   <tr><td>-h</td>
   <td>--help</td>
   <td>display help and exit</td></tr>
   <tr><td></td>
   <td>--hidden</td>
   <td>consider hidden changesets</td></tr>
   <tr><td></td>
   <td>--pager TYPE</td>
   <td>when to paginate (boolean, always, auto, or never) (default: auto)</td></tr>
   </table>
   
   </div>
   </div>
   </div>
   
   
   
   </body>
   </html>
   
 
   $ get-with-headers.py $LOCALIP:$HGPORT "help/dates"
   200 Script output follows
   
   <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
   <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en-US">
   <head>
   <link rel="icon" href="/static/hgicon.png" type="image/png" />
   <meta name="robots" content="index, nofollow" />
   <link rel="stylesheet" href="/static/style-paper.css" type="text/css" />
   <script type="text/javascript" src="/static/mercurial.js"></script>
   
   <title>Help: dates</title>
   </head>
   <body>
   
   <div class="container">
   <div class="menu">
   <div class="logo">
   <a href="https://mercurial-scm.org/">
   <img src="/static/hglogo.png" alt="mercurial" /></a>
   </div>
   <ul>
   <li><a href="/shortlog">log</a></li>
   <li><a href="/graph">graph</a></li>
   <li><a href="/tags">tags</a></li>
   <li><a href="/bookmarks">bookmarks</a></li>
   <li><a href="/branches">branches</a></li>
   </ul>
   <ul>
    <li class="active"><a href="/help">help</a></li>
   </ul>
   </div>
   
   <div class="main">
   <h2 class="breadcrumb"><a href="/">Mercurial</a> </h2>
   <h3>Help: dates</h3>
   
   <form class="search" action="/log">
   
   <p><input name="rev" id="search1" type="text" size="30" value="" /></p>
   <div id="hint">Find changesets by keywords (author, files, the commit message), revision
   number or hash, or <a href="/help/revsets">revset expression</a>.</div>
   </form>
   <div id="doc">
   <h1>Date Formats</h1>
   <p>
   Some commands allow the user to specify a date, e.g.:
   </p>
   <ul>
    <li> backout, commit, import, tag: Specify the commit date.
    <li> log, revert, update: Select revision(s) by date.
   </ul>
   <p>
   Many date formats are valid. Here are some examples:
   </p>
   <ul>
    <li> &quot;Wed Dec 6 13:18:29 2006&quot; (local timezone assumed)
    <li> &quot;Dec 6 13:18 -0600&quot; (year assumed, time offset provided)
    <li> &quot;Dec 6 13:18 UTC&quot; (UTC and GMT are aliases for +0000)
    <li> &quot;Dec 6&quot; (midnight)
    <li> &quot;13:18&quot; (today assumed)
    <li> &quot;3:39&quot; (3:39AM assumed)
    <li> &quot;3:39pm&quot; (15:39)
    <li> &quot;2006-12-06 13:18:29&quot; (ISO 8601 format)
    <li> &quot;2006-12-6 13:18&quot;
    <li> &quot;2006-12-6&quot;
    <li> &quot;12-6&quot;
    <li> &quot;12/6&quot;
    <li> &quot;12/6/6&quot; (Dec 6 2006)
    <li> &quot;today&quot; (midnight)
    <li> &quot;yesterday&quot; (midnight)
    <li> &quot;now&quot; - right now
   </ul>
   <p>
   Lastly, there is Mercurial's internal format:
   </p>
   <ul>
    <li> &quot;1165411109 0&quot; (Wed Dec 6 13:18:29 2006 UTC)
   </ul>
   <p>
   This is the internal representation format for dates. The first number
   is the number of seconds since the epoch (1970-01-01 00:00 UTC). The
   second is the offset of the local timezone, in seconds west of UTC
   (negative if the timezone is east of UTC).
   </p>
   <p>
   The log command also accepts date ranges:
   </p>
   <ul>
    <li> &quot;&lt;DATE&quot; - at or before a given date/time
    <li> &quot;&gt;DATE&quot; - on or after a given date/time
    <li> &quot;DATE to DATE&quot; - a date range, inclusive
    <li> &quot;-DAYS&quot; - within a given number of days of today
   </ul>
   
   </div>
   </div>
   </div>
   
   
   
   </body>
   </html>
   
 
   $ get-with-headers.py $LOCALIP:$HGPORT "help/pager"
   200 Script output follows
   
   <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
   <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en-US">
   <head>
   <link rel="icon" href="/static/hgicon.png" type="image/png" />
   <meta name="robots" content="index, nofollow" />
   <link rel="stylesheet" href="/static/style-paper.css" type="text/css" />
   <script type="text/javascript" src="/static/mercurial.js"></script>
   
   <title>Help: pager</title>
   </head>
   <body>
   
   <div class="container">
   <div class="menu">
   <div class="logo">
   <a href="https://mercurial-scm.org/">
   <img src="/static/hglogo.png" alt="mercurial" /></a>
   </div>
   <ul>
   <li><a href="/shortlog">log</a></li>
   <li><a href="/graph">graph</a></li>
   <li><a href="/tags">tags</a></li>
   <li><a href="/bookmarks">bookmarks</a></li>
   <li><a href="/branches">branches</a></li>
   </ul>
   <ul>
    <li class="active"><a href="/help">help</a></li>
   </ul>
   </div>
   
   <div class="main">
   <h2 class="breadcrumb"><a href="/">Mercurial</a> </h2>
   <h3>Help: pager</h3>
   
   <form class="search" action="/log">
   
   <p><input name="rev" id="search1" type="text" size="30" value="" /></p>
   <div id="hint">Find changesets by keywords (author, files, the commit message), revision
   number or hash, or <a href="/help/revsets">revset expression</a>.</div>
   </form>
   <div id="doc">
   <h1>Pager Support</h1>
   <p>
   Some Mercurial commands can produce a lot of output, and Mercurial will
   attempt to use a pager to make those commands more pleasant.
   </p>
   <p>
   To set the pager that should be used, set the application variable:
   </p>
   <pre>
   [pager]
   pager = less -FRX
   </pre>
   <p>
   If no pager is set in the user or repository configuration, Mercurial uses the
   environment variable $PAGER. If $PAGER is not set, pager.pager from the default
   or system configuration is used. If none of these are set, a default pager will
   be used, typically 'less' on Unix and 'more' on Windows.
   </p>
   <p>
   You can disable the pager for certain commands by adding them to the
   pager.ignore list:
   </p>
   <pre>
   [pager]
   ignore = version, help, update
   </pre>
   <p>
   To ignore global commands like 'hg version' or 'hg help', you have
   to specify them in your user configuration file.
   </p>
   <p>
   To control whether the pager is used at all for an individual command,
   you can use --pager=&lt;value&gt;:
   </p>
   <ul>
    <li> use as needed: 'auto'.
    <li> require the pager: 'yes' or 'on'.
    <li> suppress the pager: 'no' or 'off' (any unrecognized value   will also work).
   </ul>
   <p>
   To globally turn off all attempts to use a pager, set:
   </p>
   <pre>
   [ui]
   paginate = never
   </pre>
   <p>
   which will prevent the pager from running.
   </p>
   
   </div>
   </div>
   </div>
   
   
   
   </body>
   </html>
   
 
 Sub-topic indexes rendered properly
 
   $ get-with-headers.py $LOCALIP:$HGPORT "help/internals"
   200 Script output follows
   
   <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
   <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en-US">
   <head>
   <link rel="icon" href="/static/hgicon.png" type="image/png" />
   <meta name="robots" content="index, nofollow" />
   <link rel="stylesheet" href="/static/style-paper.css" type="text/css" />
   <script type="text/javascript" src="/static/mercurial.js"></script>
   
   <title>Help: internals</title>
   </head>
   <body>
   
   <div class="container">
   <div class="menu">
   <div class="logo">
   <a href="https://mercurial-scm.org/">
   <img src="/static/hglogo.png" alt="mercurial" /></a>
   </div>
   <ul>
   <li><a href="/shortlog">log</a></li>
   <li><a href="/graph">graph</a></li>
   <li><a href="/tags">tags</a></li>
   <li><a href="/bookmarks">bookmarks</a></li>
   <li><a href="/branches">branches</a></li>
   </ul>
   <ul>
   <li><a href="/help">help</a></li>
   </ul>
   </div>
   
   <div class="main">
   <h2 class="breadcrumb"><a href="/">Mercurial</a> </h2>
   
   <form class="search" action="/log">
   
   <p><input name="rev" id="search1" type="text" size="30" value="" /></p>
   <div id="hint">Find changesets by keywords (author, files, the commit message), revision
   number or hash, or <a href="/help/revsets">revset expression</a>.</div>
   </form>
   <table class="bigtable">
   <tr><td colspan="2"><h2><a name="topics" href="#topics">Topics</a></h2></td></tr>
   
   <tr><td>
   <a href="/help/internals.bundle2">
   bundle2
   </a>
   </td><td>
   Bundle2
   </td></tr>
   <tr><td>
   <a href="/help/internals.bundles">
   bundles
   </a>
   </td><td>
   Bundles
   </td></tr>
   <tr><td>
   <a href="/help/internals.cbor">
   cbor
   </a>
   </td><td>
   CBOR
   </td></tr>
   <tr><td>
   <a href="/help/internals.censor">
   censor
   </a>
   </td><td>
   Censor
   </td></tr>
   <tr><td>
   <a href="/help/internals.changegroups">
   changegroups
   </a>
   </td><td>
   Changegroups
   </td></tr>
   <tr><td>
   <a href="/help/internals.config">
   config
   </a>
   </td><td>
   Config Registrar
   </td></tr>
   <tr><td>
   <a href="/help/internals.requirements">
   requirements
   </a>
   </td><td>
   Repository Requirements
   </td></tr>
   <tr><td>
   <a href="/help/internals.revlogs">
   revlogs
   </a>
   </td><td>
   Revision Logs
   </td></tr>
   <tr><td>
   <a href="/help/internals.wireprotocol">
   wireprotocol
   </a>
   </td><td>
   Wire Protocol
   </td></tr>
   <tr><td>
   <a href="/help/internals.wireprotocolrpc">
   wireprotocolrpc
   </a>
   </td><td>
   Wire Protocol RPC
   </td></tr>
   <tr><td>
   <a href="/help/internals.wireprotocolv2">
   wireprotocolv2
   </a>
   </td><td>
   Wire Protocol Version 2
   </td></tr>
   
   
   
   
   
   </table>
   </div>
   </div>
   
   
   
   </body>
   </html>
   
 
 Sub-topic topics rendered properly
 
   $ get-with-headers.py $LOCALIP:$HGPORT "help/internals.changegroups"
   200 Script output follows
   
   <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
   <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en-US">
   <head>
   <link rel="icon" href="/static/hgicon.png" type="image/png" />
   <meta name="robots" content="index, nofollow" />
   <link rel="stylesheet" href="/static/style-paper.css" type="text/css" />
   <script type="text/javascript" src="/static/mercurial.js"></script>
   
   <title>Help: internals.changegroups</title>
   </head>
   <body>
   
   <div class="container">
   <div class="menu">
   <div class="logo">
   <a href="https://mercurial-scm.org/">
   <img src="/static/hglogo.png" alt="mercurial" /></a>
   </div>
   <ul>
   <li><a href="/shortlog">log</a></li>
   <li><a href="/graph">graph</a></li>
   <li><a href="/tags">tags</a></li>
   <li><a href="/bookmarks">bookmarks</a></li>
   <li><a href="/branches">branches</a></li>
   </ul>
   <ul>
    <li class="active"><a href="/help">help</a></li>
   </ul>
   </div>
   
   <div class="main">
   <h2 class="breadcrumb"><a href="/">Mercurial</a> </h2>
   <h3>Help: internals.changegroups</h3>
   
   <form class="search" action="/log">
   
   <p><input name="rev" id="search1" type="text" size="30" value="" /></p>
   <div id="hint">Find changesets by keywords (author, files, the commit message), revision
   number or hash, or <a href="/help/revsets">revset expression</a>.</div>
   </form>
   <div id="doc">
   <h1>Changegroups</h1>
   <p>
   Changegroups are representations of repository revlog data, specifically
   the changelog data, root/flat manifest data, treemanifest data, and
   filelogs.
   </p>
   <p>
   There are 3 versions of changegroups: &quot;1&quot;, &quot;2&quot;, and &quot;3&quot;. From a
   high-level, versions &quot;1&quot; and &quot;2&quot; are almost exactly the same, with the
   only difference being an additional item in the *delta header*.  Version
   &quot;3&quot; adds support for revlog flags in the *delta header* and optionally
   exchanging treemanifests (enabled by setting an option on the
   &quot;changegroup&quot; part in the bundle2).
   </p>
   <p>
   Changegroups when not exchanging treemanifests consist of 3 logical
   segments:
   </p>
   <pre>
   +---------------------------------+
   |           |          |          |
   | changeset | manifest | filelogs |
   |           |          |          |
   |           |          |          |
   +---------------------------------+
   </pre>
   <p>
   When exchanging treemanifests, there are 4 logical segments:
   </p>
   <pre>
   +-------------------------------------------------+
   |           |          |               |          |
   | changeset |   root   | treemanifests | filelogs |
   |           | manifest |               |          |
   |           |          |               |          |
   +-------------------------------------------------+
   </pre>
   <p>
   The principle building block of each segment is a *chunk*. A *chunk*
   is a framed piece of data:
   </p>
   <pre>
   +---------------------------------------+
   |           |                           |
   |  length   |           data            |
   | (4 bytes) |   (&lt;length - 4&gt; bytes)    |
   |           |                           |
   +---------------------------------------+
   </pre>
   <p>
   All integers are big-endian signed integers. Each chunk starts with a 32-bit
   integer indicating the length of the entire chunk (including the length field
   itself).
   </p>
   <p>
   There is a special case chunk that has a value of 0 for the length
   (&quot;0x00000000&quot;). We call this an *empty chunk*.
   </p>
   <h2>Delta Groups</h2>
   <p>
   A *delta group* expresses the content of a revlog as a series of deltas,
   or patches against previous revisions.
   </p>
   <p>
   Delta groups consist of 0 or more *chunks* followed by the *empty chunk*
   to signal the end of the delta group:
   </p>
   <pre>
   +------------------------------------------------------------------------+
   |                |             |               |             |           |
   | chunk0 length  | chunk0 data | chunk1 length | chunk1 data |    0x0    |
   |   (4 bytes)    |  (various)  |   (4 bytes)   |  (various)  | (4 bytes) |
   |                |             |               |             |           |
   +------------------------------------------------------------------------+
   </pre>
   <p>
   Each *chunk*'s data consists of the following:
   </p>
   <pre>
   +---------------------------------------+
   |                        |              |
   |     delta header       |  delta data  |
   |  (various by version)  |  (various)   |
   |                        |              |
   +---------------------------------------+
   </pre>
   <p>
   The *delta data* is a series of *delta*s that describe a diff from an existing
   entry (either that the recipient already has, or previously specified in the
   bundle/changegroup).
   </p>
   <p>
   The *delta header* is different between versions &quot;1&quot;, &quot;2&quot;, and
   &quot;3&quot; of the changegroup format.
   </p>
   <p>
   Version 1 (headerlen=80):
   </p>
   <pre>
   +------------------------------------------------------+
   |            |             |             |             |
   |    node    |   p1 node   |   p2 node   |  link node  |
   | (20 bytes) |  (20 bytes) |  (20 bytes) |  (20 bytes) |
   |            |             |             |             |
   +------------------------------------------------------+
   </pre>
   <p>
   Version 2 (headerlen=100):
   </p>
   <pre>
   +------------------------------------------------------------------+
   |            |             |             |            |            |
   |    node    |   p1 node   |   p2 node   | base node  | link node  |
   | (20 bytes) |  (20 bytes) |  (20 bytes) | (20 bytes) | (20 bytes) |
   |            |             |             |            |            |
   +------------------------------------------------------------------+
   </pre>
   <p>
   Version 3 (headerlen=102):
   </p>
   <pre>
   +------------------------------------------------------------------------------+
   |            |             |             |            |            |           |
   |    node    |   p1 node   |   p2 node   | base node  | link node  |   flags   |
   | (20 bytes) |  (20 bytes) |  (20 bytes) | (20 bytes) | (20 bytes) | (2 bytes) |
   |            |             |             |            |            |           |
   +------------------------------------------------------------------------------+
   </pre>
   <p>
   The *delta data* consists of &quot;chunklen - 4 - headerlen&quot; bytes, which contain a
   series of *delta*s, densely packed (no separators). These deltas describe a diff
   from an existing entry (either that the recipient already has, or previously
   specified in the bundle/changegroup). The format is described more fully in
   &quot;hg help internals.bdiff&quot;, but briefly:
   </p>
   <pre>
   +---------------------------------------------------------------+
   |              |            |            |                      |
   | start offset | end offset | new length |        content       |
   |  (4 bytes)   |  (4 bytes) |  (4 bytes) | (&lt;new length&gt; bytes) |
   |              |            |            |                      |
   +---------------------------------------------------------------+
   </pre>
   <p>
   Please note that the length field in the delta data does *not* include itself.
   </p>
   <p>
   In version 1, the delta is always applied against the previous node from
   the changegroup or the first parent if this is the first entry in the
   changegroup.
   </p>
   <p>
   In version 2 and up, the delta base node is encoded in the entry in the
   changegroup. This allows the delta to be expressed against any parent,
   which can result in smaller deltas and more efficient encoding of data.
   </p>
   <h2>Changeset Segment</h2>
   <p>
   The *changeset segment* consists of a single *delta group* holding
   changelog data. The *empty chunk* at the end of the *delta group* denotes
   the boundary to the *manifest segment*.
   </p>
   <h2>Manifest Segment</h2>
   <p>
   The *manifest segment* consists of a single *delta group* holding manifest
   data. If treemanifests are in use, it contains only the manifest for the
   root directory of the repository. Otherwise, it contains the entire
   manifest data. The *empty chunk* at the end of the *delta group* denotes
   the boundary to the next segment (either the *treemanifests segment* or the
   *filelogs segment*, depending on version and the request options).
   </p>
   <h3>Treemanifests Segment</h3>
   <p>
   The *treemanifests segment* only exists in changegroup version &quot;3&quot;, and
   only if the 'treemanifest' param is part of the bundle2 changegroup part
   (it is not possible to use changegroup version 3 outside of bundle2).
   Aside from the filenames in the *treemanifests segment* containing a
   trailing &quot;/&quot; character, it behaves identically to the *filelogs segment*
   (see below). The final sub-segment is followed by an *empty chunk* (logically,
   a sub-segment with filename size 0). This denotes the boundary to the
   *filelogs segment*.
   </p>
   <h2>Filelogs Segment</h2>
   <p>
   The *filelogs segment* consists of multiple sub-segments, each
   corresponding to an individual file whose data is being described:
   </p>
   <pre>
   +--------------------------------------------------+
   |          |          |          |     |           |
   | filelog0 | filelog1 | filelog2 | ... |    0x0    |
   |          |          |          |     | (4 bytes) |
   |          |          |          |     |           |
   +--------------------------------------------------+
   </pre>
   <p>
   The final filelog sub-segment is followed by an *empty chunk* (logically,
   a sub-segment with filename size 0). This denotes the end of the segment
   and of the overall changegroup.
   </p>
   <p>
   Each filelog sub-segment consists of the following:
   </p>
   <pre>
   +------------------------------------------------------+
   |                 |                      |             |
   | filename length |       filename       | delta group |
   |    (4 bytes)    | (&lt;length - 4&gt; bytes) |  (various)  |
   |                 |                      |             |
   +------------------------------------------------------+
   </pre>
   <p>
   That is, a *chunk* consisting of the filename (not terminated or padded)
   followed by N chunks constituting the *delta group* for this file. The
   *empty chunk* at the end of each *delta group* denotes the boundary to the
   next filelog sub-segment.
   </p>
   
   </div>
   </div>
   </div>
   
   
   
   </body>
   </html>
   
 
   $ get-with-headers.py 127.0.0.1:$HGPORT "help/unknowntopic"
   404 Not Found
   
   <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
   <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en-US">
   <head>
   <link rel="icon" href="/static/hgicon.png" type="image/png" />
   <meta name="robots" content="index, nofollow" />
   <link rel="stylesheet" href="/static/style-paper.css" type="text/css" />
   <script type="text/javascript" src="/static/mercurial.js"></script>
   
   <title>test: error</title>
   </head>
   <body>
   
   <div class="container">
   <div class="menu">
   <div class="logo">
   <a href="https://mercurial-scm.org/">
   <img src="/static/hglogo.png" width=75 height=90 border=0 alt="mercurial" /></a>
   </div>
   <ul>
   <li><a href="/shortlog">log</a></li>
   <li><a href="/graph">graph</a></li>
   <li><a href="/tags">tags</a></li>
   <li><a href="/bookmarks">bookmarks</a></li>
   <li><a href="/branches">branches</a></li>
   </ul>
   <ul>
   <li><a href="/help">help</a></li>
   </ul>
   </div>
   
   <div class="main">
   
   <h2 class="breadcrumb"><a href="/">Mercurial</a> </h2>
   <h3>error</h3>
   
   
   <form class="search" action="/log">
   
   <p><input name="rev" id="search1" type="text" size="30" value="" /></p>
   <div id="hint">Find changesets by keywords (author, files, the commit message), revision
   number or hash, or <a href="/help/revsets">revset expression</a>.</div>
   </form>
   
   <div class="description">
   <p>
   An error occurred while processing your request:
   </p>
   <p>
   Not Found
   </p>
   </div>
   </div>
   </div>
   
   
   
   </body>
   </html>
   
   [1]
 
   $ killdaemons.py
 
 #endif