resolve: graduate resolve.mark-check from experimental, add docs

Since this hasn't been in a release yet, I'm not bothering to add an alias for
the experimental name of the config variable.

Differential Revision: https://phab.mercurial-scm.org/D4071

mercurial/commands.py

@@ -1,5859 +1,5859 b''
 # commands.py - command processing for 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 difflib
 import errno
 import os
 import re
 import sys
 
 from .i18n import _
 from .node import (
     hex,
     nullid,
     nullrev,
     short,
 )
 from . import (
     archival,
     bookmarks,
     bundle2,
     changegroup,
     cmdutil,
     copies,
     debugcommands as debugcommandsmod,
     destutil,
     dirstateguard,
     discovery,
     encoding,
     error,
     exchange,
     extensions,
     filemerge,
     formatter,
     graphmod,
     hbisect,
     help,
     hg,
     logcmdutil,
     merge as mergemod,
     obsolete,
     obsutil,
     patch,
     phases,
     pycompat,
     rcutil,
     registrar,
     repair,
     revsetlang,
     rewriteutil,
     scmutil,
     server,
     state as statemod,
     streamclone,
     tags as tagsmod,
     templatekw,
     ui as uimod,
     util,
     wireprotoserver,
 )
 from .utils import (
     dateutil,
     stringutil,
 )
 
 table = {}
 table.update(debugcommandsmod.command._table)
 
 command = registrar.command(table)
 INTENT_READONLY = registrar.INTENT_READONLY
 
 # common command options
 
 globalopts = [
     ('R', 'repository', '',
      _('repository root directory or name of overlay bundle file'),
      _('REPO')),
     ('', 'cwd', '',
      _('change working directory'), _('DIR')),
     ('y', 'noninteractive', None,
      _('do not prompt, automatically pick the first choice for all prompts')),
     ('q', 'quiet', None, _('suppress output')),
     ('v', 'verbose', None, _('enable additional output')),
     ('', 'color', '',
      # i18n: 'always', 'auto', 'never', and 'debug' are keywords
      # and should not be translated
      _("when to colorize (boolean, always, auto, never, or debug)"),
      _('TYPE')),
     ('', 'config', [],
      _('set/override config option (use \'section.name=value\')'),
      _('CONFIG')),
     ('', 'debug', None, _('enable debugging output')),
     ('', 'debugger', None, _('start debugger')),
     ('', 'encoding', encoding.encoding, _('set the charset encoding'),
      _('ENCODE')),
     ('', 'encodingmode', encoding.encodingmode,
      _('set the charset encoding mode'), _('MODE')),
     ('', 'traceback', None, _('always print a traceback on exception')),
     ('', 'time', None, _('time how long the command takes')),
     ('', 'profile', None, _('print command execution profile')),
     ('', 'version', None, _('output version information and exit')),
     ('h', 'help', None, _('display help and exit')),
     ('', 'hidden', False, _('consider hidden changesets')),
     ('', 'pager', 'auto',
      _("when to paginate (boolean, always, auto, or never)"), _('TYPE')),
 ]
 
 dryrunopts = cmdutil.dryrunopts
 remoteopts = cmdutil.remoteopts
 walkopts = cmdutil.walkopts
 commitopts = cmdutil.commitopts
 commitopts2 = cmdutil.commitopts2
 formatteropts = cmdutil.formatteropts
 templateopts = cmdutil.templateopts
 logopts = cmdutil.logopts
 diffopts = cmdutil.diffopts
 diffwsopts = cmdutil.diffwsopts
 diffopts2 = cmdutil.diffopts2
 mergetoolopts = cmdutil.mergetoolopts
 similarityopts = cmdutil.similarityopts
 subrepoopts = cmdutil.subrepoopts
 debugrevlogopts = cmdutil.debugrevlogopts
 
 # Commands start here, listed alphabetically
 
 @command('^add',
     walkopts + subrepoopts + dryrunopts,
     _('[OPTION]... [FILE]...'),
     inferrepo=True)
 def add(ui, repo, *pats, **opts):
     """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``).
 
     .. container:: verbose
 
        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.
     """
 
     m = scmutil.match(repo[None], pats, pycompat.byteskwargs(opts))
     rejected = cmdutil.add(ui, repo, m, "", False, **opts)
     return rejected and 1 or 0
 
 @command('addremove',
     similarityopts + subrepoopts + walkopts + dryrunopts,
     _('[OPTION]... [FILE]...'),
     inferrepo=True)
 def addremove(ui, repo, *pats, **opts):
     """add all new files, delete all missing files
 
     Add all new files and remove all missing files from the
     repository.
 
     Unless names are given, new files are ignored if they match any of
     the patterns in ``.hgignore``. As with add, these changes take
     effect at the next commit.
 
     Use the -s/--similarity option to detect renamed files. This
     option takes a percentage between 0 (disabled) and 100 (files must
     be identical) as its parameter. With a parameter greater than 0,
     this compares every removed file with every added file and records
     those similar enough as renames. Detecting renamed files this way
     can be expensive. After using this option, :hg:`status -C` can be
     used to check which files were identified as moved or renamed. If
     not specified, -s/--similarity defaults to 100 and only renames of
     identical files are detected.
 
     .. container:: verbose
 
        Examples:
 
          - A number of files (bar.c and foo.c) are new,
            while foobar.c has been removed (without using :hg:`remove`)
            from the repository::
 
              $ ls
              bar.c foo.c
              $ hg status
              ! foobar.c
              ? bar.c
              ? foo.c
              $ hg addremove
              adding bar.c
              adding foo.c
              removing foobar.c
              $ hg status
              A bar.c
              A foo.c
              R foobar.c
 
          - A file foobar.c was moved to foo.c without using :hg:`rename`.
            Afterwards, it was edited slightly::
 
              $ ls
              foo.c
              $ hg status
              ! foobar.c
              ? foo.c
              $ hg addremove --similarity 90
              removing foobar.c
              adding foo.c
              recording removal of foobar.c as rename to foo.c (94% similar)
              $ hg status -C
              A foo.c
                foobar.c
              R foobar.c
 
     Returns 0 if all files are successfully added.
     """
     opts = pycompat.byteskwargs(opts)
     if not opts.get('similarity'):
         opts['similarity'] = '100'
     matcher = scmutil.match(repo[None], pats, opts)
     return scmutil.addremove(repo, matcher, "", opts)
 
 @command('^annotate|blame',
     [('r', 'rev', '', _('annotate the specified revision'), _('REV')),
     ('', 'follow', None,
      _('follow copies/renames and list the filename (DEPRECATED)')),
     ('', 'no-follow', None, _("don't follow copies and renames")),
     ('a', 'text', None, _('treat all files as text')),
     ('u', 'user', None, _('list the author (long with -v)')),
     ('f', 'file', None, _('list the filename')),
     ('d', 'date', None, _('list the date (short with -q)')),
     ('n', 'number', None, _('list the revision number (default)')),
     ('c', 'changeset', None, _('list the changeset')),
     ('l', 'line-number', None, _('show line number at the first appearance')),
     ('', 'skip', [], _('revision to not display (EXPERIMENTAL)'), _('REV')),
     ] + diffwsopts + walkopts + formatteropts,
     _('[-r REV] [-f] [-a] [-u] [-d] [-n] [-c] [-l] FILE...'),
     inferrepo=True)
 def annotate(ui, repo, *pats, **opts):
     """show changeset information by line for each file
 
     List changes in files, showing the revision id responsible for
     each line.
 
     This command is useful for discovering when a change was made and
     by whom.
 
     If you include --file, --user, or --date, the revision number is
     suppressed unless you also include --number.
 
     Without the -a/--text option, annotate will avoid processing files
     it detects as binary. With -a, annotate will annotate the file
     anyway, although the results will probably be neither useful
     nor desirable.
 
     Returns 0 on success.
     """
     opts = pycompat.byteskwargs(opts)
     if not pats:
         raise error.Abort(_('at least one filename or pattern is required'))
 
     if opts.get('follow'):
         # --follow is deprecated and now just an alias for -f/--file
         # to mimic the behavior of Mercurial before version 1.5
         opts['file'] = True
 
     rev = opts.get('rev')
     if rev:
         repo = scmutil.unhidehashlikerevs(repo, [rev], 'nowarn')
     ctx = scmutil.revsingle(repo, rev)
 
     rootfm = ui.formatter('annotate', opts)
     if ui.quiet:
         datefunc = dateutil.shortdate
     else:
         datefunc = dateutil.datestr
     if ctx.rev() is None:
         def hexfn(node):
             if node is None:
                 return None
             else:
                 return rootfm.hexfunc(node)
         if opts.get('changeset'):
             # omit "+" suffix which is appended to node hex
             def formatrev(rev):
                 if rev is None:
                     return '%d' % ctx.p1().rev()
                 else:
                     return '%d' % rev
         else:
             def formatrev(rev):
                 if rev is None:
                     return '%d+' % ctx.p1().rev()
                 else:
                     return '%d ' % rev
         def formathex(hex):
             if hex is None:
                 return '%s+' % rootfm.hexfunc(ctx.p1().node())
             else:
                 return '%s ' % hex
     else:
         hexfn = rootfm.hexfunc
         formatrev = formathex = pycompat.bytestr
 
     opmap = [('user', ' ', lambda x: x.fctx.user(), ui.shortuser),
              ('rev', ' ', lambda x: x.fctx.rev(), formatrev),
              ('node', ' ', lambda x: hexfn(x.fctx.node()), formathex),
              ('date', ' ', lambda x: x.fctx.date(), util.cachefunc(datefunc)),
              ('file', ' ', lambda x: x.fctx.path(), pycompat.bytestr),
              ('line_number', ':', lambda x: x.lineno, pycompat.bytestr),
             ]
     opnamemap = {'rev': 'number', 'node': 'changeset'}
 
     if (not opts.get('user') and not opts.get('changeset')
         and not opts.get('date') and not opts.get('file')):
         opts['number'] = True
 
     linenumber = opts.get('line_number') is not None
     if linenumber and (not opts.get('changeset')) and (not opts.get('number')):
         raise error.Abort(_('at least one of -n/-c is required for -l'))
 
     ui.pager('annotate')
 
     if rootfm.isplain():
         def makefunc(get, fmt):
             return lambda x: fmt(get(x))
     else:
         def makefunc(get, fmt):
             return get
     datahint = rootfm.datahint()
     funcmap = [(makefunc(get, fmt), sep) for fn, sep, get, fmt in opmap
                if opts.get(opnamemap.get(fn, fn)) or fn in datahint]
     funcmap[0] = (funcmap[0][0], '') # no separator in front of first column
     fields = ' '.join(fn for fn, sep, get, fmt in opmap
                       if opts.get(opnamemap.get(fn, fn)) or fn in datahint)
 
     def bad(x, y):
         raise error.Abort("%s: %s" % (x, y))
 
     m = scmutil.match(ctx, pats, opts, badfn=bad)
 
     follow = not opts.get('no_follow')
     diffopts = patch.difffeatureopts(ui, opts, section='annotate',
                                      whitespace=True)
     skiprevs = opts.get('skip')
     if skiprevs:
         skiprevs = scmutil.revrange(repo, skiprevs)
 
     for abs in ctx.walk(m):
         fctx = ctx[abs]
         rootfm.startitem()
         rootfm.data(abspath=abs, path=m.rel(abs))
         if not opts.get('text') and fctx.isbinary():
             rootfm.plain(_("%s: binary file\n")
                          % ((pats and m.rel(abs)) or abs))
             continue
 
         fm = rootfm.nested('lines', tmpl='{rev}: {line}')
         lines = fctx.annotate(follow=follow, skiprevs=skiprevs,
                               diffopts=diffopts)
         if not lines:
             fm.end()
             continue
         formats = []
         pieces = []
 
         for f, sep in funcmap:
             l = [f(n) for n in lines]
             if fm.isplain():
                 sizes = [encoding.colwidth(x) for x in l]
                 ml = max(sizes)
                 formats.append([sep + ' ' * (ml - w) + '%s' for w in sizes])
             else:
                 formats.append(['%s' for x in l])
             pieces.append(l)
 
         for f, p, n in zip(zip(*formats), zip(*pieces), lines):
             fm.startitem()
             fm.context(fctx=n.fctx)
             fm.write(fields, "".join(f), *p)
             if n.skip:
                 fmt = "* %s"
             else:
                 fmt = ": %s"
             fm.write('line', fmt, n.text)
 
         if not lines[-1].text.endswith('\n'):
             fm.plain('\n')
         fm.end()
 
     rootfm.end()
 
 @command('archive',
     [('', 'no-decode', None, _('do not pass files through decoders')),
     ('p', 'prefix', '', _('directory prefix for files in archive'),
      _('PREFIX')),
     ('r', 'rev', '', _('revision to distribute'), _('REV')),
     ('t', 'type', '', _('type of distribution to create'), _('TYPE')),
     ] + subrepoopts + walkopts,
     _('[OPTION]... DEST'))
 def archive(ui, repo, dest, **opts):
     '''create an unversioned archive of a repository revision
 
     By default, the revision used is the parent of the working
     directory; use -r/--rev to specify a different revision.
 
     The archive type is automatically detected based on file
     extension (to override, use -t/--type).
 
     .. container:: verbose
 
       Examples:
 
       - create a zip file containing the 1.0 release::
 
           hg archive -r 1.0 project-1.0.zip
 
       - create a tarball excluding .hg files::
 
           hg archive project.tar.gz -X ".hg*"
 
     Valid types are:
 
     :``files``: a directory full of files (default)
     :``tar``:   tar archive, uncompressed
     :``tbz2``:  tar archive, compressed using bzip2
     :``tgz``:   tar archive, compressed using gzip
     :``uzip``:  zip archive, uncompressed
     :``zip``:   zip archive, compressed using deflate
 
     The exact name of the destination archive or directory is given
     using a format string; see :hg:`help export` for details.
 
     Each member added to an archive file has a directory prefix
     prepended. Use -p/--prefix to specify a format string for the
     prefix. The default is the basename of the archive, with suffixes
     removed.
 
     Returns 0 on success.
     '''
 
     opts = pycompat.byteskwargs(opts)
     rev = opts.get('rev')
     if rev:
         repo = scmutil.unhidehashlikerevs(repo, [rev], 'nowarn')
     ctx = scmutil.revsingle(repo, rev)
     if not ctx:
         raise error.Abort(_('no working directory: please specify a revision'))
     node = ctx.node()
     dest = cmdutil.makefilename(ctx, dest)
     if os.path.realpath(dest) == repo.root:
         raise error.Abort(_('repository root cannot be destination'))
 
     kind = opts.get('type') or archival.guesskind(dest) or 'files'
     prefix = opts.get('prefix')
 
     if dest == '-':
         if kind == 'files':
             raise error.Abort(_('cannot archive plain files to stdout'))
         dest = cmdutil.makefileobj(ctx, dest)
         if not prefix:
             prefix = os.path.basename(repo.root) + '-%h'
 
     prefix = cmdutil.makefilename(ctx, prefix)
     match = scmutil.match(ctx, [], opts)
     archival.archive(repo, dest, node, kind, not opts.get('no_decode'),
                      match, prefix, subrepos=opts.get('subrepos'))
 
 @command('backout',
     [('', 'merge', None, _('merge with old dirstate parent after backout')),
     ('', 'commit', None,
      _('commit if no conflicts were encountered (DEPRECATED)')),
     ('', 'no-commit', None, _('do not commit')),
     ('', 'parent', '',
      _('parent to choose when backing out merge (DEPRECATED)'), _('REV')),
     ('r', 'rev', '', _('revision to backout'), _('REV')),
     ('e', 'edit', False, _('invoke editor on commit messages')),
     ] + mergetoolopts + walkopts + commitopts + commitopts2,
     _('[OPTION]... [-r] REV'))
 def backout(ui, repo, node=None, rev=None, **opts):
     '''reverse effect of earlier changeset
 
     Prepare a new changeset with the effect of REV undone in the
     current working directory. If no conflicts were encountered,
     it will be committed immediately.
 
     If REV is the parent of the working directory, then this new changeset
     is committed automatically (unless --no-commit is specified).
 
     .. note::
 
        :hg:`backout` cannot be used to fix either an unwanted or
        incorrect merge.
 
     .. container:: verbose
 
       Examples:
 
       - Reverse the effect of the parent of the working directory.
         This backout will be committed immediately::
 
           hg backout -r .
 
       - Reverse the effect of previous bad revision 23::
 
           hg backout -r 23
 
       - Reverse the effect of previous bad revision 23 and
         leave changes uncommitted::
 
           hg backout -r 23 --no-commit
           hg commit -m "Backout revision 23"
 
       By default, the pending changeset will have one parent,
       maintaining a linear history. With --merge, the pending
       changeset will instead have two parents: the old parent of the
       working directory and a new child of REV that simply undoes REV.
 
       Before version 1.7, the behavior without --merge was equivalent
       to specifying --merge followed by :hg:`update --clean .` to
       cancel the merge and leave the child of REV as a head to be
       merged separately.
 
     See :hg:`help dates` for a list of formats valid for -d/--date.
 
     See :hg:`help revert` for a way to restore files to the state
     of another revision.
 
     Returns 0 on success, 1 if nothing to backout or there are unresolved
     files.
     '''
     with repo.wlock(), repo.lock():
         return _dobackout(ui, repo, node, rev, **opts)
 
 def _dobackout(ui, repo, node=None, rev=None, **opts):
     opts = pycompat.byteskwargs(opts)
     if opts.get('commit') and opts.get('no_commit'):
         raise error.Abort(_("cannot use --commit with --no-commit"))
     if opts.get('merge') and opts.get('no_commit'):
         raise error.Abort(_("cannot use --merge with --no-commit"))
 
     if rev and node:
         raise error.Abort(_("please specify just one revision"))
 
     if not rev:
         rev = node
 
     if not rev:
         raise error.Abort(_("please specify a revision to backout"))
 
     date = opts.get('date')
     if date:
         opts['date'] = dateutil.parsedate(date)
 
     cmdutil.checkunfinished(repo)
     cmdutil.bailifchanged(repo)
     node = scmutil.revsingle(repo, rev).node()
 
     op1, op2 = repo.dirstate.parents()
     if not repo.changelog.isancestor(node, op1):
         raise error.Abort(_('cannot backout change that is not an ancestor'))
 
     p1, p2 = repo.changelog.parents(node)
     if p1 == nullid:
         raise error.Abort(_('cannot backout a change with no parents'))
     if p2 != nullid:
         if not opts.get('parent'):
             raise error.Abort(_('cannot backout a merge changeset'))
         p = repo.lookup(opts['parent'])
         if p not in (p1, p2):
             raise error.Abort(_('%s is not a parent of %s') %
                              (short(p), short(node)))
         parent = p
     else:
         if opts.get('parent'):
             raise error.Abort(_('cannot use --parent on non-merge changeset'))
         parent = p1
 
     # the backout should appear on the same branch
     branch = repo.dirstate.branch()
     bheads = repo.branchheads(branch)
     rctx = scmutil.revsingle(repo, hex(parent))
     if not opts.get('merge') and op1 != node:
         with dirstateguard.dirstateguard(repo, 'backout'):
             overrides = {('ui', 'forcemerge'): opts.get('tool', '')}
             with ui.configoverride(overrides, 'backout'):
                 stats = mergemod.update(repo, parent, True, True, node, False)
             repo.setparents(op1, op2)
         hg._showstats(repo, stats)
         if stats.unresolvedcount:
             repo.ui.status(_("use 'hg resolve' to retry unresolved "
                              "file merges\n"))
             return 1
     else:
         hg.clean(repo, node, show_stats=False)
         repo.dirstate.setbranch(branch)
         cmdutil.revert(ui, repo, rctx, repo.dirstate.parents())
 
     if opts.get('no_commit'):
         msg = _("changeset %s backed out, "
                 "don't forget to commit.\n")
         ui.status(msg % short(node))
         return 0
 
     def commitfunc(ui, repo, message, match, opts):
         editform = 'backout'
         e = cmdutil.getcommiteditor(editform=editform,
                                     **pycompat.strkwargs(opts))
         if not message:
             # we don't translate commit messages
             message = "Backed out changeset %s" % short(node)
             e = cmdutil.getcommiteditor(edit=True, editform=editform)
         return repo.commit(message, opts.get('user'), opts.get('date'),
                            match, editor=e)
     newnode = cmdutil.commit(ui, repo, commitfunc, [], opts)
     if not newnode:
         ui.status(_("nothing changed\n"))
         return 1
     cmdutil.commitstatus(repo, newnode, branch, bheads)
 
     def nice(node):
         return '%d:%s' % (repo.changelog.rev(node), short(node))
     ui.status(_('changeset %s backs out changeset %s\n') %
               (nice(repo.changelog.tip()), nice(node)))
     if opts.get('merge') and op1 != node:
         hg.clean(repo, op1, show_stats=False)
         ui.status(_('merging with changeset %s\n')
                   % nice(repo.changelog.tip()))
         overrides = {('ui', 'forcemerge'): opts.get('tool', '')}
         with ui.configoverride(overrides, 'backout'):
             return hg.merge(repo, hex(repo.changelog.tip()))
     return 0
 
 @command('bisect',
     [('r', 'reset', False, _('reset bisect state')),
     ('g', 'good', False, _('mark changeset good')),
     ('b', 'bad', False, _('mark changeset bad')),
     ('s', 'skip', False, _('skip testing changeset')),
     ('e', 'extend', False, _('extend the bisect range')),
     ('c', 'command', '', _('use command to check changeset state'), _('CMD')),
     ('U', 'noupdate', False, _('do not update to target'))],
     _("[-gbsr] [-U] [-c CMD] [REV]"))
 def bisect(ui, repo, rev=None, extra=None, command=None,
                reset=None, good=None, bad=None, skip=None, extend=None,
                noupdate=None):
     """subdivision search of changesets
 
     This command helps to find changesets which introduce problems. To
     use, mark the earliest changeset you know exhibits the problem as
     bad, then mark the latest changeset which is free from the problem
     as good. Bisect will update your working directory to a revision
     for testing (unless the -U/--noupdate option is specified). Once
     you have performed tests, mark the working directory as good or
     bad, and bisect will either update to another candidate changeset
     or announce that it has found the bad revision.
 
     As a shortcut, you can also use the revision argument to mark a
     revision as good or bad without checking it out first.
 
     If you supply a command, it will be used for automatic bisection.
     The environment variable HG_NODE will contain the ID of the
     changeset being tested. The exit status of the command will be
     used to mark revisions as good or bad: status 0 means good, 125
     means to skip the revision, 127 (command not found) will abort the
     bisection, and any other non-zero exit status means the revision
     is bad.
 
     .. container:: verbose
 
       Some examples:
 
       - start a bisection with known bad revision 34, and good revision 12::
 
           hg bisect --bad 34
           hg bisect --good 12
 
       - advance the current bisection by marking current revision as good or
         bad::
 
           hg bisect --good
           hg bisect --bad
 
       - mark the current revision, or a known revision, to be skipped (e.g. if
         that revision is not usable because of another issue)::
 
           hg bisect --skip
           hg bisect --skip 23
 
       - skip all revisions that do not touch directories ``foo`` or ``bar``::
 
           hg bisect --skip "!( file('path:foo') & file('path:bar') )"
 
       - forget the current bisection::
 
           hg bisect --reset
 
       - use 'make && make tests' to automatically find the first broken
         revision::
 
           hg bisect --reset
           hg bisect --bad 34
           hg bisect --good 12
           hg bisect --command "make && make tests"
 
       - see all changesets whose states are already known in the current
         bisection::
 
           hg log -r "bisect(pruned)"
 
       - see the changeset currently being bisected (especially useful
         if running with -U/--noupdate)::
 
           hg log -r "bisect(current)"
 
       - see all changesets that took part in the current bisection::
 
           hg log -r "bisect(range)"
 
       - you can even get a nice graph::
 
           hg log --graph -r "bisect(range)"
 
       See :hg:`help revisions.bisect` for more about the `bisect()` predicate.
 
     Returns 0 on success.
     """
     # backward compatibility
     if rev in "good bad reset init".split():
         ui.warn(_("(use of 'hg bisect <cmd>' is deprecated)\n"))
         cmd, rev, extra = rev, extra, None
         if cmd == "good":
             good = True
         elif cmd == "bad":
             bad = True
         else:
             reset = True
     elif extra:
         raise error.Abort(_('incompatible arguments'))
 
     incompatibles = {
         '--bad': bad,
         '--command': bool(command),
         '--extend': extend,
         '--good': good,
         '--reset': reset,
         '--skip': skip,
     }
 
     enabled = [x for x in incompatibles if incompatibles[x]]
 
     if len(enabled) > 1:
         raise error.Abort(_('%s and %s are incompatible') %
                           tuple(sorted(enabled)[0:2]))
 
     if reset:
         hbisect.resetstate(repo)
         return
 
     state = hbisect.load_state(repo)
 
     # update state
     if good or bad or skip:
         if rev:
             nodes = [repo[i].node() for i in scmutil.revrange(repo, [rev])]
         else:
             nodes = [repo.lookup('.')]
         if good:
             state['good'] += nodes
         elif bad:
             state['bad'] += nodes
         elif skip:
             state['skip'] += nodes
         hbisect.save_state(repo, state)
         if not (state['good'] and state['bad']):
             return
 
     def mayupdate(repo, node, show_stats=True):
         """common used update sequence"""
         if noupdate:
             return
         cmdutil.checkunfinished(repo)
         cmdutil.bailifchanged(repo)
         return hg.clean(repo, node, show_stats=show_stats)
 
     displayer = logcmdutil.changesetdisplayer(ui, repo, {})
 
     if command:
         changesets = 1
         if noupdate:
             try:
                 node = state['current'][0]
             except LookupError:
                 raise error.Abort(_('current bisect revision is unknown - '
                                    'start a new bisect to fix'))
         else:
             node, p2 = repo.dirstate.parents()
             if p2 != nullid:
                 raise error.Abort(_('current bisect revision is a merge'))
         if rev:
             node = repo[scmutil.revsingle(repo, rev, node)].node()
         try:
             while changesets:
                 # update state
                 state['current'] = [node]
                 hbisect.save_state(repo, state)
                 status = ui.system(command, environ={'HG_NODE': hex(node)},
                                    blockedtag='bisect_check')
                 if status == 125:
                     transition = "skip"
                 elif status == 0:
                     transition = "good"
                 # status < 0 means process was killed
                 elif status == 127:
                     raise error.Abort(_("failed to execute %s") % command)
                 elif status < 0:
                     raise error.Abort(_("%s killed") % command)
                 else:
                     transition = "bad"
                 state[transition].append(node)
                 ctx = repo[node]
                 ui.status(_('changeset %d:%s: %s\n') % (ctx.rev(), ctx,
                                                         transition))
                 hbisect.checkstate(state)
                 # bisect
                 nodes, changesets, bgood = hbisect.bisect(repo, state)
                 # update to next check
                 node = nodes[0]
                 mayupdate(repo, node, show_stats=False)
         finally:
             state['current'] = [node]
             hbisect.save_state(repo, state)
         hbisect.printresult(ui, repo, state, displayer, nodes, bgood)
         return
 
     hbisect.checkstate(state)
 
     # actually bisect
     nodes, changesets, good = hbisect.bisect(repo, state)
     if extend:
         if not changesets:
             extendnode = hbisect.extendrange(repo, state, nodes, good)
             if extendnode is not None:
                 ui.write(_("Extending search to changeset %d:%s\n")
                          % (extendnode.rev(), extendnode))
                 state['current'] = [extendnode.node()]
                 hbisect.save_state(repo, state)
                 return mayupdate(repo, extendnode.node())
         raise error.Abort(_("nothing to extend"))
 
     if changesets == 0:
         hbisect.printresult(ui, repo, state, displayer, nodes, good)
     else:
         assert len(nodes) == 1 # only a single node can be tested next
         node = nodes[0]
         # compute the approximate number of remaining tests
         tests, size = 0, 2
         while size <= changesets:
             tests, size = tests + 1, size * 2
         rev = repo.changelog.rev(node)
         ui.write(_("Testing changeset %d:%s "
                    "(%d changesets remaining, ~%d tests)\n")
                  % (rev, short(node), changesets, tests))
         state['current'] = [node]
         hbisect.save_state(repo, state)
         return mayupdate(repo, node)
 
 @command('bookmarks|bookmark',
     [('f', 'force', False, _('force')),
     ('r', 'rev', '', _('revision for bookmark action'), _('REV')),
     ('d', 'delete', False, _('delete a given bookmark')),
     ('m', 'rename', '', _('rename a given bookmark'), _('OLD')),
     ('i', 'inactive', False, _('mark a bookmark inactive')),
     ] + formatteropts,
     _('hg bookmarks [OPTIONS]... [NAME]...'))
 def bookmark(ui, repo, *names, **opts):
     '''create a new bookmark or list existing bookmarks
 
     Bookmarks are labels on changesets to help track lines of development.
     Bookmarks are unversioned and can be moved, renamed and deleted.
     Deleting or moving a bookmark has no effect on the associated changesets.
 
     Creating or updating to a bookmark causes it to be marked as 'active'.
     The active bookmark is indicated with a '*'.
     When a commit is made, the active bookmark will advance to the new commit.
     A plain :hg:`update` will also advance an active bookmark, if possible.
     Updating away from a bookmark will cause it to be deactivated.
 
     Bookmarks can be pushed and pulled between repositories (see
     :hg:`help push` and :hg:`help pull`). If a shared bookmark has
     diverged, a new 'divergent bookmark' of the form 'name@path' will
     be created. Using :hg:`merge` will resolve the divergence.
 
     Specifying bookmark as '.' to -m or -d options is equivalent to specifying
     the active bookmark's name.
 
     A bookmark named '@' has the special property that :hg:`clone` will
     check it out by default if it exists.
 
     .. container:: verbose
 
       Examples:
 
       - create an active bookmark for a new line of development::
 
           hg book new-feature
 
       - create an inactive bookmark as a place marker::
 
           hg book -i reviewed
 
       - create an inactive bookmark on another changeset::
 
           hg book -r .^ tested
 
       - rename bookmark turkey to dinner::
 
           hg book -m turkey dinner
 
       - move the '@' bookmark from another branch::
 
           hg book -f @
     '''
     force = opts.get(r'force')
     rev = opts.get(r'rev')
     delete = opts.get(r'delete')
     rename = opts.get(r'rename')
     inactive = opts.get(r'inactive')
 
     if delete and rename:
         raise error.Abort(_("--delete and --rename are incompatible"))
     if delete and rev:
         raise error.Abort(_("--rev is incompatible with --delete"))
     if rename and rev:
         raise error.Abort(_("--rev is incompatible with --rename"))
     if not names and (delete or rev):
         raise error.Abort(_("bookmark name required"))
 
     if delete or rename or names or inactive:
         with repo.wlock(), repo.lock(), repo.transaction('bookmark') as tr:
             if delete:
                 names = pycompat.maplist(repo._bookmarks.expandname, names)
                 bookmarks.delete(repo, tr, names)
             elif rename:
                 if not names:
                     raise error.Abort(_("new bookmark name required"))
                 elif len(names) > 1:
                     raise error.Abort(_("only one new bookmark name allowed"))
                 rename = repo._bookmarks.expandname(rename)
                 bookmarks.rename(repo, tr, rename, names[0], force, inactive)
             elif names:
                 bookmarks.addbookmarks(repo, tr, names, rev, force, inactive)
             elif inactive:
                 if len(repo._bookmarks) == 0:
                     ui.status(_("no bookmarks set\n"))
                 elif not repo._activebookmark:
                     ui.status(_("no active bookmark\n"))
                 else:
                     bookmarks.deactivate(repo)
     else: # show bookmarks
         bookmarks.printbookmarks(ui, repo, **opts)
 
 @command('branch',
     [('f', 'force', None,
      _('set branch name even if it shadows an existing branch')),
      ('C', 'clean', None, _('reset branch name to parent branch name')),
      ('r', 'rev', [], _('change branches of the given revs (EXPERIMENTAL)')),
     ],
     _('[-fC] [NAME]'))
 def branch(ui, repo, label=None, **opts):
     """set or show the current branch name
 
     .. note::
 
        Branch names are permanent and global. Use :hg:`bookmark` to create a
        light-weight bookmark instead. See :hg:`help glossary` for more
        information about named branches and bookmarks.
 
     With no argument, show the current branch name. With one argument,
     set the working directory branch name (the branch will not exist
     in the repository until the next commit). Standard practice
     recommends that primary development take place on the 'default'
     branch.
 
     Unless -f/--force is specified, branch will not let you set a
     branch name that already exists.
 
     Use -C/--clean to reset the working directory branch to that of
     the parent of the working directory, negating a previous branch
     change.
 
     Use the command :hg:`update` to switch to an existing branch. Use
     :hg:`commit --close-branch` to mark this branch head as closed.
     When all heads of a branch are closed, the branch will be
     considered closed.
 
     Returns 0 on success.
     """
     opts = pycompat.byteskwargs(opts)
     revs = opts.get('rev')
     if label:
         label = label.strip()
 
     if not opts.get('clean') and not label:
         if revs:
             raise error.Abort(_("no branch name specified for the revisions"))
         ui.write("%s\n" % repo.dirstate.branch())
         return
 
     with repo.wlock():
         if opts.get('clean'):
             label = repo[None].p1().branch()
             repo.dirstate.setbranch(label)
             ui.status(_('reset working directory to branch %s\n') % label)
         elif label:
 
             scmutil.checknewlabel(repo, label, 'branch')
             if revs:
                 return cmdutil.changebranch(ui, repo, revs, label)
 
             if not opts.get('force') and label in repo.branchmap():
                 if label not in [p.branch() for p in repo[None].parents()]:
                     raise error.Abort(_('a branch of the same name already'
                                        ' exists'),
                                      # i18n: "it" refers to an existing branch
                                      hint=_("use 'hg update' to switch to it"))
 
             repo.dirstate.setbranch(label)
             ui.status(_('marked working directory as branch %s\n') % label)
 
             # find any open named branches aside from default
             others = [n for n, h, t, c in repo.branchmap().iterbranches()
                       if n != "default" and not c]
             if not others:
                 ui.status(_('(branches are permanent and global, '
                             'did you want a bookmark?)\n'))
 
 @command('branches',
     [('a', 'active', False,
       _('show only branches that have unmerged heads (DEPRECATED)')),
      ('c', 'closed', False, _('show normal and closed branches')),
     ] + formatteropts,
     _('[-c]'),
     intents={INTENT_READONLY})
 def branches(ui, repo, active=False, closed=False, **opts):
     """list repository named branches
 
     List the repository's named branches, indicating which ones are
     inactive. If -c/--closed is specified, also list branches which have
     been marked closed (see :hg:`commit --close-branch`).
 
     Use the command :hg:`update` to switch to an existing branch.
 
     Returns 0.
     """
 
     opts = pycompat.byteskwargs(opts)
     ui.pager('branches')
     fm = ui.formatter('branches', opts)
     hexfunc = fm.hexfunc
 
     allheads = set(repo.heads())
     branches = []
     for tag, heads, tip, isclosed in repo.branchmap().iterbranches():
         isactive = False
         if not isclosed:
             openheads = set(repo.branchmap().iteropen(heads))
             isactive = bool(openheads & allheads)
         branches.append((tag, repo[tip], isactive, not isclosed))
     branches.sort(key=lambda i: (i[2], i[1].rev(), i[0], i[3]),
                   reverse=True)
 
     for tag, ctx, isactive, isopen in branches:
         if active and not isactive:
             continue
         if isactive:
             label = 'branches.active'
             notice = ''
         elif not isopen:
             if not closed:
                 continue
             label = 'branches.closed'
             notice = _(' (closed)')
         else:
             label = 'branches.inactive'
             notice = _(' (inactive)')
         current = (tag == repo.dirstate.branch())
         if current:
             label = 'branches.current'
 
         fm.startitem()
         fm.write('branch', '%s', tag, label=label)
         rev = ctx.rev()
         padsize = max(31 - len("%d" % rev) - encoding.colwidth(tag), 0)
         fmt = ' ' * padsize + ' %d:%s'
         fm.condwrite(not ui.quiet, 'rev node', fmt, rev, hexfunc(ctx.node()),
                      label='log.changeset changeset.%s' % ctx.phasestr())
         fm.context(ctx=ctx)
         fm.data(active=isactive, closed=not isopen, current=current)
         if not ui.quiet:
             fm.plain(notice)
         fm.plain('\n')
     fm.end()
 
 @command('bundle',
     [('f', 'force', None, _('run even when the destination is unrelated')),
     ('r', 'rev', [], _('a changeset intended to be added to the destination'),
      _('REV')),
     ('b', 'branch', [], _('a specific branch you would like to bundle'),
      _('BRANCH')),
     ('', 'base', [],
      _('a base changeset assumed to be available at the destination'),
      _('REV')),
     ('a', 'all', None, _('bundle all changesets in the repository')),
     ('t', 'type', 'bzip2', _('bundle compression type to use'), _('TYPE')),
     ] + remoteopts,
     _('[-f] [-t BUNDLESPEC] [-a] [-r REV]... [--base REV]... FILE [DEST]'))
 def bundle(ui, repo, fname, dest=None, **opts):
     """create a bundle file
 
     Generate a bundle file containing data to be transferred to another
     repository.
 
     To create a bundle containing all changesets, use -a/--all
     (or --base null). Otherwise, hg assumes the destination will have
     all the nodes you specify with --base parameters. Otherwise, hg
     will assume the repository has all the nodes in destination, or
     default-push/default if no destination is specified, where destination
     is the repository you provide through DEST option.
 
     You can change bundle format with the -t/--type option. See
     :hg:`help bundlespec` for documentation on this format. By default,
     the most appropriate format is used and compression defaults to
     bzip2.
 
     The bundle file can then be transferred using conventional means
     and applied to another repository with the unbundle or pull
     command. This is useful when direct push and pull are not
     available or when exporting an entire repository is undesirable.
 
     Applying bundles preserves all changeset contents including
     permissions, copy/rename information, and revision history.
 
     Returns 0 on success, 1 if no changes found.
     """
     opts = pycompat.byteskwargs(opts)
     revs = None
     if 'rev' in opts:
         revstrings = opts['rev']
         revs = scmutil.revrange(repo, revstrings)
         if revstrings and not revs:
             raise error.Abort(_('no commits to bundle'))
 
     bundletype = opts.get('type', 'bzip2').lower()
     try:
         bundlespec = exchange.parsebundlespec(repo, bundletype, strict=False)
     except error.UnsupportedBundleSpecification as e:
         raise error.Abort(pycompat.bytestr(e),
                           hint=_("see 'hg help bundlespec' for supported "
                                  "values for --type"))
     cgversion = bundlespec.contentopts["cg.version"]
 
     # Packed bundles are a pseudo bundle format for now.
     if cgversion == 's1':
         raise error.Abort(_('packed bundles cannot be produced by "hg bundle"'),
                           hint=_("use 'hg debugcreatestreamclonebundle'"))
 
     if opts.get('all'):
         if dest:
             raise error.Abort(_("--all is incompatible with specifying "
                                 "a destination"))
         if opts.get('base'):
             ui.warn(_("ignoring --base because --all was specified\n"))
         base = ['null']
     else:
         base = scmutil.revrange(repo, opts.get('base'))
     if cgversion not in changegroup.supportedoutgoingversions(repo):
         raise error.Abort(_("repository does not support bundle version %s") %
                           cgversion)
 
     if base:
         if dest:
             raise error.Abort(_("--base is incompatible with specifying "
                                "a destination"))
         common = [repo[rev].node() for rev in base]
         heads = [repo[r].node() for r in revs] if revs else None
         outgoing = discovery.outgoing(repo, common, heads)
     else:
         dest = ui.expandpath(dest or 'default-push', dest or 'default')
         dest, branches = hg.parseurl(dest, opts.get('branch'))
         other = hg.peer(repo, opts, dest)
         revs = [repo[r].hex() for r in revs]
         revs, checkout = hg.addbranchrevs(repo, repo, branches, revs)
         heads = revs and pycompat.maplist(repo.lookup, revs) or revs
         outgoing = discovery.findcommonoutgoing(repo, other,
                                                 onlyheads=heads,
                                                 force=opts.get('force'),
                                                 portable=True)
 
     if not outgoing.missing:
         scmutil.nochangesfound(ui, repo, not base and outgoing.excluded)
         return 1
 
     if cgversion == '01': #bundle1
         bversion = 'HG10' + bundlespec.wirecompression
         bcompression = None
     elif cgversion in ('02', '03'):
         bversion = 'HG20'
         bcompression = bundlespec.wirecompression
     else:
         raise error.ProgrammingError(
             'bundle: unexpected changegroup version %s' % cgversion)
 
     # TODO compression options should be derived from bundlespec parsing.
     # This is a temporary hack to allow adjusting bundle compression
     # level without a) formalizing the bundlespec changes to declare it
     # b) introducing a command flag.
     compopts = {}
     complevel = ui.configint('experimental',
                              'bundlecomplevel.' + bundlespec.compression)
     if complevel is None:
         complevel = ui.configint('experimental', 'bundlecomplevel')
     if complevel is not None:
         compopts['level'] = complevel
 
     # Allow overriding the bundling of obsmarker in phases through
     # configuration while we don't have a bundle version that include them
     if repo.ui.configbool('experimental', 'evolution.bundle-obsmarker'):
         bundlespec.contentopts['obsolescence'] = True
     if repo.ui.configbool('experimental', 'bundle-phases'):
         bundlespec.contentopts['phases'] = True
 
     bundle2.writenewbundle(ui, repo, 'bundle', fname, bversion, outgoing,
                            bundlespec.contentopts, compression=bcompression,
                            compopts=compopts)
 
 @command('cat',
     [('o', 'output', '',
      _('print output to file with formatted name'), _('FORMAT')),
     ('r', 'rev', '', _('print the given revision'), _('REV')),
     ('', 'decode', None, _('apply any matching decode filter')),
     ] + walkopts + formatteropts,
     _('[OPTION]... FILE...'),
     inferrepo=True,
     intents={INTENT_READONLY})
 def cat(ui, repo, file1, *pats, **opts):
     """output the current or given revision of files
 
     Print the specified files as they were at the given revision. If
     no revision is given, the parent of the working directory is used.
 
     Output may be to a file, in which case the name of the file is
     given using a template string. See :hg:`help templates`. In addition
     to the common template keywords, the following formatting rules are
     supported:
 
     :``%%``: literal "%" character
     :``%s``: basename of file being printed
     :``%d``: dirname of file being printed, or '.' if in repository root
     :``%p``: root-relative path name of file being printed
     :``%H``: changeset hash (40 hexadecimal digits)
     :``%R``: changeset revision number
     :``%h``: short-form changeset hash (12 hexadecimal digits)
     :``%r``: zero-padded changeset revision number
     :``%b``: basename of the exporting repository
     :``\\``: literal "\\" character
 
     Returns 0 on success.
     """
     opts = pycompat.byteskwargs(opts)
     rev = opts.get('rev')
     if rev:
         repo = scmutil.unhidehashlikerevs(repo, [rev], 'nowarn')
     ctx = scmutil.revsingle(repo, rev)
     m = scmutil.match(ctx, (file1,) + pats, opts)
     fntemplate = opts.pop('output', '')
     if cmdutil.isstdiofilename(fntemplate):
         fntemplate = ''
 
     if fntemplate:
         fm = formatter.nullformatter(ui, 'cat', opts)
     else:
         ui.pager('cat')
         fm = ui.formatter('cat', opts)
     with fm:
         return cmdutil.cat(ui, repo, ctx, m, fm, fntemplate, '',
                            **pycompat.strkwargs(opts))
 
 @command('^clone',
     [('U', 'noupdate', None, _('the clone will include an empty working '
                                'directory (only a repository)')),
     ('u', 'updaterev', '', _('revision, tag, or branch to check out'),
         _('REV')),
     ('r', 'rev', [], _('do not clone everything, but include this changeset'
                        ' and its ancestors'), _('REV')),
     ('b', 'branch', [], _('do not clone everything, but include this branch\'s'
                           ' changesets and their ancestors'), _('BRANCH')),
     ('', 'pull', None, _('use pull protocol to copy metadata')),
     ('', 'uncompressed', None,
        _('an alias to --stream (DEPRECATED)')),
     ('', 'stream', None,
        _('clone with minimal data processing')),
     ] + remoteopts,
     _('[OPTION]... SOURCE [DEST]'),
     norepo=True)
 def clone(ui, source, dest=None, **opts):
     """make a copy of an existing repository
 
     Create a copy of an existing repository in a new directory.
 
     If no destination directory name is specified, it defaults to the
     basename of the source.
 
     The location of the source is added to the new repository's
     ``.hg/hgrc`` file, as the default to be used for future pulls.
 
     Only local paths and ``ssh://`` URLs are supported as
     destinations. For ``ssh://`` destinations, no working directory or
     ``.hg/hgrc`` will be created on the remote side.
 
     If the source repository has a bookmark called '@' set, that
     revision will be checked out in the new repository by default.
 
     To check out a particular version, use -u/--update, or
     -U/--noupdate to create a clone with no working directory.
 
     To pull only a subset of changesets, specify one or more revisions
     identifiers with -r/--rev or branches with -b/--branch. The
     resulting clone will contain only the specified changesets and
     their ancestors. These options (or 'clone src#rev dest') imply
     --pull, even for local source repositories.
 
     In normal clone mode, the remote normalizes repository data into a common
     exchange format and the receiving end translates this data into its local
     storage format. --stream activates a different clone mode that essentially
     copies repository files from the remote with minimal data processing. This
     significantly reduces the CPU cost of a clone both remotely and locally.
     However, it often increases the transferred data size by 30-40%. This can
     result in substantially faster clones where I/O throughput is plentiful,
     especially for larger repositories. A side-effect of --stream clones is
     that storage settings and requirements on the remote are applied locally:
     a modern client may inherit legacy or inefficient storage used by the
     remote or a legacy Mercurial client may not be able to clone from a
     modern Mercurial remote.
 
     .. note::
 
        Specifying a tag will include the tagged changeset but not the
        changeset containing the tag.
 
     .. container:: verbose
 
       For efficiency, hardlinks are used for cloning whenever the
       source and destination are on the same filesystem (note this
       applies only to the repository data, not to the working
       directory). Some filesystems, such as AFS, implement hardlinking
       incorrectly, but do not report errors. In these cases, use the
       --pull option to avoid hardlinking.
 
       Mercurial will update the working directory to the first applicable
       revision from this list:
 
       a) null if -U or the source repository has no changesets
       b) if -u . and the source repository is local, the first parent of
          the source repository's working directory
       c) the changeset specified with -u (if a branch name, this means the
          latest head of that branch)
       d) the changeset specified with -r
       e) the tipmost head specified with -b
       f) the tipmost head specified with the url#branch source syntax
       g) the revision marked with the '@' bookmark, if present
       h) the tipmost head of the default branch
       i) tip
 
       When cloning from servers that support it, Mercurial may fetch
       pre-generated data from a server-advertised URL or inline from the
       same stream. When this is done, hooks operating on incoming changesets
       and changegroups may fire more than once, once for each pre-generated
       bundle and as well as for any additional remaining data. In addition,
       if an error occurs, the repository may be rolled back to a partial
       clone. This behavior may change in future releases.
       See :hg:`help -e clonebundles` for more.
 
       Examples:
 
       - clone a remote repository to a new directory named hg/::
 
           hg clone https://www.mercurial-scm.org/repo/hg/
 
       - create a lightweight local clone::
 
           hg clone project/ project-feature/
 
       - clone from an absolute path on an ssh server (note double-slash)::
 
           hg clone ssh://user@server//home/projects/alpha/
 
       - do a streaming clone while checking out a specified version::
 
           hg clone --stream http://server/repo -u 1.5
 
       - create a repository without changesets after a particular revision::
 
           hg clone -r 04e544 experimental/ good/
 
       - clone (and track) a particular named branch::
 
           hg clone https://www.mercurial-scm.org/repo/hg/#stable
 
     See :hg:`help urls` for details on specifying URLs.
 
     Returns 0 on success.
     """
     opts = pycompat.byteskwargs(opts)
     if opts.get('noupdate') and opts.get('updaterev'):
         raise error.Abort(_("cannot specify both --noupdate and --updaterev"))
 
     r = hg.clone(ui, opts, source, dest,
                  pull=opts.get('pull'),
                  stream=opts.get('stream') or opts.get('uncompressed'),
                  revs=opts.get('rev'),
                  update=opts.get('updaterev') or not opts.get('noupdate'),
                  branch=opts.get('branch'),
                  shareopts=opts.get('shareopts'))
 
     return r is None
 
 @command('^commit|ci',
     [('A', 'addremove', None,
      _('mark new/missing files as added/removed before committing')),
     ('', 'close-branch', None,
      _('mark a branch head as closed')),
     ('', 'amend', None, _('amend the parent of the working directory')),
     ('s', 'secret', None, _('use the secret phase for committing')),
     ('e', 'edit', None, _('invoke editor on commit messages')),
     ('i', 'interactive', None, _('use interactive mode')),
     ] + walkopts + commitopts + commitopts2 + subrepoopts,
     _('[OPTION]... [FILE]...'),
     inferrepo=True)
 def commit(ui, repo, *pats, **opts):
     """commit the specified files or all outstanding changes
 
     Commit changes to the given files into the repository. Unlike a
     centralized SCM, this operation is a local operation. See
     :hg:`push` for a way to actively distribute your changes.
 
     If a list of files is omitted, all changes reported by :hg:`status`
     will be committed.
 
     If you are committing the result of a merge, do not provide any
     filenames or -I/-X filters.
 
     If no commit message is specified, Mercurial starts your
     configured editor where you can enter a message. In case your
     commit fails, you will find a backup of your message in
     ``.hg/last-message.txt``.
 
     The --close-branch flag can be used to mark the current branch
     head closed. When all heads of a branch are closed, the branch
     will be considered closed and no longer listed.
 
     The --amend flag can be used to amend the parent of the
     working directory with a new commit that contains the changes
     in the parent in addition to those currently reported by :hg:`status`,
     if there are any. The old commit is stored in a backup bundle in
     ``.hg/strip-backup`` (see :hg:`help bundle` and :hg:`help unbundle`
     on how to restore it).
 
     Message, user and date are taken from the amended commit unless
     specified. When a message isn't specified on the command line,
     the editor will open with the message of the amended commit.
 
     It is not possible to amend public changesets (see :hg:`help phases`)
     or changesets that have children.
 
     See :hg:`help dates` for a list of formats valid for -d/--date.
 
     Returns 0 on success, 1 if nothing changed.
 
     .. container:: verbose
 
       Examples:
 
       - commit all files ending in .py::
 
           hg commit --include "set:**.py"
 
       - commit all non-binary files::
 
           hg commit --exclude "set:binary()"
 
       - amend the current commit and set the date to now::
 
           hg commit --amend --date now
     """
     with repo.wlock(), repo.lock():
         return _docommit(ui, repo, *pats, **opts)
 
 def _docommit(ui, repo, *pats, **opts):
     if opts.get(r'interactive'):
         opts.pop(r'interactive')
         ret = cmdutil.dorecord(ui, repo, commit, None, False,
                                cmdutil.recordfilter, *pats,
                                **opts)
         # ret can be 0 (no changes to record) or the value returned by
         # commit(), 1 if nothing changed or None on success.
         return 1 if ret == 0 else ret
 
     opts = pycompat.byteskwargs(opts)
     if opts.get('subrepos'):
         if opts.get('amend'):
             raise error.Abort(_('cannot amend with --subrepos'))
         # Let --subrepos on the command line override config setting.
         ui.setconfig('ui', 'commitsubrepos', True, 'commit')
 
     cmdutil.checkunfinished(repo, commit=True)
 
     branch = repo[None].branch()
     bheads = repo.branchheads(branch)
 
     extra = {}
     if opts.get('close_branch'):
         extra['close'] = '1'
 
         if not bheads:
             raise error.Abort(_('can only close branch heads'))
         elif opts.get('amend'):
             if repo[None].parents()[0].p1().branch() != branch and \
                     repo[None].parents()[0].p2().branch() != branch:
                 raise error.Abort(_('can only close branch heads'))
 
     if opts.get('amend'):
         if ui.configbool('ui', 'commitsubrepos'):
             raise error.Abort(_('cannot amend with ui.commitsubrepos enabled'))
 
         old = repo['.']
         rewriteutil.precheck(repo, [old.rev()], 'amend')
 
         # Currently histedit gets confused if an amend happens while histedit
         # is in progress. Since we have a checkunfinished command, we are
         # temporarily honoring it.
         #
         # Note: eventually this guard will be removed. Please do not expect
         # this behavior to remain.
         if not obsolete.isenabled(repo, obsolete.createmarkersopt):
             cmdutil.checkunfinished(repo)
 
         node = cmdutil.amend(ui, repo, old, extra, pats, opts)
         if node == old.node():
             ui.status(_("nothing changed\n"))
             return 1
     else:
         def commitfunc(ui, repo, message, match, opts):
             overrides = {}
             if opts.get('secret'):
                 overrides[('phases', 'new-commit')] = 'secret'
 
             baseui = repo.baseui
             with baseui.configoverride(overrides, 'commit'):
                 with ui.configoverride(overrides, 'commit'):
                     editform = cmdutil.mergeeditform(repo[None],
                                                      'commit.normal')
                     editor = cmdutil.getcommiteditor(
                         editform=editform, **pycompat.strkwargs(opts))
                     return repo.commit(message,
                                        opts.get('user'),
                                        opts.get('date'),
                                        match,
                                        editor=editor,
                                        extra=extra)
 
         node = cmdutil.commit(ui, repo, commitfunc, pats, opts)
 
         if not node:
             stat = cmdutil.postcommitstatus(repo, pats, opts)
             if stat[3]:
                 ui.status(_("nothing changed (%d missing files, see "
                             "'hg status')\n") % len(stat[3]))
             else:
                 ui.status(_("nothing changed\n"))
             return 1
 
     cmdutil.commitstatus(repo, node, branch, bheads, opts)
 
 @command('config|showconfig|debugconfig',
     [('u', 'untrusted', None, _('show untrusted configuration options')),
      ('e', 'edit', None, _('edit user config')),
      ('l', 'local', None, _('edit repository config')),
      ('g', 'global', None, _('edit global config'))] + formatteropts,
     _('[-u] [NAME]...'),
     optionalrepo=True,
     intents={INTENT_READONLY})
 def config(ui, repo, *values, **opts):
     """show combined config settings from all hgrc files
 
     With no arguments, print names and values of all config items.
 
     With one argument of the form section.name, print just the value
     of that config item.
 
     With multiple arguments, print names and values of all config
     items with matching section names or section.names.
 
     With --edit, start an editor on the user-level config file. With
     --global, edit the system-wide config file. With --local, edit the
     repository-level config file.
 
     With --debug, the source (filename and line number) is printed
     for each config item.
 
     See :hg:`help config` for more information about config files.
 
     Returns 0 on success, 1 if NAME does not exist.
 
     """
 
     opts = pycompat.byteskwargs(opts)
     if opts.get('edit') or opts.get('local') or opts.get('global'):
         if opts.get('local') and opts.get('global'):
             raise error.Abort(_("can't use --local and --global together"))
 
         if opts.get('local'):
             if not repo:
                 raise error.Abort(_("can't use --local outside a repository"))
             paths = [repo.vfs.join('hgrc')]
         elif opts.get('global'):
             paths = rcutil.systemrcpath()
         else:
             paths = rcutil.userrcpath()
 
         for f in paths:
             if os.path.exists(f):
                 break
         else:
             if opts.get('global'):
                 samplehgrc = uimod.samplehgrcs['global']
             elif opts.get('local'):
                 samplehgrc = uimod.samplehgrcs['local']
             else:
                 samplehgrc = uimod.samplehgrcs['user']
 
             f = paths[0]
             fp = open(f, "wb")
             fp.write(util.tonativeeol(samplehgrc))
             fp.close()
 
         editor = ui.geteditor()
         ui.system("%s \"%s\"" % (editor, f),
                   onerr=error.Abort, errprefix=_("edit failed"),
                   blockedtag='config_edit')
         return
     ui.pager('config')
     fm = ui.formatter('config', opts)
     for t, f in rcutil.rccomponents():
         if t == 'path':
             ui.debug('read config from: %s\n' % f)
         elif t == 'items':
             for section, name, value, source in f:
                 ui.debug('set config by: %s\n' % source)
         else:
             raise error.ProgrammingError('unknown rctype: %s' % t)
     untrusted = bool(opts.get('untrusted'))
 
     selsections = selentries = []
     if values:
         selsections = [v for v in values if '.' not in v]
         selentries = [v for v in values if '.' in v]
     uniquesel = (len(selentries) == 1 and not selsections)
     selsections = set(selsections)
     selentries = set(selentries)
 
     matched = False
     for section, name, value in ui.walkconfig(untrusted=untrusted):
         source = ui.configsource(section, name, untrusted)
         value = pycompat.bytestr(value)
         if fm.isplain():
             source = source or 'none'
             value = value.replace('\n', '\\n')
         entryname = section + '.' + name
         if values and not (section in selsections or entryname in selentries):
             continue
         fm.startitem()
         fm.condwrite(ui.debugflag, 'source', '%s: ', source)
         if uniquesel:
             fm.data(name=entryname)
             fm.write('value', '%s\n', value)
         else:
             fm.write('name value', '%s=%s\n', entryname, value)
         matched = True
     fm.end()
     if matched:
         return 0
     return 1
 
 @command('copy|cp',
     [('A', 'after', None, _('record a copy that has already occurred')),
     ('f', 'force', None, _('forcibly copy over an existing managed file')),
     ] + walkopts + dryrunopts,
     _('[OPTION]... [SOURCE]... DEST'))
 def copy(ui, repo, *pats, **opts):
     """mark files as copied for the next commit
 
     Mark dest as having copies of source files. If dest is a
     directory, copies are put in that directory. If dest is a file,
     the source must be a single file.
 
     By default, this command copies the contents of files as they
     exist in the working directory. If invoked with -A/--after, the
     operation is recorded, but no copying is performed.
 
     This command takes effect with the next commit. To undo a copy
     before that, see :hg:`revert`.
 
     Returns 0 on success, 1 if errors are encountered.
     """
     opts = pycompat.byteskwargs(opts)
     with repo.wlock(False):
         return cmdutil.copy(ui, repo, pats, opts)
 
 @command('debugcommands', [], _('[COMMAND]'), norepo=True)
 def debugcommands(ui, cmd='', *args):
     """list all available commands and options"""
     for cmd, vals in sorted(table.iteritems()):
         cmd = cmd.split('|')[0].strip('^')
         opts = ', '.join([i[1] for i in vals[1]])
         ui.write('%s: %s\n' % (cmd, opts))
 
 @command('debugcomplete',
     [('o', 'options', None, _('show the command options'))],
     _('[-o] CMD'),
     norepo=True)
 def debugcomplete(ui, cmd='', **opts):
     """returns the completion list associated with the given command"""
 
     if opts.get(r'options'):
         options = []
         otables = [globalopts]
         if cmd:
             aliases, entry = cmdutil.findcmd(cmd, table, False)
             otables.append(entry[1])
         for t in otables:
             for o in t:
                 if "(DEPRECATED)" in o[3]:
                     continue
                 if o[0]:
                     options.append('-%s' % o[0])
                 options.append('--%s' % o[1])
         ui.write("%s\n" % "\n".join(options))
         return
 
     cmdlist, unused_allcmds = cmdutil.findpossible(cmd, table)
     if ui.verbose:
         cmdlist = [' '.join(c[0]) for c in cmdlist.values()]
     ui.write("%s\n" % "\n".join(sorted(cmdlist)))
 
 @command('^diff',
     [('r', 'rev', [], _('revision'), _('REV')),
     ('c', 'change', '', _('change made by revision'), _('REV'))
     ] + diffopts + diffopts2 + walkopts + subrepoopts,
     _('[OPTION]... ([-c REV] | [-r REV1 [-r REV2]]) [FILE]...'),
     inferrepo=True,
     intents={INTENT_READONLY})
 def diff(ui, repo, *pats, **opts):
     """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`.
 
     .. container:: verbose
 
       Examples:
 
       - compare a file in the current working directory to its parent::
 
           hg diff foo.c
 
       - compare two historical versions of a directory, with rename info::
 
           hg diff --git -r 1.0:1.2 lib/
 
       - get change stats relative to the last change on some date::
 
           hg diff --stat -r "date('may 2')"
 
       - diff all newly-added files that contain a keyword::
 
           hg diff "set:added() and grep(GNU)"
 
       - compare a revision and its parents::
 
           hg diff -c 9353         # compare against first parent
           hg diff -r 9353^:9353   # same using revset syntax
           hg diff -r 9353^2:9353  # compare against the second parent
 
     Returns 0 on success.
     """
 
     opts = pycompat.byteskwargs(opts)
     revs = opts.get('rev')
     change = opts.get('change')
     stat = opts.get('stat')
     reverse = opts.get('reverse')
 
     if revs and change:
         msg = _('cannot specify --rev and --change at the same time')
         raise error.Abort(msg)
     elif change:
         repo = scmutil.unhidehashlikerevs(repo, [change], 'nowarn')
         ctx2 = scmutil.revsingle(repo, change, None)
         ctx1 = ctx2.p1()
     else:
         repo = scmutil.unhidehashlikerevs(repo, revs, 'nowarn')
         ctx1, ctx2 = scmutil.revpair(repo, revs)
     node1, node2 = ctx1.node(), ctx2.node()
 
     if reverse:
         node1, node2 = node2, node1
 
     diffopts = patch.diffallopts(ui, opts)
     m = scmutil.match(ctx2, pats, opts)
     ui.pager('diff')
     logcmdutil.diffordiffstat(ui, repo, diffopts, node1, node2, m, stat=stat,
                               listsubrepos=opts.get('subrepos'),
                               root=opts.get('root'))
 
 @command('^export',
     [('B', 'bookmark', '',
      _('export changes only reachable by given bookmark')),
     ('o', 'output', '',
      _('print output to file with formatted name'), _('FORMAT')),
     ('', 'switch-parent', None, _('diff against the second parent')),
     ('r', 'rev', [], _('revisions to export'), _('REV')),
     ] + diffopts + formatteropts,
     _('[OPTION]... [-o OUTFILESPEC] [-r] [REV]...'),
     intents={INTENT_READONLY})
 def export(ui, repo, *changesets, **opts):
     """dump the header and diffs for one or more changesets
 
     Print the changeset header and diffs for one or more revisions.
     If no revision is given, the parent of the working directory is used.
 
     The information shown in the changeset header is: author, date,
     branch name (if non-default), changeset hash, parent(s) and commit
     comment.
 
     .. note::
 
        :hg:`export` may generate unexpected diff output for merge
        changesets, as it will compare the merge changeset against its
        first parent only.
 
     Output may be to a file, in which case the name of the file is
     given using a template string. See :hg:`help templates`. In addition
     to the common template keywords, the following formatting rules are
     supported:
 
     :``%%``: literal "%" character
     :``%H``: changeset hash (40 hexadecimal digits)
     :``%N``: number of patches being generated
     :``%R``: changeset revision number
     :``%b``: basename of the exporting repository
     :``%h``: short-form changeset hash (12 hexadecimal digits)
     :``%m``: first line of the commit message (only alphanumeric characters)
     :``%n``: zero-padded sequence number, starting at 1
     :``%r``: zero-padded changeset revision number
     :``\\``: literal "\\" character
 
     Without the -a/--text option, export will avoid generating diffs
     of files it detects as binary. With -a, export will generate a
     diff anyway, probably with undesirable results.
 
     With -B/--bookmark changesets reachable by the given bookmark are
     selected.
 
     Use the -g/--git option to generate diffs in the git extended diff
     format. See :hg:`help diffs` for more information.
 
     With the --switch-parent option, the diff will be against the
     second parent. It can be useful to review a merge.
 
     .. container:: verbose
 
       Examples:
 
       - use export and import to transplant a bugfix to the current
         branch::
 
           hg export -r 9353 | hg import -
 
       - export all the changesets between two revisions to a file with
         rename information::
 
           hg export --git -r 123:150 > changes.txt
 
       - split outgoing changes into a series of patches with
         descriptive names::
 
           hg export -r "outgoing()" -o "%n-%m.patch"
 
     Returns 0 on success.
     """
     opts = pycompat.byteskwargs(opts)
     bookmark = opts.get('bookmark')
     changesets += tuple(opts.get('rev', []))
 
     if bookmark and changesets:
         raise error.Abort(_("-r and -B are mutually exclusive"))
 
     if bookmark:
         if bookmark not in repo._bookmarks:
             raise error.Abort(_("bookmark '%s' not found") % bookmark)
 
         revs = scmutil.bookmarkrevs(repo, bookmark)
     else:
         if not changesets:
             changesets = ['.']
 
         repo = scmutil.unhidehashlikerevs(repo, changesets, 'nowarn')
         revs = scmutil.revrange(repo, changesets)
 
     if not revs:
         raise error.Abort(_("export requires at least one changeset"))
     if len(revs) > 1:
         ui.note(_('exporting patches:\n'))
     else:
         ui.note(_('exporting patch:\n'))
 
     fntemplate = opts.get('output')
     if cmdutil.isstdiofilename(fntemplate):
         fntemplate = ''
 
     if fntemplate:
         fm = formatter.nullformatter(ui, 'export', opts)
     else:
         ui.pager('export')
         fm = ui.formatter('export', opts)
     with fm:
         cmdutil.export(repo, revs, fm, fntemplate=fntemplate,
                        switch_parent=opts.get('switch_parent'),
                        opts=patch.diffallopts(ui, opts))
 
 @command('files',
     [('r', 'rev', '', _('search the repository as it is in REV'), _('REV')),
      ('0', 'print0', None, _('end filenames with NUL, for use with xargs')),
     ] + walkopts + formatteropts + subrepoopts,
     _('[OPTION]... [FILE]...'),
     intents={INTENT_READONLY})
 def files(ui, repo, *pats, **opts):
     """list tracked files
 
     Print files under Mercurial control in the working directory or
     specified revision for given files (excluding removed files).
     Files can be specified as filenames or filesets.
 
     If no files are given to match, this command prints the names
     of all files under Mercurial control.
 
     .. container:: verbose
 
       Examples:
 
       - list all files under the current directory::
 
           hg files .
 
       - shows sizes and flags for current revision::
 
           hg files -vr .
 
       - list all files named README::
 
           hg files -I "**/README"
 
       - list all binary files::
 
           hg files "set:binary()"
 
       - find files containing a regular expression::
 
           hg files "set:grep('bob')"
 
       - search tracked file contents with xargs and grep::
 
           hg files -0 | xargs -0 grep foo
 
     See :hg:`help patterns` and :hg:`help filesets` for more information
     on specifying file patterns.
 
     Returns 0 if a match is found, 1 otherwise.
 
     """
 
     opts = pycompat.byteskwargs(opts)
     rev = opts.get('rev')
     if rev:
         repo = scmutil.unhidehashlikerevs(repo, [rev], 'nowarn')
     ctx = scmutil.revsingle(repo, rev, None)
 
     end = '\n'
     if opts.get('print0'):
         end = '\0'
     fmt = '%s' + end
 
     m = scmutil.match(ctx, pats, opts)
     ui.pager('files')
     with ui.formatter('files', opts) as fm:
         return cmdutil.files(ui, ctx, m, fm, fmt, opts.get('subrepos'))
 
 @command(
     '^forget',
     [('i', 'interactive', None, _('use interactive mode')),
     ] + walkopts + dryrunopts,
     _('[OPTION]... FILE...'), inferrepo=True)
 def forget(ui, repo, *pats, **opts):
     """forget the specified files on the next commit
 
     Mark the specified files so they will no longer be tracked
     after the next commit.
 
     This only removes files from the current branch, not from the
     entire project history, and it does not delete them from the
     working directory.
 
     To delete the file from the working directory, see :hg:`remove`.
 
     To undo a forget before the next commit, see :hg:`add`.
 
     .. container:: verbose
 
       Examples:
 
       - forget newly-added binary files::
 
           hg forget "set:added() and binary()"
 
       - forget files that would be excluded by .hgignore::
 
           hg forget "set:hgignore()"
 
     Returns 0 on success.
     """
 
     opts = pycompat.byteskwargs(opts)
     if not pats:
         raise error.Abort(_('no files specified'))
 
     m = scmutil.match(repo[None], pats, opts)
     dryrun, interactive = opts.get('dry_run'), opts.get('interactive')
     rejected = cmdutil.forget(ui, repo, m, prefix="",
                               explicitonly=False, dryrun=dryrun,
                               interactive=interactive)[0]
     return rejected and 1 or 0
 
 @command(
     'graft',
     [('r', 'rev', [], _('revisions to graft'), _('REV')),
      ('c', 'continue', False, _('resume interrupted graft')),
      ('', 'stop', False, _('stop interrupted graft')),
      ('', 'abort', False, _('abort interrupted graft')),
      ('e', 'edit', False, _('invoke editor on commit messages')),
      ('', 'log', None, _('append graft info to log message')),
      ('', 'no-commit', None,
       _("don't commit, just apply the changes in working directory")),
      ('f', 'force', False, _('force graft')),
      ('D', 'currentdate', False,
       _('record the current date as commit date')),
      ('U', 'currentuser', False,
       _('record the current user as committer'), _('DATE'))]
     + commitopts2 + mergetoolopts  + dryrunopts,
     _('[OPTION]... [-r REV]... REV...'))
 def graft(ui, repo, *revs, **opts):
     '''copy changes from other branches onto the current branch
 
     This command uses Mercurial's merge logic to copy individual
     changes from other branches without merging branches in the
     history graph. This is sometimes known as 'backporting' or
     'cherry-picking'. By default, graft will copy user, date, and
     description from the source changesets.
 
     Changesets that are ancestors of the current revision, that have
     already been grafted, or that are merges will be skipped.
 
     If --log is specified, log messages will have a comment appended
     of the form::
 
       (grafted from CHANGESETHASH)
 
     If --force is specified, revisions will be grafted even if they
     are already ancestors of, or have been grafted to, the destination.
     This is useful when the revisions have since been backed out.
 
     If a graft merge results in conflicts, the graft process is
     interrupted so that the current merge can be manually resolved.
     Once all conflicts are addressed, the graft process can be
     continued with the -c/--continue option.
 
     The -c/--continue option reapplies all the earlier options.
 
     .. container:: verbose
 
       Examples:
 
       - copy a single change to the stable branch and edit its description::
 
           hg update stable
           hg graft --edit 9393
 
       - graft a range of changesets with one exception, updating dates::
 
           hg graft -D "2085::2093 and not 2091"
 
       - continue a graft after resolving conflicts::
 
           hg graft -c
 
       - show the source of a grafted changeset::
 
           hg log --debug -r .
 
       - show revisions sorted by date::
 
           hg log -r "sort(all(), date)"
 
     See :hg:`help revisions` for more about specifying revisions.
 
     Returns 0 on successful completion.
     '''
     with repo.wlock():
         return _dograft(ui, repo, *revs, **opts)
 
 def _dograft(ui, repo, *revs, **opts):
     opts = pycompat.byteskwargs(opts)
     if revs and opts.get('rev'):
         ui.warn(_('warning: inconsistent use of --rev might give unexpected '
                   'revision ordering!\n'))
 
     revs = list(revs)
     revs.extend(opts.get('rev'))
     # a dict of data to be stored in state file
     statedata = {}
     # list of new nodes created by ongoing graft
     statedata['newnodes'] = []
 
     if not opts.get('user') and opts.get('currentuser'):
         opts['user'] = ui.username()
     if not opts.get('date') and opts.get('currentdate'):
         opts['date'] = "%d %d" % dateutil.makedate()
 
     editor = cmdutil.getcommiteditor(editform='graft',
                                      **pycompat.strkwargs(opts))
 
     cont = False
     if opts.get('no_commit'):
         if opts.get('edit'):
             raise error.Abort(_("cannot specify --no-commit and "
                                 "--edit together"))
         if opts.get('currentuser'):
             raise error.Abort(_("cannot specify --no-commit and "
                                 "--currentuser together"))
         if opts.get('currentdate'):
             raise error.Abort(_("cannot specify --no-commit and "
                                 "--currentdate together"))
         if opts.get('log'):
             raise error.Abort(_("cannot specify --no-commit and "
                                 "--log together"))
 
     graftstate = statemod.cmdstate(repo, 'graftstate')
 
     if opts.get('stop'):
         if opts.get('continue'):
             raise error.Abort(_("cannot use '--continue' and "
                                 "'--stop' together"))
         if opts.get('abort'):
             raise error.Abort(_("cannot use '--abort' and '--stop' together"))
 
         if any((opts.get('edit'), opts.get('log'), opts.get('user'),
                 opts.get('date'), opts.get('currentdate'),
                 opts.get('currentuser'), opts.get('rev'))):
             raise error.Abort(_("cannot specify any other flag with '--stop'"))
         return _stopgraft(ui, repo, graftstate)
     elif opts.get('abort'):
         if opts.get('continue'):
             raise error.Abort(_("cannot use '--continue' and "
                                 "'--abort' together"))
         if any((opts.get('edit'), opts.get('log'), opts.get('user'),
                 opts.get('date'), opts.get('currentdate'),
                 opts.get('currentuser'), opts.get('rev'))):
             raise error.Abort(_("cannot specify any other flag with '--abort'"))
 
         return _abortgraft(ui, repo, graftstate)
     elif opts.get('continue'):
         cont = True
         if revs:
             raise error.Abort(_("can't specify --continue and revisions"))
         # read in unfinished revisions
         if graftstate.exists():
             statedata = _readgraftstate(repo, graftstate)
             if statedata.get('date'):
                 opts['date'] = statedata['date']
             if statedata.get('user'):
                 opts['user'] = statedata['user']
             if statedata.get('log'):
                 opts['log'] = True
             if statedata.get('no_commit'):
                 opts['no_commit'] = statedata.get('no_commit')
             nodes = statedata['nodes']
             revs = [repo[node].rev() for node in nodes]
         else:
             cmdutil.wrongtooltocontinue(repo, _('graft'))
     else:
         if not revs:
             raise error.Abort(_('no revisions specified'))
         cmdutil.checkunfinished(repo)
         cmdutil.bailifchanged(repo)
         revs = scmutil.revrange(repo, revs)
 
     skipped = set()
     # check for merges
     for rev in repo.revs('%ld and merge()', revs):
         ui.warn(_('skipping ungraftable merge revision %d\n') % rev)
         skipped.add(rev)
     revs = [r for r in revs if r not in skipped]
     if not revs:
         return -1
 
     # Don't check in the --continue case, in effect retaining --force across
     # --continues. That's because without --force, any revisions we decided to
     # skip would have been filtered out here, so they wouldn't have made their
     # way to the graftstate. With --force, any revisions we would have otherwise
     # skipped would not have been filtered out, and if they hadn't been applied
     # already, they'd have been in the graftstate.
     if not (cont or opts.get('force')):
         # check for ancestors of dest branch
         crev = repo['.'].rev()
         ancestors = repo.changelog.ancestors([crev], inclusive=True)
         # XXX make this lazy in the future
         # don't mutate while iterating, create a copy
         for rev in list(revs):
             if rev in ancestors:
                 ui.warn(_('skipping ancestor revision %d:%s\n') %
                         (rev, repo[rev]))
                 # XXX remove on list is slow
                 revs.remove(rev)
         if not revs:
             return -1
 
         # analyze revs for earlier grafts
         ids = {}
         for ctx in repo.set("%ld", revs):
             ids[ctx.hex()] = ctx.rev()
             n = ctx.extra().get('source')
             if n:
                 ids[n] = ctx.rev()
 
         # check ancestors for earlier grafts
         ui.debug('scanning for duplicate grafts\n')
 
         # The only changesets we can be sure doesn't contain grafts of any
         # revs, are the ones that are common ancestors of *all* revs:
         for rev in repo.revs('only(%d,ancestor(%ld))', crev, revs):
             ctx = repo[rev]
             n = ctx.extra().get('source')
             if n in ids:
                 try:
                     r = repo[n].rev()
                 except error.RepoLookupError:
                     r = None
                 if r in revs:
                     ui.warn(_('skipping revision %d:%s '
                               '(already grafted to %d:%s)\n')
                             % (r, repo[r], rev, ctx))
                     revs.remove(r)
                 elif ids[n] in revs:
                     if r is None:
                         ui.warn(_('skipping already grafted revision %d:%s '
                                   '(%d:%s also has unknown origin %s)\n')
                                 % (ids[n], repo[ids[n]], rev, ctx, n[:12]))
                     else:
                         ui.warn(_('skipping already grafted revision %d:%s '
                                   '(%d:%s also has origin %d:%s)\n')
                                 % (ids[n], repo[ids[n]], rev, ctx, r, n[:12]))
                     revs.remove(ids[n])
             elif ctx.hex() in ids:
                 r = ids[ctx.hex()]
                 ui.warn(_('skipping already grafted revision %d:%s '
                           '(was grafted from %d:%s)\n') %
                         (r, repo[r], rev, ctx))
                 revs.remove(r)
         if not revs:
             return -1
 
     if opts.get('no_commit'):
         statedata['no_commit'] = True
     for pos, ctx in enumerate(repo.set("%ld", revs)):
         desc = '%d:%s "%s"' % (ctx.rev(), ctx,
                                ctx.description().split('\n', 1)[0])
         names = repo.nodetags(ctx.node()) + repo.nodebookmarks(ctx.node())
         if names:
             desc += ' (%s)' % ' '.join(names)
         ui.status(_('grafting %s\n') % desc)
         if opts.get('dry_run'):
             continue
 
         source = ctx.extra().get('source')
         extra = {}
         if source:
             extra['source'] = source
             extra['intermediate-source'] = ctx.hex()
         else:
             extra['source'] = ctx.hex()
         user = ctx.user()
         if opts.get('user'):
             user = opts['user']
             statedata['user'] = user
         date = ctx.date()
         if opts.get('date'):
             date = opts['date']
             statedata['date'] = date
         message = ctx.description()
         if opts.get('log'):
             message += '\n(grafted from %s)' % ctx.hex()
             statedata['log'] = True
 
         # we don't merge the first commit when continuing
         if not cont:
             # perform the graft merge with p1(rev) as 'ancestor'
             overrides = {('ui', 'forcemerge'): opts.get('tool', '')}
             with ui.configoverride(overrides, 'graft'):
                 stats = mergemod.graft(repo, ctx, ctx.p1(), ['local', 'graft'])
             # report any conflicts
             if stats.unresolvedcount > 0:
                 # write out state for --continue
                 nodes = [repo[rev].hex() for rev in revs[pos:]]
                 statedata['nodes'] = nodes
                 stateversion = 1
                 graftstate.save(stateversion, statedata)
                 hint = _("use 'hg resolve' and 'hg graft --continue'")
                 raise error.Abort(
                     _("unresolved conflicts, can't continue"),
                     hint=hint)
         else:
             cont = False
 
         # commit if --no-commit is false
         if not opts.get('no_commit'):
             node = repo.commit(text=message, user=user, date=date, extra=extra,
                                editor=editor)
             if node is None:
                 ui.warn(
                     _('note: graft of %d:%s created no changes to commit\n') %
                     (ctx.rev(), ctx))
             # checking that newnodes exist because old state files won't have it
             elif statedata.get('newnodes') is not None:
                 statedata['newnodes'].append(node)
 
     # remove state when we complete successfully
     if not opts.get('dry_run'):
         graftstate.delete()
 
     return 0
 
 def _abortgraft(ui, repo, graftstate):
     """abort the interrupted graft and rollbacks to the state before interrupted
     graft"""
     if not graftstate.exists():
         raise error.Abort(_("no interrupted graft to abort"))
     statedata = _readgraftstate(repo, graftstate)
     newnodes = statedata.get('newnodes')
     if newnodes is None:
         # and old graft state which does not have all the data required to abort
         # the graft
         raise error.Abort(_("cannot abort using an old graftstate"))
 
     # changeset from which graft operation was started
     startctx = None
     if len(newnodes) > 0:
         startctx = repo[newnodes[0]].p1()
     else:
         startctx = repo['.']
     # whether to strip or not
     cleanup = False
     if newnodes:
         newnodes = [repo[r].rev() for r in newnodes]
         cleanup = True
         # checking that none of the newnodes turned public or is public
         immutable = [c for c in newnodes if not repo[c].mutable()]
         if immutable:
             repo.ui.warn(_("cannot clean up public changesets %s\n")
                          % ', '.join(bytes(repo[r]) for r in immutable),
                          hint=_("see 'hg help phases' for details"))
             cleanup = False
 
         # checking that no new nodes are created on top of grafted revs
         desc = set(repo.changelog.descendants(newnodes))
         if desc - set(newnodes):
             repo.ui.warn(_("new changesets detected on destination "
                            "branch, can't strip\n"))
             cleanup = False
 
         if cleanup:
             with repo.wlock(), repo.lock():
                 hg.updaterepo(repo, startctx.node(), overwrite=True)
                 # stripping the new nodes created
                 strippoints = [c.node() for c in repo.set("roots(%ld)",
                                                           newnodes)]
                 repair.strip(repo.ui, repo, strippoints, backup=False)
 
     if not cleanup:
         # we don't update to the startnode if we can't strip
         startctx = repo['.']
         hg.updaterepo(repo, startctx.node(), overwrite=True)
 
     ui.status(_("graft aborted\n"))
     ui.status(_("working directory is now at %s\n") % startctx.hex()[:12])
     graftstate.delete()
     return 0
 
 def _readgraftstate(repo, graftstate):
     """read the graft state file and return a dict of the data stored in it"""
     try:
         return graftstate.read()
     except error.CorruptedState:
         nodes = repo.vfs.read('graftstate').splitlines()
         return {'nodes': nodes}
 
 def _stopgraft(ui, repo, graftstate):
     """stop the interrupted graft"""
     if not graftstate.exists():
         raise error.Abort(_("no interrupted graft found"))
     pctx = repo['.']
     hg.updaterepo(repo, pctx.node(), overwrite=True)
     graftstate.delete()
     ui.status(_("stopped the interrupted graft\n"))
     ui.status(_("working directory is now at %s\n") % pctx.hex()[:12])
     return 0
 
 @command('grep',
     [('0', 'print0', None, _('end fields with NUL')),
     ('', 'all', None, _('print all revisions that match (DEPRECATED) ')),
     ('', 'diff', None, _('print all revisions when the term was introduced '
                          'or removed')),
     ('a', 'text', None, _('treat all files as text')),
     ('f', 'follow', None,
      _('follow changeset history,'
        ' or file history across copies and renames')),
     ('i', 'ignore-case', None, _('ignore case when matching')),
     ('l', 'files-with-matches', None,
      _('print only filenames and revisions that match')),
     ('n', 'line-number', None, _('print matching line numbers')),
     ('r', 'rev', [],
      _('only search files changed within revision range'), _('REV')),
     ('', 'all-files', None,
      _('include all files in the changeset while grepping (EXPERIMENTAL)')),
     ('u', 'user', None, _('list the author (long with -v)')),
     ('d', 'date', None, _('list the date (short with -q)')),
     ] + formatteropts + walkopts,
     _('[OPTION]... PATTERN [FILE]...'),
     inferrepo=True,
     intents={INTENT_READONLY})
 def grep(ui, repo, pattern, *pats, **opts):
     """search revision history for a pattern in specified files
 
     Search revision history for a regular expression in the specified
     files or the entire project.
 
     By default, grep prints the most recent revision number for each
     file in which it finds a match. To get it to print every revision
     that contains a change in match status ("-" for a match that becomes
     a non-match, or "+" for a non-match that becomes a match), use the
     --diff flag.
 
     PATTERN can be any Python (roughly Perl-compatible) regular
     expression.
 
     If no FILEs are specified (and -f/--follow isn't set), all files in
     the repository are searched, including those that don't exist in the
     current branch or have been deleted in a prior changeset.
 
     Returns 0 if a match is found, 1 otherwise.
     """
     opts = pycompat.byteskwargs(opts)
     diff = opts.get('all') or opts.get('diff')
     if diff and opts.get('all_files'):
         raise error.Abort(_('--diff and --all-files are mutually exclusive'))
     # TODO: remove "not opts.get('rev')" if --all-files -rMULTIREV gets working
     if opts.get('all_files') is None and not opts.get('rev') and not diff:
         # experimental config: commands.grep.all-files
         opts['all_files'] = ui.configbool('commands', 'grep.all-files')
     plaingrep = opts.get('all_files') and not opts.get('rev')
     if plaingrep:
         opts['rev'] = ['wdir()']
 
     reflags = re.M
     if opts.get('ignore_case'):
         reflags |= re.I
     try:
         regexp = util.re.compile(pattern, reflags)
     except re.error as inst:
         ui.warn(_("grep: invalid match pattern: %s\n") % pycompat.bytestr(inst))
         return 1
     sep, eol = ':', '\n'
     if opts.get('print0'):
         sep = eol = '\0'
 
     getfile = util.lrucachefunc(repo.file)
 
     def matchlines(body):
         begin = 0
         linenum = 0
         while begin < len(body):
             match = regexp.search(body, begin)
             if not match:
                 break
             mstart, mend = match.span()
             linenum += body.count('\n', begin, mstart) + 1
             lstart = body.rfind('\n', begin, mstart) + 1 or begin
             begin = body.find('\n', mend) + 1 or len(body) + 1
             lend = begin - 1
             yield linenum, mstart - lstart, mend - lstart, body[lstart:lend]
 
     class linestate(object):
         def __init__(self, line, linenum, colstart, colend):
             self.line = line
             self.linenum = linenum
             self.colstart = colstart
             self.colend = colend
 
         def __hash__(self):
             return hash((self.linenum, self.line))
 
         def __eq__(self, other):
             return self.line == other.line
 
         def findpos(self):
             """Iterate all (start, end) indices of matches"""
             yield self.colstart, self.colend
             p = self.colend
             while p < len(self.line):
                 m = regexp.search(self.line, p)
                 if not m:
                     break
                 yield m.span()
                 p = m.end()
 
     matches = {}
     copies = {}
     def grepbody(fn, rev, body):
         matches[rev].setdefault(fn, [])
         m = matches[rev][fn]
         for lnum, cstart, cend, line in matchlines(body):
             s = linestate(line, lnum, cstart, cend)
             m.append(s)
 
     def difflinestates(a, b):
         sm = difflib.SequenceMatcher(None, a, b)
         for tag, alo, ahi, blo, bhi in sm.get_opcodes():
             if tag == 'insert':
                 for i in pycompat.xrange(blo, bhi):
                     yield ('+', b[i])
             elif tag == 'delete':
                 for i in pycompat.xrange(alo, ahi):
                     yield ('-', a[i])
             elif tag == 'replace':
                 for i in pycompat.xrange(alo, ahi):
                     yield ('-', a[i])
                 for i in pycompat.xrange(blo, bhi):
                     yield ('+', b[i])
 
     def display(fm, fn, ctx, pstates, states):
         rev = scmutil.intrev(ctx)
         if fm.isplain():
             formatuser = ui.shortuser
         else:
             formatuser = str
         if ui.quiet:
             datefmt = '%Y-%m-%d'
         else:
             datefmt = '%a %b %d %H:%M:%S %Y %1%2'
         found = False
         @util.cachefunc
         def binary():
             flog = getfile(fn)
             try:
                 return stringutil.binary(flog.read(ctx.filenode(fn)))
             except error.WdirUnsupported:
                 return ctx[fn].isbinary()
 
         fieldnamemap = {'filename': 'file', 'linenumber': 'line_number'}
         if diff:
             iter = difflinestates(pstates, states)
         else:
             iter = [('', l) for l in states]
         for change, l in iter:
             fm.startitem()
             fm.context(ctx=ctx)
             fm.data(node=fm.hexfunc(scmutil.binnode(ctx)))
 
             cols = [
                 ('filename', fn, True),
                 ('rev', rev, not plaingrep),
                 ('linenumber', l.linenum, opts.get('line_number')),
             ]
             if diff:
                 cols.append(('change', change, True))
             cols.extend([
                 ('user', formatuser(ctx.user()), opts.get('user')),
                 ('date', fm.formatdate(ctx.date(), datefmt), opts.get('date')),
             ])
             lastcol = next(name for name, data, cond in reversed(cols) if cond)
             for name, data, cond in cols:
                 field = fieldnamemap.get(name, name)
                 fm.condwrite(cond, field, '%s', data, label='grep.%s' % name)
                 if cond and name != lastcol:
                     fm.plain(sep, label='grep.sep')
             if not opts.get('files_with_matches'):
                 fm.plain(sep, label='grep.sep')
                 if not opts.get('text') and binary():
                     fm.plain(_(" Binary file matches"))
                 else:
                     displaymatches(fm.nested('texts', tmpl='{text}'), l)
             fm.plain(eol)
             found = True
             if opts.get('files_with_matches'):
                 break
         return found
 
     def displaymatches(fm, l):
         p = 0
         for s, e in l.findpos():
             if p < s:
                 fm.startitem()
                 fm.write('text', '%s', l.line[p:s])
                 fm.data(matched=False)
             fm.startitem()
             fm.write('text', '%s', l.line[s:e], label='grep.match')
             fm.data(matched=True)
             p = e
         if p < len(l.line):
             fm.startitem()
             fm.write('text', '%s', l.line[p:])
             fm.data(matched=False)
         fm.end()
 
     skip = {}
     revfiles = {}
     match = scmutil.match(repo[None], pats, opts)
     found = False
     follow = opts.get('follow')
 
     def prep(ctx, fns):
         rev = ctx.rev()
         pctx = ctx.p1()
         parent = pctx.rev()
         matches.setdefault(rev, {})
         matches.setdefault(parent, {})
         files = revfiles.setdefault(rev, [])
         for fn in fns:
             flog = getfile(fn)
             try:
                 fnode = ctx.filenode(fn)
             except error.LookupError:
                 continue
             try:
                 copied = flog.renamed(fnode)
             except error.WdirUnsupported:
                 copied = ctx[fn].renamed()
             copy = follow and copied and copied[0]
             if copy:
                 copies.setdefault(rev, {})[fn] = copy
             if fn in skip:
                 if copy:
                     skip[copy] = True
                 continue
             files.append(fn)
 
             if fn not in matches[rev]:
                 try:
                     content = flog.read(fnode)
                 except error.WdirUnsupported:
                     content = ctx[fn].data()
                 grepbody(fn, rev, content)
 
             pfn = copy or fn
             if pfn not in matches[parent]:
                 try:
                     fnode = pctx.filenode(pfn)
                     grepbody(pfn, parent, flog.read(fnode))
                 except error.LookupError:
                     pass
 
     ui.pager('grep')
     fm = ui.formatter('grep', opts)
     for ctx in cmdutil.walkchangerevs(repo, match, opts, prep):
         rev = ctx.rev()
         parent = ctx.p1().rev()
         for fn in sorted(revfiles.get(rev, [])):
             states = matches[rev][fn]
             copy = copies.get(rev, {}).get(fn)
             if fn in skip:
                 if copy:
                     skip[copy] = True
                 continue
             pstates = matches.get(parent, {}).get(copy or fn, [])
             if pstates or states:
                 r = display(fm, fn, ctx, pstates, states)
                 found = found or r
                 if r and not diff:
                     skip[fn] = True
                     if copy:
                         skip[copy] = True
         del revfiles[rev]
         # We will keep the matches dict for the duration of the window
         # clear the matches dict once the window is over
         if not revfiles:
             matches.clear()
     fm.end()
 
     return not found
 
 @command('heads',
     [('r', 'rev', '',
      _('show only heads which are descendants of STARTREV'), _('STARTREV')),
     ('t', 'topo', False, _('show topological heads only')),
     ('a', 'active', False, _('show active branchheads only (DEPRECATED)')),
     ('c', 'closed', False, _('show normal and closed branch heads')),
     ] + templateopts,
     _('[-ct] [-r STARTREV] [REV]...'),
     intents={INTENT_READONLY})
 def heads(ui, repo, *branchrevs, **opts):
     """show branch heads
 
     With no arguments, show all open branch heads in the repository.
     Branch heads are changesets that have no descendants on the
     same branch. They are where development generally takes place and
     are the usual targets for update and merge operations.
 
     If one or more REVs are given, only open branch heads on the
     branches associated with the specified changesets are shown. This
     means that you can use :hg:`heads .` to see the heads on the
     currently checked-out branch.
 
     If -c/--closed is specified, also show branch heads marked closed
     (see :hg:`commit --close-branch`).
 
     If STARTREV is specified, only those heads that are descendants of
     STARTREV will be displayed.
 
     If -t/--topo is specified, named branch mechanics will be ignored and only
     topological heads (changesets with no children) will be shown.
 
     Returns 0 if matching heads are found, 1 if not.
     """
 
     opts = pycompat.byteskwargs(opts)
     start = None
     rev = opts.get('rev')
     if rev:
         repo = scmutil.unhidehashlikerevs(repo, [rev], 'nowarn')
         start = scmutil.revsingle(repo, rev, None).node()
 
     if opts.get('topo'):
         heads = [repo[h] for h in repo.heads(start)]
     else:
         heads = []
         for branch in repo.branchmap():
             heads += repo.branchheads(branch, start, opts.get('closed'))
         heads = [repo[h] for h in heads]
 
     if branchrevs:
         branches = set(repo[r].branch()
                        for r in scmutil.revrange(repo, branchrevs))
         heads = [h for h in heads if h.branch() in branches]
 
     if opts.get('active') and branchrevs:
         dagheads = repo.heads(start)
         heads = [h for h in heads if h.node() in dagheads]
 
     if branchrevs:
         haveheads = set(h.branch() for h in heads)
         if branches - haveheads:
             headless = ', '.join(b for b in branches - haveheads)
             msg = _('no open branch heads found on branches %s')
             if opts.get('rev'):
                 msg += _(' (started at %s)') % opts['rev']
             ui.warn((msg + '\n') % headless)
 
     if not heads:
         return 1
 
     ui.pager('heads')
     heads = sorted(heads, key=lambda x: -x.rev())
     displayer = logcmdutil.changesetdisplayer(ui, repo, opts)
     for ctx in heads:
         displayer.show(ctx)
     displayer.close()
 
 @command('help',
     [('e', 'extension', None, _('show only help for extensions')),
      ('c', 'command', None, _('show only help for commands')),
      ('k', 'keyword', None, _('show topics matching keyword')),
      ('s', 'system', [], _('show help for specific platform(s)')),
      ],
     _('[-ecks] [TOPIC]'),
     norepo=True,
     intents={INTENT_READONLY})
 def help_(ui, name=None, **opts):
     """show help for a given topic or a help overview
 
     With no arguments, print a list of commands with short help messages.
 
     Given a topic, extension, or command name, print help for that
     topic.
 
     Returns 0 if successful.
     """
 
     keep = opts.get(r'system') or []
     if len(keep) == 0:
         if pycompat.sysplatform.startswith('win'):
             keep.append('windows')
         elif pycompat.sysplatform == 'OpenVMS':
             keep.append('vms')
         elif pycompat.sysplatform == 'plan9':
             keep.append('plan9')
         else:
             keep.append('unix')
             keep.append(pycompat.sysplatform.lower())
     if ui.verbose:
         keep.append('verbose')
 
     commands = sys.modules[__name__]
     formatted = help.formattedhelp(ui, commands, name, keep=keep, **opts)
     ui.pager('help')
     ui.write(formatted)
 
 
 @command('identify|id',
     [('r', 'rev', '',
      _('identify the specified revision'), _('REV')),
     ('n', 'num', None, _('show local revision number')),
     ('i', 'id', None, _('show global revision id')),
     ('b', 'branch', None, _('show branch')),
     ('t', 'tags', None, _('show tags')),
     ('B', 'bookmarks', None, _('show bookmarks')),
     ] + remoteopts + formatteropts,
     _('[-nibtB] [-r REV] [SOURCE]'),
     optionalrepo=True,
     intents={INTENT_READONLY})
 def identify(ui, repo, source=None, rev=None,
              num=None, id=None, branch=None, tags=None, bookmarks=None, **opts):
     """identify the working directory or specified revision
 
     Print a summary identifying the repository state at REV using one or
     two parent hash identifiers, followed by a "+" if the working
     directory has uncommitted changes, the branch name (if not default),
     a list of tags, and a list of bookmarks.
 
     When REV is not given, print a summary of the current state of the
     repository including the working directory. Specify -r. to get information
     of the working directory parent without scanning uncommitted changes.
 
     Specifying a path to a repository root or Mercurial bundle will
     cause lookup to operate on that repository/bundle.
 
     .. container:: verbose
 
       Examples:
 
       - generate a build identifier for the working directory::
 
           hg id --id > build-id.dat
 
       - find the revision corresponding to a tag::
 
           hg id -n -r 1.3
 
       - check the most recent revision of a remote repository::
 
           hg id -r tip https://www.mercurial-scm.org/repo/hg/
 
     See :hg:`log` for generating more information about specific revisions,
     including full hash identifiers.
 
     Returns 0 if successful.
     """
 
     opts = pycompat.byteskwargs(opts)
     if not repo and not source:
         raise error.Abort(_("there is no Mercurial repository here "
                            "(.hg not found)"))
 
     if ui.debugflag:
         hexfunc = hex
     else:
         hexfunc = short
     default = not (num or id or branch or tags or bookmarks)
     output = []
     revs = []
 
     if source:
         source, branches = hg.parseurl(ui.expandpath(source))
         peer = hg.peer(repo or ui, opts, source) # only pass ui when no repo
         repo = peer.local()
         revs, checkout = hg.addbranchrevs(repo, peer, branches, None)
 
     fm = ui.formatter('identify', opts)
     fm.startitem()
 
     if not repo:
         if num or branch or tags:
             raise error.Abort(
                 _("can't query remote revision number, branch, or tags"))
         if not rev and revs:
             rev = revs[0]
         if not rev:
             rev = "tip"
 
         remoterev = peer.lookup(rev)
         hexrev = hexfunc(remoterev)
         if default or id:
             output = [hexrev]
         fm.data(id=hexrev)
 
         def getbms():
             bms = []
 
             if 'bookmarks' in peer.listkeys('namespaces'):
                 hexremoterev = hex(remoterev)
                 bms = [bm for bm, bmr in peer.listkeys('bookmarks').iteritems()
                        if bmr == hexremoterev]
 
             return sorted(bms)
 
         bms = getbms()
         if bookmarks:
             output.extend(bms)
         elif default and not ui.quiet:
             # multiple bookmarks for a single parent separated by '/'
             bm = '/'.join(bms)
             if bm:
                 output.append(bm)
 
         fm.data(node=hex(remoterev))
         fm.data(bookmarks=fm.formatlist(bms, name='bookmark'))
     else:
         if rev:
             repo = scmutil.unhidehashlikerevs(repo, [rev], 'nowarn')
         ctx = scmutil.revsingle(repo, rev, None)
 
         if ctx.rev() is None:
             ctx = repo[None]
             parents = ctx.parents()
             taglist = []
             for p in parents:
                 taglist.extend(p.tags())
 
             dirty = ""
             if ctx.dirty(missing=True, merge=False, branch=False):
                 dirty = '+'
             fm.data(dirty=dirty)
 
             hexoutput = [hexfunc(p.node()) for p in parents]
             if default or id:
                 output = ["%s%s" % ('+'.join(hexoutput), dirty)]
             fm.data(id="%s%s" % ('+'.join(hexoutput), dirty))
 
             if num:
                 numoutput = ["%d" % p.rev() for p in parents]
                 output.append("%s%s" % ('+'.join(numoutput), dirty))
 
             fn = fm.nested('parents', tmpl='{rev}:{node|formatnode}', sep=' ')
             for p in parents:
                 fn.startitem()
                 fn.data(rev=p.rev())
                 fn.data(node=p.hex())
                 fn.context(ctx=p)
             fn.end()
         else:
             hexoutput = hexfunc(ctx.node())
             if default or id:
                 output = [hexoutput]
             fm.data(id=hexoutput)
 
             if num:
                 output.append(pycompat.bytestr(ctx.rev()))
             taglist = ctx.tags()
 
         if default and not ui.quiet:
             b = ctx.branch()
             if b != 'default':
                 output.append("(%s)" % b)
 
             # multiple tags for a single parent separated by '/'
             t = '/'.join(taglist)
             if t:
                 output.append(t)
 
             # multiple bookmarks for a single parent separated by '/'
             bm = '/'.join(ctx.bookmarks())
             if bm:
                 output.append(bm)
         else:
             if branch:
                 output.append(ctx.branch())
 
             if tags:
                 output.extend(taglist)
 
             if bookmarks:
                 output.extend(ctx.bookmarks())
 
         fm.data(node=ctx.hex())
         fm.data(branch=ctx.branch())
         fm.data(tags=fm.formatlist(taglist, name='tag', sep=':'))
         fm.data(bookmarks=fm.formatlist(ctx.bookmarks(), name='bookmark'))
         fm.context(ctx=ctx)
 
     fm.plain("%s\n" % ' '.join(output))
     fm.end()
 
 @command('import|patch',
     [('p', 'strip', 1,
      _('directory strip option for patch. This has the same '
        'meaning as the corresponding patch option'), _('NUM')),
     ('b', 'base', '', _('base path (DEPRECATED)'), _('PATH')),
     ('e', 'edit', False, _('invoke editor on commit messages')),
     ('f', 'force', None,
      _('skip check for outstanding uncommitted changes (DEPRECATED)')),
     ('', 'no-commit', None,
      _("don't commit, just update the working directory")),
     ('', 'bypass', None,
      _("apply patch without touching the working directory")),
     ('', 'partial', None,
      _('commit even if some hunks fail')),
     ('', 'exact', None,
      _('abort if patch would apply lossily')),
     ('', 'prefix', '',
      _('apply patch to subdirectory'), _('DIR')),
     ('', 'import-branch', None,
      _('use any branch information in patch (implied by --exact)'))] +
     commitopts + commitopts2 + similarityopts,
     _('[OPTION]... PATCH...'))
 def import_(ui, repo, patch1=None, *patches, **opts):
     """import an ordered set of patches
 
     Import a list of patches and commit them individually (unless
     --no-commit is specified).
 
     To read a patch from standard input (stdin), use "-" as the patch
     name. If a URL is specified, the patch will be downloaded from
     there.
 
     Import first applies changes to the working directory (unless
     --bypass is specified), import will abort if there are outstanding
     changes.
 
     Use --bypass to apply and commit patches directly to the
     repository, without affecting the working directory. Without
     --exact, patches will be applied on top of the working directory
     parent revision.
 
     You can import a patch straight from a mail message. Even patches
     as attachments work (to use the body part, it must have type
     text/plain or text/x-patch). From and Subject headers of email
     message are used as default committer and commit message. All
     text/plain body parts before first diff are added to the commit
     message.
 
     If the imported patch was generated by :hg:`export`, user and
     description from patch override values from message headers and
     body. Values given on command line with -m/--message and -u/--user
     override these.
 
     If --exact is specified, import will set the working directory to
     the parent of each patch before applying it, and will abort if the
     resulting changeset has a different ID than the one recorded in
     the patch. This will guard against various ways that portable
     patch formats and mail systems might fail to transfer Mercurial
     data or metadata. See :hg:`bundle` for lossless transmission.
 
     Use --partial to ensure a changeset will be created from the patch
     even if some hunks fail to apply. Hunks that fail to apply will be
     written to a <target-file>.rej file. Conflicts can then be resolved
     by hand before :hg:`commit --amend` is run to update the created
     changeset. This flag exists to let people import patches that
     partially apply without losing the associated metadata (author,
     date, description, ...).
 
     .. note::
 
        When no hunks apply cleanly, :hg:`import --partial` will create
        an empty changeset, importing only the patch metadata.
 
     With -s/--similarity, hg will attempt to discover renames and
     copies in the patch in the same way as :hg:`addremove`.
 
     It is possible to use external patch programs to perform the patch
     by setting the ``ui.patch`` configuration option. For the default
     internal tool, the fuzz can also be configured via ``patch.fuzz``.
     See :hg:`help config` for more information about configuration
     files and how to use these options.
 
     See :hg:`help dates` for a list of formats valid for -d/--date.
 
     .. container:: verbose
 
       Examples:
 
       - import a traditional patch from a website and detect renames::
 
           hg import -s 80 http://example.com/bugfix.patch
 
       - import a changeset from an hgweb server::
 
           hg import https://www.mercurial-scm.org/repo/hg/rev/5ca8c111e9aa
 
       - import all the patches in an Unix-style mbox::
 
           hg import incoming-patches.mbox
 
       - import patches from stdin::
 
           hg import -
 
       - attempt to exactly restore an exported changeset (not always
         possible)::
 
           hg import --exact proposed-fix.patch
 
       - use an external tool to apply a patch which is too fuzzy for
         the default internal tool.
 
           hg import --config ui.patch="patch --merge" fuzzy.patch
 
       - change the default fuzzing from 2 to a less strict 7
 
           hg import --config ui.fuzz=7 fuzz.patch
 
     Returns 0 on success, 1 on partial success (see --partial).
     """
 
     opts = pycompat.byteskwargs(opts)
     if not patch1:
         raise error.Abort(_('need at least one patch to import'))
 
     patches = (patch1,) + patches
 
     date = opts.get('date')
     if date:
         opts['date'] = dateutil.parsedate(date)
 
     exact = opts.get('exact')
     update = not opts.get('bypass')
     if not update and opts.get('no_commit'):
         raise error.Abort(_('cannot use --no-commit with --bypass'))
     try:
         sim = float(opts.get('similarity') or 0)
     except ValueError:
         raise error.Abort(_('similarity must be a number'))
     if sim < 0 or sim > 100:
         raise error.Abort(_('similarity must be between 0 and 100'))
     if sim and not update:
         raise error.Abort(_('cannot use --similarity with --bypass'))
     if exact:
         if opts.get('edit'):
             raise error.Abort(_('cannot use --exact with --edit'))
         if opts.get('prefix'):
             raise error.Abort(_('cannot use --exact with --prefix'))
 
     base = opts["base"]
     msgs = []
     ret = 0
 
     with repo.wlock():
         if update:
             cmdutil.checkunfinished(repo)
             if (exact or not opts.get('force')):
                 cmdutil.bailifchanged(repo)
 
         if not opts.get('no_commit'):
             lock = repo.lock
             tr = lambda: repo.transaction('import')
             dsguard = util.nullcontextmanager
         else:
             lock = util.nullcontextmanager
             tr = util.nullcontextmanager
             dsguard = lambda: dirstateguard.dirstateguard(repo, 'import')
         with lock(), tr(), dsguard():
             parents = repo[None].parents()
             for patchurl in patches:
                 if patchurl == '-':
                     ui.status(_('applying patch from stdin\n'))
                     patchfile = ui.fin
                     patchurl = 'stdin'      # for error message
                 else:
                     patchurl = os.path.join(base, patchurl)
                     ui.status(_('applying %s\n') % patchurl)
                     patchfile = hg.openpath(ui, patchurl)
 
                 haspatch = False
                 for hunk in patch.split(patchfile):
                     with patch.extract(ui, hunk) as patchdata:
                         msg, node, rej = cmdutil.tryimportone(ui, repo,
                                                               patchdata,
                                                               parents, opts,
                                                               msgs, hg.clean)
                     if msg:
                         haspatch = True
                         ui.note(msg + '\n')
                     if update or exact:
                         parents = repo[None].parents()
                     else:
                         parents = [repo[node]]
                     if rej:
                         ui.write_err(_("patch applied partially\n"))
                         ui.write_err(_("(fix the .rej files and run "
                                        "`hg commit --amend`)\n"))
                         ret = 1
                         break
 
                 if not haspatch:
                     raise error.Abort(_('%s: no diffs found') % patchurl)
 
             if msgs:
                 repo.savecommitmessage('\n* * *\n'.join(msgs))
         return ret
 
 @command('incoming|in',
     [('f', 'force', None,
      _('run even if remote repository is unrelated')),
     ('n', 'newest-first', None, _('show newest record first')),
     ('', 'bundle', '',
      _('file to store the bundles into'), _('FILE')),
     ('r', 'rev', [], _('a remote changeset intended to be added'), _('REV')),
     ('B', 'bookmarks', False, _("compare bookmarks")),
     ('b', 'branch', [],
      _('a specific branch you would like to pull'), _('BRANCH')),
     ] + logopts + remoteopts + subrepoopts,
     _('[-p] [-n] [-M] [-f] [-r REV]... [--bundle FILENAME] [SOURCE]'))
 def incoming(ui, repo, source="default", **opts):
     """show new changesets found in source
 
     Show new changesets found in the specified path/URL or the default
     pull location. These are the changesets that would have been pulled
     by :hg:`pull` at the time you issued this command.
 
     See pull for valid source format details.
 
     .. container:: verbose
 
       With -B/--bookmarks, the result of bookmark comparison between
       local and remote repositories is displayed. With -v/--verbose,
       status is also displayed for each bookmark like below::
 
         BM1               01234567890a added
         BM2               1234567890ab advanced
         BM3               234567890abc diverged
         BM4               34567890abcd changed
 
       The action taken locally when pulling depends on the
       status of each bookmark:
 
       :``added``: pull will create it
       :``advanced``: pull will update it
       :``diverged``: pull will create a divergent bookmark
       :``changed``: result depends on remote changesets
 
       From the point of view of pulling behavior, bookmark
       existing only in the remote repository are treated as ``added``,
       even if it is in fact locally deleted.
 
     .. container:: verbose
 
       For remote repository, using --bundle avoids downloading the
       changesets twice if the incoming is followed by a pull.
 
       Examples:
 
       - show incoming changes with patches and full description::
 
           hg incoming -vp
 
       - show incoming changes excluding merges, store a bundle::
 
           hg in -vpM --bundle incoming.hg
           hg pull incoming.hg
 
       - briefly list changes inside a bundle::
 
           hg in changes.hg -T "{desc|firstline}\\n"
 
     Returns 0 if there are incoming changes, 1 otherwise.
     """
     opts = pycompat.byteskwargs(opts)
     if opts.get('graph'):
         logcmdutil.checkunsupportedgraphflags([], opts)
         def display(other, chlist, displayer):
             revdag = logcmdutil.graphrevs(other, chlist, opts)
             logcmdutil.displaygraph(ui, repo, revdag, displayer,
                                     graphmod.asciiedges)
 
         hg._incoming(display, lambda: 1, ui, repo, source, opts, buffered=True)
         return 0
 
     if opts.get('bundle') and opts.get('subrepos'):
         raise error.Abort(_('cannot combine --bundle and --subrepos'))
 
     if opts.get('bookmarks'):
         source, branches = hg.parseurl(ui.expandpath(source),
                                        opts.get('branch'))
         other = hg.peer(repo, opts, source)
         if 'bookmarks' not in other.listkeys('namespaces'):
             ui.warn(_("remote doesn't support bookmarks\n"))
             return 0
         ui.pager('incoming')
         ui.status(_('comparing with %s\n') % util.hidepassword(source))
         return bookmarks.incoming(ui, repo, other)
 
     repo._subtoppath = ui.expandpath(source)
     try:
         return hg.incoming(ui, repo, source, opts)
     finally:
         del repo._subtoppath
 
 
 @command('^init', remoteopts, _('[-e CMD] [--remotecmd CMD] [DEST]'),
          norepo=True)
 def init(ui, dest=".", **opts):
     """create a new repository in the given directory
 
     Initialize a new repository in the given directory. If the given
     directory does not exist, it will be created.
 
     If no directory is given, the current directory is used.
 
     It is possible to specify an ``ssh://`` URL as the destination.
     See :hg:`help urls` for more information.
 
     Returns 0 on success.
     """
     opts = pycompat.byteskwargs(opts)
     hg.peer(ui, opts, ui.expandpath(dest), create=True)
 
 @command('locate',
     [('r', 'rev', '', _('search the repository as it is in REV'), _('REV')),
     ('0', 'print0', None, _('end filenames with NUL, for use with xargs')),
     ('f', 'fullpath', None, _('print complete paths from the filesystem root')),
     ] + walkopts,
     _('[OPTION]... [PATTERN]...'))
 def locate(ui, repo, *pats, **opts):
     """locate files matching specific patterns (DEPRECATED)
 
     Print files under Mercurial control in the working directory whose
     names match the given patterns.
 
     By default, this command searches all directories in the working
     directory. To search just the current directory and its
     subdirectories, use "--include .".
 
     If no patterns are given to match, this command prints the names
     of all files under Mercurial control in the working directory.
 
     If you want to feed the output of this command into the "xargs"
     command, use the -0 option to both this command and "xargs". This
     will avoid the problem of "xargs" treating single filenames that
     contain whitespace as multiple filenames.
 
     See :hg:`help files` for a more versatile command.
 
     Returns 0 if a match is found, 1 otherwise.
     """
     opts = pycompat.byteskwargs(opts)
     if opts.get('print0'):
         end = '\0'
     else:
         end = '\n'
     ctx = scmutil.revsingle(repo, opts.get('rev'), None)
 
     ret = 1
     m = scmutil.match(ctx, pats, opts, default='relglob',
                       badfn=lambda x, y: False)
 
     ui.pager('locate')
     if ctx.rev() is None:
         # When run on the working copy, "locate" includes removed files, so
         # we get the list of files from the dirstate.
         filesgen = sorted(repo.dirstate.matches(m))
     else:
         filesgen = ctx.matches(m)
     for abs in filesgen:
         if opts.get('fullpath'):
             ui.write(repo.wjoin(abs), end)
         else:
             ui.write(((pats and m.rel(abs)) or abs), end)
         ret = 0
 
     return ret
 
 @command('^log|history',
     [('f', 'follow', None,
      _('follow changeset history, or file history across copies and renames')),
     ('', 'follow-first', None,
      _('only follow the first parent of merge changesets (DEPRECATED)')),
     ('d', 'date', '', _('show revisions matching date spec'), _('DATE')),
     ('C', 'copies', None, _('show copied files')),
     ('k', 'keyword', [],
      _('do case-insensitive search for a given text'), _('TEXT')),
     ('r', 'rev', [], _('show the specified revision or revset'), _('REV')),
     ('L', 'line-range', [],
      _('follow line range of specified file (EXPERIMENTAL)'),
      _('FILE,RANGE')),
     ('', 'removed', None, _('include revisions where files were removed')),
     ('m', 'only-merges', None, _('show only merges (DEPRECATED)')),
     ('u', 'user', [], _('revisions committed by user'), _('USER')),
     ('', 'only-branch', [],
      _('show only changesets within the given named branch (DEPRECATED)'),
      _('BRANCH')),
     ('b', 'branch', [],
      _('show changesets within the given named branch'), _('BRANCH')),
     ('P', 'prune', [],
      _('do not display revision or any of its ancestors'), _('REV')),
     ] + logopts + walkopts,
     _('[OPTION]... [FILE]'),
     inferrepo=True,
     intents={INTENT_READONLY})
 def log(ui, repo, *pats, **opts):
     """show revision history of entire repository or files
 
     Print the revision history of the specified files or the entire
     project.
 
     If no revision range is specified, the default is ``tip:0`` unless
     --follow is set, in which case the working directory parent is
     used as the starting revision.
 
     File history is shown without following rename or copy history of
     files. Use -f/--follow with a filename to follow history across
     renames and copies. --follow without a filename will only show
     ancestors of the starting revision.
 
     By default this command prints revision number and changeset id,
     tags, non-trivial parents, user, date and time, and a summary for
     each commit. When the -v/--verbose switch is used, the list of
     changed files and full commit message are shown.
 
     With --graph the revisions are shown as an ASCII art DAG with the most
     recent changeset at the top.
     'o' is a changeset, '@' is a working directory parent, '_' closes a branch,
     'x' is obsolete, '*' is unstable, and '+' represents a fork where the
     changeset from the lines below is a parent of the 'o' merge on the same
     line.
     Paths in the DAG are represented with '|', '/' and so forth. ':' in place
     of a '|' indicates one or more revisions in a path are omitted.
 
     .. container:: verbose
 
        Use -L/--line-range FILE,M:N options to follow the history of lines
        from M to N in FILE. With -p/--patch only diff hunks affecting
        specified line range will be shown. This option requires --follow;
        it can be specified multiple times. Currently, this option is not
        compatible with --graph. This option is experimental.
 
     .. note::
 
        :hg:`log --patch` may generate unexpected diff output for merge
        changesets, as it will only compare the merge changeset against
        its first parent. Also, only files different from BOTH parents
        will appear in files:.
 
     .. note::
 
        For performance reasons, :hg:`log FILE` may omit duplicate changes
        made on branches and will not show removals or mode changes. To
        see all such changes, use the --removed switch.
 
     .. container:: verbose
 
        .. note::
 
           The history resulting from -L/--line-range options depends on diff
           options; for instance if white-spaces are ignored, respective changes
           with only white-spaces in specified line range will not be listed.
 
     .. container:: verbose
 
       Some examples:
 
       - changesets with full descriptions and file lists::
 
           hg log -v
 
       - changesets ancestral to the working directory::
 
           hg log -f
 
       - last 10 commits on the current branch::
 
           hg log -l 10 -b .
 
       - changesets showing all modifications of a file, including removals::
 
           hg log --removed file.c
 
       - all changesets that touch a directory, with diffs, excluding merges::
 
           hg log -Mp lib/
 
       - all revision numbers that match a keyword::
 
           hg log -k bug --template "{rev}\\n"
 
       - the full hash identifier of the working directory parent::
 
           hg log -r . --template "{node}\\n"
 
       - list available log templates::
 
           hg log -T list
 
       - check if a given changeset is included in a tagged release::
 
           hg log -r "a21ccf and ancestor(1.9)"
 
       - find all changesets by some user in a date range::
 
           hg log -k alice -d "may 2008 to jul 2008"
 
       - summary of all changesets after the last tag::
 
           hg log -r "last(tagged())::" --template "{desc|firstline}\\n"
 
       - changesets touching lines 13 to 23 for file.c::
 
           hg log -L file.c,13:23
 
       - changesets touching lines 13 to 23 for file.c and lines 2 to 6 of
         main.c with patch::
 
           hg log -L file.c,13:23 -L main.c,2:6 -p
 
     See :hg:`help dates` for a list of formats valid for -d/--date.
 
     See :hg:`help revisions` for more about specifying and ordering
     revisions.
 
     See :hg:`help templates` for more about pre-packaged styles and
     specifying custom templates. The default template used by the log
     command can be customized via the ``ui.logtemplate`` configuration
     setting.
 
     Returns 0 on success.
 
     """
     opts = pycompat.byteskwargs(opts)
     linerange = opts.get('line_range')
 
     if linerange and not opts.get('follow'):
         raise error.Abort(_('--line-range requires --follow'))
 
     if linerange and pats:
         # TODO: take pats as patterns with no line-range filter
         raise error.Abort(
             _('FILE arguments are not compatible with --line-range option')
         )
 
     repo = scmutil.unhidehashlikerevs(repo, opts.get('rev'), 'nowarn')
     revs, differ = logcmdutil.getrevs(repo, pats, opts)
     if linerange:
         # TODO: should follow file history from logcmdutil._initialrevs(),
         # then filter the result by logcmdutil._makerevset() and --limit
         revs, differ = logcmdutil.getlinerangerevs(repo, revs, opts)
 
     getrenamed = None
     if opts.get('copies'):
         endrev = None
         if revs:
             endrev = revs.max() + 1
         getrenamed = templatekw.getrenamedfn(repo, endrev=endrev)
 
     ui.pager('log')
     displayer = logcmdutil.changesetdisplayer(ui, repo, opts, differ,
                                               buffered=True)
     if opts.get('graph'):
         displayfn = logcmdutil.displaygraphrevs
     else:
         displayfn = logcmdutil.displayrevs
     displayfn(ui, repo, revs, displayer, getrenamed)
 
 @command('manifest',
     [('r', 'rev', '', _('revision to display'), _('REV')),
      ('', 'all', False, _("list files from all revisions"))]
          + formatteropts,
     _('[-r REV]'),
     intents={INTENT_READONLY})
 def manifest(ui, repo, node=None, rev=None, **opts):
     """output the current or given revision of the project manifest
 
     Print a list of version controlled files for the given revision.
     If no revision is given, the first parent of the working directory
     is used, or the null revision if no revision is checked out.
 
     With -v, print file permissions, symlink and executable bits.
     With --debug, print file revision hashes.
 
     If option --all is specified, the list of all files from all revisions
     is printed. This includes deleted and renamed files.
 
     Returns 0 on success.
     """
     opts = pycompat.byteskwargs(opts)
     fm = ui.formatter('manifest', opts)
 
     if opts.get('all'):
         if rev or node:
             raise error.Abort(_("can't specify a revision with --all"))
 
         res = set()
         for rev in repo:
             ctx = repo[rev]
             res |= set(ctx.files())
 
         ui.pager('manifest')
         for f in sorted(res):
             fm.startitem()
             fm.write("path", '%s\n', f)
         fm.end()
         return
 
     if rev and node:
         raise error.Abort(_("please specify just one revision"))
 
     if not node:
         node = rev
 
     char = {'l': '@', 'x': '*', '': '', 't': 'd'}
     mode = {'l': '644', 'x': '755', '': '644', 't': '755'}
     if node:
         repo = scmutil.unhidehashlikerevs(repo, [node], 'nowarn')
     ctx = scmutil.revsingle(repo, node)
     mf = ctx.manifest()
     ui.pager('manifest')
     for f in ctx:
         fm.startitem()
         fm.context(ctx=ctx)
         fl = ctx[f].flags()
         fm.condwrite(ui.debugflag, 'hash', '%s ', hex(mf[f]))
         fm.condwrite(ui.verbose, 'mode type', '%s %1s ', mode[fl], char[fl])
         fm.write('path', '%s\n', f)
     fm.end()
 
 @command('^merge',
     [('f', 'force', None,
       _('force a merge including outstanding changes (DEPRECATED)')),
     ('r', 'rev', '', _('revision to merge'), _('REV')),
     ('P', 'preview', None,
      _('review revisions to merge (no merge is performed)')),
     ('', 'abort', None, _('abort the ongoing merge')),
      ] + mergetoolopts,
     _('[-P] [[-r] REV]'))
 def merge(ui, repo, node=None, **opts):
     """merge another revision into working directory
 
     The current working directory is updated with all changes made in
     the requested revision since the last common predecessor revision.
 
     Files that changed between either parent are marked as changed for
     the next commit and a commit must be performed before any further
     updates to the repository are allowed. The next commit will have
     two parents.
 
     ``--tool`` can be used to specify the merge tool used for file
     merges. It overrides the HGMERGE environment variable and your
     configuration files. See :hg:`help merge-tools` for options.
 
     If no revision is specified, the working directory's parent is a
     head revision, and the current branch contains exactly one other
     head, the other head is merged with by default. Otherwise, an
     explicit revision with which to merge with must be provided.
 
     See :hg:`help resolve` for information on handling file conflicts.
 
     To undo an uncommitted merge, use :hg:`merge --abort` which
     will check out a clean copy of the original merge parent, losing
     all changes.
 
     Returns 0 on success, 1 if there are unresolved files.
     """
 
     opts = pycompat.byteskwargs(opts)
     abort = opts.get('abort')
     if abort and repo.dirstate.p2() == nullid:
         cmdutil.wrongtooltocontinue(repo, _('merge'))
     if abort:
         if node:
             raise error.Abort(_("cannot specify a node with --abort"))
         if opts.get('rev'):
             raise error.Abort(_("cannot specify both --rev and --abort"))
         if opts.get('preview'):
             raise error.Abort(_("cannot specify --preview with --abort"))
     if opts.get('rev') and node:
         raise error.Abort(_("please specify just one revision"))
     if not node:
         node = opts.get('rev')
 
     if node:
         node = scmutil.revsingle(repo, node).node()
 
     if not node and not abort:
         node = repo[destutil.destmerge(repo)].node()
 
     if opts.get('preview'):
         # find nodes that are ancestors of p2 but not of p1
         p1 = repo.lookup('.')
         p2 = node
         nodes = repo.changelog.findmissing(common=[p1], heads=[p2])
 
         displayer = logcmdutil.changesetdisplayer(ui, repo, opts)
         for node in nodes:
             displayer.show(repo[node])
         displayer.close()
         return 0
 
     # ui.forcemerge is an internal variable, do not document
     overrides = {('ui', 'forcemerge'): opts.get('tool', '')}
     with ui.configoverride(overrides, 'merge'):
         force = opts.get('force')
         labels = ['working copy', 'merge rev']
         return hg.merge(repo, node, force=force, mergeforce=force,
                         labels=labels, abort=abort)
 
 @command('outgoing|out',
     [('f', 'force', None, _('run even when the destination is unrelated')),
     ('r', 'rev', [],
      _('a changeset intended to be included in the destination'), _('REV')),
     ('n', 'newest-first', None, _('show newest record first')),
     ('B', 'bookmarks', False, _('compare bookmarks')),
     ('b', 'branch', [], _('a specific branch you would like to push'),
      _('BRANCH')),
     ] + logopts + remoteopts + subrepoopts,
     _('[-M] [-p] [-n] [-f] [-r REV]... [DEST]'))
 def outgoing(ui, repo, dest=None, **opts):
     """show changesets not found in the destination
 
     Show changesets not found in the specified destination repository
     or the default push location. These are the changesets that would
     be pushed if a push was requested.
 
     See pull for details of valid destination formats.
 
     .. container:: verbose
 
       With -B/--bookmarks, the result of bookmark comparison between
       local and remote repositories is displayed. With -v/--verbose,
       status is also displayed for each bookmark like below::
 
         BM1               01234567890a added
         BM2                            deleted
         BM3               234567890abc advanced
         BM4               34567890abcd diverged
         BM5               4567890abcde changed
 
       The action taken when pushing depends on the
       status of each bookmark:
 
       :``added``: push with ``-B`` will create it
       :``deleted``: push with ``-B`` will delete it
       :``advanced``: push will update it
       :``diverged``: push with ``-B`` will update it
       :``changed``: push with ``-B`` will update it
 
       From the point of view of pushing behavior, bookmarks
       existing only in the remote repository are treated as
       ``deleted``, even if it is in fact added remotely.
 
     Returns 0 if there are outgoing changes, 1 otherwise.
     """
     # hg._outgoing() needs to re-resolve the path in order to handle #branch
     # style URLs, so don't overwrite dest.
     path = ui.paths.getpath(dest, default=('default-push', 'default'))
     if not path:
         raise error.Abort(_('default repository not configured!'),
                           hint=_("see 'hg help config.paths'"))
 
     opts = pycompat.byteskwargs(opts)
     if opts.get('graph'):
         logcmdutil.checkunsupportedgraphflags([], opts)
         o, other = hg._outgoing(ui, repo, dest, opts)
         if not o:
             cmdutil.outgoinghooks(ui, repo, other, opts, o)
             return
 
         revdag = logcmdutil.graphrevs(repo, o, opts)
         ui.pager('outgoing')
         displayer = logcmdutil.changesetdisplayer(ui, repo, opts, buffered=True)
         logcmdutil.displaygraph(ui, repo, revdag, displayer,
                                 graphmod.asciiedges)
         cmdutil.outgoinghooks(ui, repo, other, opts, o)
         return 0
 
     if opts.get('bookmarks'):
         dest = path.pushloc or path.loc
         other = hg.peer(repo, opts, dest)
         if 'bookmarks' not in other.listkeys('namespaces'):
             ui.warn(_("remote doesn't support bookmarks\n"))
             return 0
         ui.status(_('comparing with %s\n') % util.hidepassword(dest))
         ui.pager('outgoing')
         return bookmarks.outgoing(ui, repo, other)
 
     repo._subtoppath = path.pushloc or path.loc
     try:
         return hg.outgoing(ui, repo, dest, opts)
     finally:
         del repo._subtoppath
 
 @command('parents',
     [('r', 'rev', '', _('show parents of the specified revision'), _('REV')),
     ] + templateopts,
     _('[-r REV] [FILE]'),
     inferrepo=True)
 def parents(ui, repo, file_=None, **opts):
     """show the parents of the working directory or revision (DEPRECATED)
 
     Print the working directory's parent revisions. If a revision is
     given via -r/--rev, the parent of that revision will be printed.
     If a file argument is given, the revision in which the file was
     last changed (before the working directory revision or the
     argument to --rev if given) is printed.
 
     This command is equivalent to::
 
         hg log -r "p1()+p2()" or
         hg log -r "p1(REV)+p2(REV)" or
         hg log -r "max(::p1() and file(FILE))+max(::p2() and file(FILE))" or
         hg log -r "max(::p1(REV) and file(FILE))+max(::p2(REV) and file(FILE))"
 
     See :hg:`summary` and :hg:`help revsets` for related information.
 
     Returns 0 on success.
     """
 
     opts = pycompat.byteskwargs(opts)
     rev = opts.get('rev')
     if rev:
         repo = scmutil.unhidehashlikerevs(repo, [rev], 'nowarn')
     ctx = scmutil.revsingle(repo, rev, None)
 
     if file_:
         m = scmutil.match(ctx, (file_,), opts)
         if m.anypats() or len(m.files()) != 1:
             raise error.Abort(_('can only specify an explicit filename'))
         file_ = m.files()[0]
         filenodes = []
         for cp in ctx.parents():
             if not cp:
                 continue
             try:
                 filenodes.append(cp.filenode(file_))
             except error.LookupError:
                 pass
         if not filenodes:
             raise error.Abort(_("'%s' not found in manifest!") % file_)
         p = []
         for fn in filenodes:
             fctx = repo.filectx(file_, fileid=fn)
             p.append(fctx.node())
     else:
         p = [cp.node() for cp in ctx.parents()]
 
     displayer = logcmdutil.changesetdisplayer(ui, repo, opts)
     for n in p:
         if n != nullid:
             displayer.show(repo[n])
     displayer.close()
 
 @command('paths', formatteropts, _('[NAME]'), optionalrepo=True,
     intents={INTENT_READONLY})
 def paths(ui, repo, search=None, **opts):
     """show aliases for remote repositories
 
     Show definition of symbolic path name NAME. If no name is given,
     show definition of all available names.
 
     Option -q/--quiet suppresses all output when searching for NAME
     and shows only the path names when listing all definitions.
 
     Path names are defined in the [paths] section of your
     configuration file and in ``/etc/mercurial/hgrc``. If run inside a
     repository, ``.hg/hgrc`` is used, too.
 
     The path names ``default`` and ``default-push`` have a special
     meaning.  When performing a push or pull operation, they are used
     as fallbacks if no location is specified on the command-line.
     When ``default-push`` is set, it will be used for push and
     ``default`` will be used for pull; otherwise ``default`` is used
     as the fallback for both.  When cloning a repository, the clone
     source is written as ``default`` in ``.hg/hgrc``.
 
     .. note::
 
        ``default`` and ``default-push`` apply to all inbound (e.g.
        :hg:`incoming`) and outbound (e.g. :hg:`outgoing`, :hg:`email`
        and :hg:`bundle`) operations.
 
     See :hg:`help urls` for more information.
 
     Returns 0 on success.
     """
 
     opts = pycompat.byteskwargs(opts)
     ui.pager('paths')
     if search:
         pathitems = [(name, path) for name, path in ui.paths.iteritems()
                      if name == search]
     else:
         pathitems = sorted(ui.paths.iteritems())
 
     fm = ui.formatter('paths', opts)
     if fm.isplain():
         hidepassword = util.hidepassword
     else:
         hidepassword = bytes
     if ui.quiet:
         namefmt = '%s\n'
     else:
         namefmt = '%s = '
     showsubopts = not search and not ui.quiet
 
     for name, path in pathitems:
         fm.startitem()
         fm.condwrite(not search, 'name', namefmt, name)
         fm.condwrite(not ui.quiet, 'url', '%s\n', hidepassword(path.rawloc))
         for subopt, value in sorted(path.suboptions.items()):
             assert subopt not in ('name', 'url')
             if showsubopts:
                 fm.plain('%s:%s = ' % (name, subopt))
             fm.condwrite(showsubopts, subopt, '%s\n', value)
 
     fm.end()
 
     if search and not pathitems:
         if not ui.quiet:
             ui.warn(_("not found!\n"))
         return 1
     else:
         return 0
 
 @command('phase',
     [('p', 'public', False, _('set changeset phase to public')),
      ('d', 'draft', False, _('set changeset phase to draft')),
      ('s', 'secret', False, _('set changeset phase to secret')),
      ('f', 'force', False, _('allow to move boundary backward')),
      ('r', 'rev', [], _('target revision'), _('REV')),
     ],
     _('[-p|-d|-s] [-f] [-r] [REV...]'))
 def phase(ui, repo, *revs, **opts):
     """set or show the current phase name
 
     With no argument, show the phase name of the current revision(s).
 
     With one of -p/--public, -d/--draft or -s/--secret, change the
     phase value of the specified revisions.
 
     Unless -f/--force is specified, :hg:`phase` won't move changesets from a
     lower phase to a higher phase. Phases are ordered as follows::
 
         public < draft < secret
 
     Returns 0 on success, 1 if some phases could not be changed.
 
     (For more information about the phases concept, see :hg:`help phases`.)
     """
     opts = pycompat.byteskwargs(opts)
     # search for a unique phase argument
     targetphase = None
     for idx, name in enumerate(phases.phasenames):
         if opts[name]:
             if targetphase is not None:
                 raise error.Abort(_('only one phase can be specified'))
             targetphase = idx
 
     # look for specified revision
     revs = list(revs)
     revs.extend(opts['rev'])
     if not revs:
         # display both parents as the second parent phase can influence
         # the phase of a merge commit
         revs = [c.rev() for c in repo[None].parents()]
 
     revs = scmutil.revrange(repo, revs)
 
     ret = 0
     if targetphase is None:
         # display
         for r in revs:
             ctx = repo[r]
             ui.write('%i: %s\n' % (ctx.rev(), ctx.phasestr()))
     else:
         with repo.lock(), repo.transaction("phase") as tr:
             # set phase
             if not revs:
                 raise error.Abort(_('empty revision set'))
             nodes = [repo[r].node() for r in revs]
             # moving revision from public to draft may hide them
             # We have to check result on an unfiltered repository
             unfi = repo.unfiltered()
             getphase = unfi._phasecache.phase
             olddata = [getphase(unfi, r) for r in unfi]
             phases.advanceboundary(repo, tr, targetphase, nodes)
             if opts['force']:
                 phases.retractboundary(repo, tr, targetphase, nodes)
         getphase = unfi._phasecache.phase
         newdata = [getphase(unfi, r) for r in unfi]
         changes = sum(newdata[r] != olddata[r] for r in unfi)
         cl = unfi.changelog
         rejected = [n for n in nodes
                     if newdata[cl.rev(n)] < targetphase]
         if rejected:
             ui.warn(_('cannot move %i changesets to a higher '
                       'phase, use --force\n') % len(rejected))
             ret = 1
         if changes:
             msg = _('phase changed for %i changesets\n') % changes
             if ret:
                 ui.status(msg)
             else:
                 ui.note(msg)
         else:
             ui.warn(_('no phases changed\n'))
     return ret
 
 def postincoming(ui, repo, modheads, optupdate, checkout, brev):
     """Run after a changegroup has been added via pull/unbundle
 
     This takes arguments below:
 
     :modheads: change of heads by pull/unbundle
     :optupdate: updating working directory is needed or not
     :checkout: update destination revision (or None to default destination)
     :brev: a name, which might be a bookmark to be activated after updating
     """
     if modheads == 0:
         return
     if optupdate:
         try:
             return hg.updatetotally(ui, repo, checkout, brev)
         except error.UpdateAbort as inst:
             msg = _("not updating: %s") % stringutil.forcebytestr(inst)
             hint = inst.hint
             raise error.UpdateAbort(msg, hint=hint)
     if modheads > 1:
         currentbranchheads = len(repo.branchheads())
         if currentbranchheads == modheads:
             ui.status(_("(run 'hg heads' to see heads, 'hg merge' to merge)\n"))
         elif currentbranchheads > 1:
             ui.status(_("(run 'hg heads .' to see heads, 'hg merge' to "
                         "merge)\n"))
         else:
             ui.status(_("(run 'hg heads' to see heads)\n"))
     elif not ui.configbool('commands', 'update.requiredest'):
         ui.status(_("(run 'hg update' to get a working copy)\n"))
 
 @command('^pull',
     [('u', 'update', None,
      _('update to new branch head if new descendants were pulled')),
     ('f', 'force', None, _('run even when remote repository is unrelated')),
     ('r', 'rev', [], _('a remote changeset intended to be added'), _('REV')),
     ('B', 'bookmark', [], _("bookmark to pull"), _('BOOKMARK')),
     ('b', 'branch', [], _('a specific branch you would like to pull'),
      _('BRANCH')),
     ] + remoteopts,
     _('[-u] [-f] [-r REV]... [-e CMD] [--remotecmd CMD] [SOURCE]'))
 def pull(ui, repo, source="default", **opts):
     """pull changes from the specified source
 
     Pull changes from a remote repository to a local one.
 
     This finds all changes from the repository at the specified path
     or URL and adds them to a local repository (the current one unless
     -R is specified). By default, this does not update the copy of the
     project in the working directory.
 
     When cloning from servers that support it, Mercurial may fetch
     pre-generated data. When this is done, hooks operating on incoming
     changesets and changegroups may fire more than once, once for each
     pre-generated bundle and as well as for any additional remaining
     data. See :hg:`help -e clonebundles` for more.
 
     Use :hg:`incoming` if you want to see what would have been added
     by a pull at the time you issued this command. If you then decide
     to add those changes to the repository, you should use :hg:`pull
     -r X` where ``X`` is the last changeset listed by :hg:`incoming`.
 
     If SOURCE is omitted, the 'default' path will be used.
     See :hg:`help urls` for more information.
 
     Specifying bookmark as ``.`` is equivalent to specifying the active
     bookmark's name.
 
     Returns 0 on success, 1 if an update had unresolved files.
     """
 
     opts = pycompat.byteskwargs(opts)
     if ui.configbool('commands', 'update.requiredest') and opts.get('update'):
         msg = _('update destination required by configuration')
         hint = _('use hg pull followed by hg update DEST')
         raise error.Abort(msg, hint=hint)
 
     source, branches = hg.parseurl(ui.expandpath(source), opts.get('branch'))
     ui.status(_('pulling from %s\n') % util.hidepassword(source))
     other = hg.peer(repo, opts, source)
     try:
         revs, checkout = hg.addbranchrevs(repo, other, branches,
                                           opts.get('rev'))
 
 
         pullopargs = {}
         if opts.get('bookmark'):
             if not revs:
                 revs = []
             # The list of bookmark used here is not the one used to actually
             # update the bookmark name. This can result in the revision pulled
             # not ending up with the name of the bookmark because of a race
             # condition on the server. (See issue 4689 for details)
             remotebookmarks = other.listkeys('bookmarks')
             remotebookmarks = bookmarks.unhexlifybookmarks(remotebookmarks)
             pullopargs['remotebookmarks'] = remotebookmarks
             for b in opts['bookmark']:
                 b = repo._bookmarks.expandname(b)
                 if b not in remotebookmarks:
                     raise error.Abort(_('remote bookmark %s not found!') % b)
                 revs.append(hex(remotebookmarks[b]))
 
         if revs:
             try:
                 # When 'rev' is a bookmark name, we cannot guarantee that it
                 # will be updated with that name because of a race condition
                 # server side. (See issue 4689 for details)
                 oldrevs = revs
                 revs = [] # actually, nodes
                 for r in oldrevs:
                     with other.commandexecutor() as e:
                         node = e.callcommand('lookup', {'key': r}).result()
 
                     revs.append(node)
                     if r == checkout:
                         checkout = node
             except error.CapabilityError:
                 err = _("other repository doesn't support revision lookup, "
                         "so a rev cannot be specified.")
                 raise error.Abort(err)
 
         wlock = util.nullcontextmanager()
         if opts.get('update'):
             wlock = repo.wlock()
         with wlock:
             pullopargs.update(opts.get('opargs', {}))
             modheads = exchange.pull(repo, other, heads=revs,
                                      force=opts.get('force'),
                                      bookmarks=opts.get('bookmark', ()),
                                      opargs=pullopargs).cgresult
 
             # brev is a name, which might be a bookmark to be activated at
             # the end of the update. In other words, it is an explicit
             # destination of the update
             brev = None
 
             if checkout:
                 checkout = repo.changelog.rev(checkout)
 
                 # order below depends on implementation of
                 # hg.addbranchrevs(). opts['bookmark'] is ignored,
                 # because 'checkout' is determined without it.
                 if opts.get('rev'):
                     brev = opts['rev'][0]
                 elif opts.get('branch'):
                     brev = opts['branch'][0]
                 else:
                     brev = branches[0]
             repo._subtoppath = source
             try:
                 ret = postincoming(ui, repo, modheads, opts.get('update'),
                                    checkout, brev)
 
             finally:
                 del repo._subtoppath
 
     finally:
         other.close()
     return ret
 
 @command('^push',
     [('f', 'force', None, _('force push')),
     ('r', 'rev', [],
      _('a changeset intended to be included in the destination'),
      _('REV')),
     ('B', 'bookmark', [], _("bookmark to push"), _('BOOKMARK')),
     ('b', 'branch', [],
      _('a specific branch you would like to push'), _('BRANCH')),
     ('', 'new-branch', False, _('allow pushing a new branch')),
     ('', 'pushvars', [], _('variables that can be sent to server (ADVANCED)')),
     ] + remoteopts,
     _('[-f] [-r REV]... [-e CMD] [--remotecmd CMD] [DEST]'))
 def push(ui, repo, dest=None, **opts):
     """push changes to the specified destination
 
     Push changesets from the local repository to the specified
     destination.
 
     This operation is symmetrical to pull: it is identical to a pull
     in the destination repository from the current one.
 
     By default, push will not allow creation of new heads at the
     destination, since multiple heads would make it unclear which head
     to use. In this situation, it is recommended to pull and merge
     before pushing.
 
     Use --new-branch if you want to allow push to create a new named
     branch that is not present at the destination. This allows you to
     only create a new branch without forcing other changes.
 
     .. note::
 
        Extra care should be taken with the -f/--force option,
        which will push all new heads on all branches, an action which will
        almost always cause confusion for collaborators.
 
     If -r/--rev is used, the specified revision and all its ancestors
     will be pushed to the remote repository.
 
     If -B/--bookmark is used, the specified bookmarked revision, its
     ancestors, and the bookmark will be pushed to the remote
     repository. Specifying ``.`` is equivalent to specifying the active
     bookmark's name.
 
     Please see :hg:`help urls` for important details about ``ssh://``
     URLs. If DESTINATION is omitted, a default path will be used.
 
     .. container:: verbose
 
         The --pushvars option sends strings to the server that become
         environment variables prepended with ``HG_USERVAR_``. For example,
         ``--pushvars ENABLE_FEATURE=true``, provides the server side hooks with
         ``HG_USERVAR_ENABLE_FEATURE=true`` as part of their environment.
 
         pushvars can provide for user-overridable hooks as well as set debug
         levels. One example is having a hook that blocks commits containing
         conflict markers, but enables the user to override the hook if the file
         is using conflict markers for testing purposes or the file format has
         strings that look like conflict markers.
 
         By default, servers will ignore `--pushvars`. To enable it add the
         following to your configuration file::
 
             [push]
             pushvars.server = true
 
     Returns 0 if push was successful, 1 if nothing to push.
     """
 
     opts = pycompat.byteskwargs(opts)
     if opts.get('bookmark'):
         ui.setconfig('bookmarks', 'pushing', opts['bookmark'], 'push')
         for b in opts['bookmark']:
             # translate -B options to -r so changesets get pushed
             b = repo._bookmarks.expandname(b)
             if b in repo._bookmarks:
                 opts.setdefault('rev', []).append(b)
             else:
                 # if we try to push a deleted bookmark, translate it to null
                 # this lets simultaneous -r, -b options continue working
                 opts.setdefault('rev', []).append("null")
 
     path = ui.paths.getpath(dest, default=('default-push', 'default'))
     if not path:
         raise error.Abort(_('default repository not configured!'),
                          hint=_("see 'hg help config.paths'"))
     dest = path.pushloc or path.loc
     branches = (path.branch, opts.get('branch') or [])
     ui.status(_('pushing to %s\n') % util.hidepassword(dest))
     revs, checkout = hg.addbranchrevs(repo, repo, branches, opts.get('rev'))
     other = hg.peer(repo, opts, dest)
 
     if revs:
         revs = [repo[r].node() for r in scmutil.revrange(repo, revs)]
         if not revs:
             raise error.Abort(_("specified revisions evaluate to an empty set"),
                              hint=_("use different revision arguments"))
     elif path.pushrev:
         # It doesn't make any sense to specify ancestor revisions. So limit
         # to DAG heads to make discovery simpler.
         expr = revsetlang.formatspec('heads(%r)', path.pushrev)
         revs = scmutil.revrange(repo, [expr])
         revs = [repo[rev].node() for rev in revs]
         if not revs:
             raise error.Abort(_('default push revset for path evaluates to an '
                                 'empty set'))
 
     repo._subtoppath = dest
     try:
         # push subrepos depth-first for coherent ordering
         c = repo['.']
         subs = c.substate # only repos that are committed
         for s in sorted(subs):
             result = c.sub(s).push(opts)
             if result == 0:
                 return not result
     finally:
         del repo._subtoppath
 
     opargs = dict(opts.get('opargs', {})) # copy opargs since we may mutate it
     opargs.setdefault('pushvars', []).extend(opts.get('pushvars', []))
 
     pushop = exchange.push(repo, other, opts.get('force'), revs=revs,
                            newbranch=opts.get('new_branch'),
                            bookmarks=opts.get('bookmark', ()),
                            opargs=opargs)
 
     result = not pushop.cgresult
 
     if pushop.bkresult is not None:
         if pushop.bkresult == 2:
             result = 2
         elif not result and pushop.bkresult:
             result = 2
 
     return result
 
 @command('recover', [])
 def recover(ui, repo):
     """roll back an interrupted transaction
 
     Recover from an interrupted commit or pull.
 
     This command tries to fix the repository status after an
     interrupted operation. It should only be necessary when Mercurial
     suggests it.
 
     Returns 0 if successful, 1 if nothing to recover or verify fails.
     """
     if repo.recover():
         return hg.verify(repo)
     return 1
 
 @command('^remove|rm',
     [('A', 'after', None, _('record delete for missing files')),
     ('f', 'force', None,
      _('forget added files, delete modified files')),
     ] + subrepoopts + walkopts + dryrunopts,
     _('[OPTION]... FILE...'),
     inferrepo=True)
 def remove(ui, repo, *pats, **opts):
     """remove the specified files on the next commit
 
     Schedule the indicated files for removal from the current branch.
 
     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`.
 
     .. container:: verbose
 
       -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.
 
       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):
 
       ========= == == == ==
       opt/state A  C  M  !
       ========= == == == ==
       none      W  RD W  R
       -f        R  RD RD R
       -A        W  W  W  R
       -Af       R  R  R  R
       ========= == == == ==
 
       .. note::
 
          :hg:`remove` never deletes files in Added [A] state from the
          working directory, not even if ``--force`` is specified.
 
     Returns 0 on success, 1 if any warnings encountered.
     """
 
     opts = pycompat.byteskwargs(opts)
     after, force = opts.get('after'), opts.get('force')
     dryrun = opts.get('dry_run')
     if not pats and not after:
         raise error.Abort(_('no files specified'))
 
     m = scmutil.match(repo[None], pats, opts)
     subrepos = opts.get('subrepos')
     return cmdutil.remove(ui, repo, m, "", after, force, subrepos,
                           dryrun=dryrun)
 
 @command('rename|move|mv',
     [('A', 'after', None, _('record a rename that has already occurred')),
     ('f', 'force', None, _('forcibly copy over an existing managed file')),
     ] + walkopts + dryrunopts,
     _('[OPTION]... SOURCE... DEST'))
 def rename(ui, repo, *pats, **opts):
     """rename files; equivalent of copy + remove
 
     Mark dest as copies of sources; mark sources for deletion. If dest
     is a directory, copies are put in that directory. If dest is a
     file, there can only be one source.
 
     By default, this command copies the contents of files as they
     exist in the working directory. If invoked with -A/--after, the
     operation is recorded, but no copying is performed.
 
     This command takes effect at the next commit. To undo a rename
     before that, see :hg:`revert`.
 
     Returns 0 on success, 1 if errors are encountered.
     """
     opts = pycompat.byteskwargs(opts)
     with repo.wlock(False):
         return cmdutil.copy(ui, repo, pats, opts, rename=True)
 
 @command('resolve',
     [('a', 'all', None, _('select all unresolved files')),
     ('l', 'list', None, _('list state of files needing merge')),
     ('m', 'mark', None, _('mark files as resolved')),
     ('u', 'unmark', None, _('mark files as unresolved')),
     ('n', 'no-status', None, _('hide status prefix'))]
     + mergetoolopts + walkopts + formatteropts,
     _('[OPTION]... [FILE]...'),
     inferrepo=True)
 def resolve(ui, repo, *pats, **opts):
     """redo merges or set/view the merge status of files
 
     Merges with unresolved conflicts are often the result of
     non-interactive merging using the ``internal:merge`` configuration
     setting, or a command-line merge tool like ``diff3``. The resolve
     command is used to manage the files involved in a merge, after
     :hg:`merge` has been run, and before :hg:`commit` is run (i.e. the
     working directory must have two parents). See :hg:`help
     merge-tools` for information on configuring merge tools.
 
     The resolve command can be used in the following ways:
 
     - :hg:`resolve [--tool TOOL] FILE...`: attempt to re-merge the specified
       files, discarding any previous merge attempts. Re-merging is not
       performed for files already marked as resolved. Use ``--all/-a``
       to select all unresolved files. ``--tool`` can be used to specify
       the merge tool used for the given files. It overrides the HGMERGE
       environment variable and your configuration files.  Previous file
       contents are saved with a ``.orig`` suffix.
 
     - :hg:`resolve -m [FILE]`: mark a file as having been resolved
       (e.g. after having manually fixed-up the files). The default is
       to mark all unresolved files.
 
     - :hg:`resolve -u [FILE]...`: mark a file as unresolved. The
       default is to mark all resolved files.
 
     - :hg:`resolve -l`: list files which had or still have conflicts.
       In the printed list, ``U`` = unresolved and ``R`` = resolved.
       You can use ``set:unresolved()`` or ``set:resolved()`` to filter
       the list. See :hg:`help filesets` for details.
 
     .. note::
 
        Mercurial will not let you commit files with unresolved merge
        conflicts. You must use :hg:`resolve -m ...` before you can
        commit after a conflicting merge.
 
     Returns 0 on success, 1 if any files fail a resolve attempt.
     """
 
     opts = pycompat.byteskwargs(opts)
     confirm = ui.configbool('commands', 'resolve.confirm')
     flaglist = 'all mark unmark list no_status'.split()
     all, mark, unmark, show, nostatus = \
         [opts.get(o) for o in flaglist]
 
     if all and confirm:
         if ui.promptchoice(_(b're-merge all unresolved files (yn)?'
                              b'$$ &Yes $$ &No')):
             raise error.Abort(_('user quit'))
 
     if (show and (mark or unmark)) or (mark and unmark):
         raise error.Abort(_("too many options specified"))
     if pats and all:
         raise error.Abort(_("can't specify --all and patterns"))
     if not (all or pats or show or mark or unmark):
         raise error.Abort(_('no files or directories specified'),
                          hint=('use --all to re-merge all unresolved files'))
 
     if show:
         ui.pager('resolve')
         fm = ui.formatter('resolve', opts)
         ms = mergemod.mergestate.read(repo)
         wctx = repo[None]
         m = scmutil.match(wctx, pats, opts)
 
         # Labels and keys based on merge state.  Unresolved path conflicts show
         # as 'P'.  Resolved path conflicts show as 'R', the same as normal
         # resolved conflicts.
         mergestateinfo = {
             mergemod.MERGE_RECORD_UNRESOLVED: ('resolve.unresolved', 'U'),
             mergemod.MERGE_RECORD_RESOLVED: ('resolve.resolved', 'R'),
             mergemod.MERGE_RECORD_UNRESOLVED_PATH: ('resolve.unresolved', 'P'),
             mergemod.MERGE_RECORD_RESOLVED_PATH: ('resolve.resolved', 'R'),
             mergemod.MERGE_RECORD_DRIVER_RESOLVED: ('resolve.driverresolved',
                                                     'D'),
         }
 
         for f in ms:
             if not m(f):
                 continue
 
             label, key = mergestateinfo[ms[f]]
             fm.startitem()
             fm.context(ctx=wctx)
             fm.condwrite(not nostatus, 'status', '%s ', key, label=label)
             fm.write('path', '%s\n', f, label=label)
         fm.end()
         return 0
 
     with repo.wlock():
         ms = mergemod.mergestate.read(repo)
 
         if not (ms.active() or repo.dirstate.p2() != nullid):
             raise error.Abort(
                 _('resolve command not applicable when not merging'))
 
         wctx = repo[None]
 
         if (ms.mergedriver
             and ms.mdstate() == mergemod.MERGE_DRIVER_STATE_UNMARKED):
             proceed = mergemod.driverpreprocess(repo, ms, wctx)
             ms.commit()
             # allow mark and unmark to go through
             if not mark and not unmark and not proceed:
                 return 1
 
         m = scmutil.match(wctx, pats, opts)
         ret = 0
         didwork = False
         runconclude = False
 
         tocomplete = []
         hasconflictmarkers = []
         if mark:
-            markcheck = ui.config('experimental', 'resolve.mark-check')
+            markcheck = ui.config('commands', 'resolve.mark-check')
         for f in ms:
             if not m(f):
                 continue
 
             didwork = True
 
             # don't let driver-resolved files be marked, and run the conclude
             # step if asked to resolve
             if ms[f] == mergemod.MERGE_RECORD_DRIVER_RESOLVED:
                 exact = m.exact(f)
                 if mark:
                     if exact:
                         ui.warn(_('not marking %s as it is driver-resolved\n')
                                 % f)
                 elif unmark:
                     if exact:
                         ui.warn(_('not unmarking %s as it is driver-resolved\n')
                                 % f)
                 else:
                     runconclude = True
                 continue
 
             # path conflicts must be resolved manually
             if ms[f] in (mergemod.MERGE_RECORD_UNRESOLVED_PATH,
                          mergemod.MERGE_RECORD_RESOLVED_PATH):
                 if mark:
                     ms.mark(f, mergemod.MERGE_RECORD_RESOLVED_PATH)
                 elif unmark:
                     ms.mark(f, mergemod.MERGE_RECORD_UNRESOLVED_PATH)
                 elif ms[f] == mergemod.MERGE_RECORD_UNRESOLVED_PATH:
                     ui.warn(_('%s: path conflict must be resolved manually\n')
                             % f)
                 continue
 
             if mark:
                 if markcheck:
                     with repo.wvfs(f) as fobj:
                         fdata = fobj.read()
                     if filemerge.hasconflictmarkers(fdata) and \
                         ms[f] != mergemod.MERGE_RECORD_RESOLVED:
                         hasconflictmarkers.append(f)
                 ms.mark(f, mergemod.MERGE_RECORD_RESOLVED)
             elif unmark:
                 ms.mark(f, mergemod.MERGE_RECORD_UNRESOLVED)
             else:
                 # backup pre-resolve (merge uses .orig for its own purposes)
                 a = repo.wjoin(f)
                 try:
                     util.copyfile(a, a + ".resolve")
                 except (IOError, OSError) as inst:
                     if inst.errno != errno.ENOENT:
                         raise
 
                 try:
                     # preresolve file
                     overrides = {('ui', 'forcemerge'): opts.get('tool', '')}
                     with ui.configoverride(overrides, 'resolve'):
                         complete, r = ms.preresolve(f, wctx)
                     if not complete:
                         tocomplete.append(f)
                     elif r:
                         ret = 1
                 finally:
                     ms.commit()
 
                 # replace filemerge's .orig file with our resolve file, but only
                 # for merges that are complete
                 if complete:
                     try:
                         util.rename(a + ".resolve",
                                     scmutil.origpath(ui, repo, a))
                     except OSError as inst:
                         if inst.errno != errno.ENOENT:
                             raise
 
         if hasconflictmarkers:
             ui.warn(_('warning: the following files still have conflict '
                       'markers:\n  ') + '\n  '.join(hasconflictmarkers) + '\n')
             if markcheck == 'abort' and not all:
                 raise error.Abort(_('conflict markers detected'),
                                   hint=_('use --all to mark anyway'))
 
         for f in tocomplete:
             try:
                 # resolve file
                 overrides = {('ui', 'forcemerge'): opts.get('tool', '')}
                 with ui.configoverride(overrides, 'resolve'):
                     r = ms.resolve(f, wctx)
                 if r:
                     ret = 1
             finally:
                 ms.commit()
 
             # replace filemerge's .orig file with our resolve file
             a = repo.wjoin(f)
             try:
                 util.rename(a + ".resolve", scmutil.origpath(ui, repo, a))
             except OSError as inst:
                 if inst.errno != errno.ENOENT:
                     raise
 
         ms.commit()
         ms.recordactions()
 
         if not didwork and pats:
             hint = None
             if not any([p for p in pats if p.find(':') >= 0]):
                 pats = ['path:%s' % p for p in pats]
                 m = scmutil.match(wctx, pats, opts)
                 for f in ms:
                     if not m(f):
                         continue
                     flags = ''.join(['-%s ' % o[0:1] for o in flaglist
                                                    if opts.get(o)])
                     hint = _("(try: hg resolve %s%s)\n") % (
                              flags,
                              ' '.join(pats))
                     break
             ui.warn(_("arguments do not match paths that need resolving\n"))
             if hint:
                 ui.warn(hint)
         elif ms.mergedriver and ms.mdstate() != 's':
             # run conclude step when either a driver-resolved file is requested
             # or there are no driver-resolved files
             # we can't use 'ret' to determine whether any files are unresolved
             # because we might not have tried to resolve some
             if ((runconclude or not list(ms.driverresolved()))
                 and not list(ms.unresolved())):
                 proceed = mergemod.driverconclude(repo, ms, wctx)
                 ms.commit()
                 if not proceed:
                     return 1
 
     # Nudge users into finishing an unfinished operation
     unresolvedf = list(ms.unresolved())
     driverresolvedf = list(ms.driverresolved())
     if not unresolvedf and not driverresolvedf:
         ui.status(_('(no more unresolved files)\n'))
         cmdutil.checkafterresolved(repo)
     elif not unresolvedf:
         ui.status(_('(no more unresolved files -- '
                     'run "hg resolve --all" to conclude)\n'))
 
     return ret
 
 @command('revert',
     [('a', 'all', None, _('revert all changes when no arguments given')),
     ('d', 'date', '', _('tipmost revision matching date'), _('DATE')),
     ('r', 'rev', '', _('revert to the specified revision'), _('REV')),
     ('C', 'no-backup', None, _('do not save backup copies of files')),
     ('i', 'interactive', None, _('interactively select the changes')),
     ] + walkopts + dryrunopts,
     _('[OPTION]... [-r REV] [NAME]...'))
 def revert(ui, repo, *pats, **opts):
     """restore files to their checkout state
 
     .. note::
 
        To check out earlier revisions, you should use :hg:`update REV`.
        To cancel an uncommitted merge (and lose your changes),
        use :hg:`merge --abort`.
 
     With no revision specified, revert the specified files or directories
     to the contents they had in the parent of the working directory.
     This restores the contents of files to an unmodified
     state and unschedules adds, removes, copies, and renames. If the
     working directory has two parents, you must explicitly specify a
     revision.
 
     Using the -r/--rev or -d/--date options, revert the given files or
     directories to their states as of a specific revision. Because
     revert does not change the working directory parents, this will
     cause these files to appear modified. This can be helpful to "back
     out" some or all of an earlier change. See :hg:`backout` for a
     related method.
 
     Modified files are saved with a .orig suffix before reverting.
     To disable these backups, use --no-backup. It is possible to store
     the backup files in a custom directory relative to the root of the
     repository by setting the ``ui.origbackuppath`` configuration
     option.
 
     See :hg:`help dates` for a list of formats valid for -d/--date.
 
     See :hg:`help backout` for a way to reverse the effect of an
     earlier changeset.
 
     Returns 0 on success.
     """
 
     opts = pycompat.byteskwargs(opts)
     if opts.get("date"):
         if opts.get("rev"):
             raise error.Abort(_("you can't specify a revision and a date"))
         opts["rev"] = cmdutil.finddate(ui, repo, opts["date"])
 
     parent, p2 = repo.dirstate.parents()
     if not opts.get('rev') and p2 != nullid:
         # revert after merge is a trap for new users (issue2915)
         raise error.Abort(_('uncommitted merge with no revision specified'),
                          hint=_("use 'hg update' or see 'hg help revert'"))
 
     rev = opts.get('rev')
     if rev:
         repo = scmutil.unhidehashlikerevs(repo, [rev], 'nowarn')
     ctx = scmutil.revsingle(repo, rev)
 
     if (not (pats or opts.get('include') or opts.get('exclude') or
              opts.get('all') or opts.get('interactive'))):
         msg = _("no files or directories specified")
         if p2 != nullid:
             hint = _("uncommitted merge, use --all to discard all changes,"
                      " or 'hg update -C .' to abort the merge")
             raise error.Abort(msg, hint=hint)
         dirty = any(repo.status())
         node = ctx.node()
         if node != parent:
             if dirty:
                 hint = _("uncommitted changes, use --all to discard all"
                          " changes, or 'hg update %s' to update") % ctx.rev()
             else:
                 hint = _("use --all to revert all files,"
                          " or 'hg update %s' to update") % ctx.rev()
         elif dirty:
             hint = _("uncommitted changes, use --all to discard all changes")
         else:
             hint = _("use --all to revert all files")
         raise error.Abort(msg, hint=hint)
 
     return cmdutil.revert(ui, repo, ctx, (parent, p2), *pats,
                           **pycompat.strkwargs(opts))
 
 @command('rollback', dryrunopts +
          [('f', 'force', False, _('ignore safety measures'))])
 def rollback(ui, repo, **opts):
     """roll back the last transaction (DANGEROUS) (DEPRECATED)
 
     Please use :hg:`commit --amend` instead of rollback to correct
     mistakes in the last commit.
 
     This command should be used with care. There is only one level of
     rollback, and there is no way to undo a rollback. It will also
     restore the dirstate at the time of the last transaction, losing
     any dirstate changes since that time. This command does not alter
     the working directory.
 
     Transactions are used to encapsulate the effects of all commands
     that create new changesets or propagate existing changesets into a
     repository.
 
     .. container:: verbose
 
       For example, the following commands are transactional, and their
       effects can be rolled back:
 
       - commit
       - import
       - pull
       - push (with this repository as the destination)
       - unbundle
 
       To avoid permanent data loss, rollback will refuse to rollback a
       commit transaction if it isn't checked out. Use --force to
       override this protection.
 
       The rollback command can be entirely disabled by setting the
       ``ui.rollback`` configuration setting to false. If you're here
       because you want to use rollback and it's disabled, you can
       re-enable the command by setting ``ui.rollback`` to true.
 
     This command is not intended for use on public repositories. Once
     changes are visible for pull by other users, rolling a transaction
     back locally is ineffective (someone else may already have pulled
     the changes). Furthermore, a race is possible with readers of the
     repository; for example an in-progress pull from the repository
     may fail if a rollback is performed.
 
     Returns 0 on success, 1 if no rollback data is available.
     """
     if not ui.configbool('ui', 'rollback'):
         raise error.Abort(_('rollback is disabled because it is unsafe'),
                           hint=('see `hg help -v rollback` for information'))
     return repo.rollback(dryrun=opts.get(r'dry_run'),
                          force=opts.get(r'force'))
 
 @command('root', [], intents={INTENT_READONLY})
 def root(ui, repo):
     """print the root (top) of the current working directory
 
     Print the root directory of the current repository.
 
     Returns 0 on success.
     """
     ui.write(repo.root + "\n")
 
 @command('^serve',
     [('A', 'accesslog', '', _('name of access log file to write to'),
      _('FILE')),
     ('d', 'daemon', None, _('run server in background')),
     ('', 'daemon-postexec', [], _('used internally by daemon mode')),
     ('E', 'errorlog', '', _('name of error log file to write to'), _('FILE')),
     # use string type, then we can check if something was passed
     ('p', 'port', '', _('port to listen on (default: 8000)'), _('PORT')),
     ('a', 'address', '', _('address to listen on (default: all interfaces)'),
      _('ADDR')),
     ('', 'prefix', '', _('prefix path to serve from (default: server root)'),
      _('PREFIX')),
     ('n', 'name', '',
      _('name to show in web pages (default: working directory)'), _('NAME')),
     ('', 'web-conf', '',
      _("name of the hgweb config file (see 'hg help hgweb')"), _('FILE')),
     ('', 'webdir-conf', '', _('name of the hgweb config file (DEPRECATED)'),
      _('FILE')),
     ('', 'pid-file', '', _('name of file to write process ID to'), _('FILE')),
     ('', 'stdio', None, _('for remote clients (ADVANCED)')),
     ('', 'cmdserver', '', _('for remote clients (ADVANCED)'), _('MODE')),
     ('t', 'templates', '', _('web templates to use'), _('TEMPLATE')),
     ('', 'style', '', _('template style to use'), _('STYLE')),
     ('6', 'ipv6', None, _('use IPv6 in addition to IPv4')),
     ('', 'certificate', '', _('SSL certificate file'), _('FILE')),
     ('', 'print-url', None, _('start and print only the URL'))]
      + subrepoopts,
     _('[OPTION]...'),
     optionalrepo=True)
 def serve(ui, repo, **opts):
     """start stand-alone webserver
 
     Start a local HTTP repository browser and pull server. You can use
     this for ad-hoc sharing and browsing of repositories. It is
     recommended to use a real web server to serve a repository for
     longer periods of time.
 
     Please note that the server does not implement access control.
     This means that, by default, anybody can read from the server and
     nobody can write to it by default. Set the ``web.allow-push``
     option to ``*`` to allow everybody to push to the server. You
     should use a real web server if you need to authenticate users.
 
     By default, the server logs accesses to stdout and errors to
     stderr. Use the -A/--accesslog and -E/--errorlog options to log to
     files.
 
     To have the server choose a free port number to listen on, specify
     a port number of 0; in this case, the server will print the port
     number it uses.
 
     Returns 0 on success.
     """
 
     opts = pycompat.byteskwargs(opts)
     if opts["stdio"] and opts["cmdserver"]:
         raise error.Abort(_("cannot use --stdio with --cmdserver"))
     if opts["print_url"] and ui.verbose:
         raise error.Abort(_("cannot use --print-url with --verbose"))
 
     if opts["stdio"]:
         if repo is None:
             raise error.RepoError(_("there is no Mercurial repository here"
                                     " (.hg not found)"))
         s = wireprotoserver.sshserver(ui, repo)
         s.serve_forever()
 
     service = server.createservice(ui, repo, opts)
     return server.runservice(opts, initfn=service.init, runfn=service.run)
 
 _NOTTERSE = 'nothing'
 
 @command('^status|st',
     [('A', 'all', None, _('show status of all files')),
     ('m', 'modified', None, _('show only modified files')),
     ('a', 'added', None, _('show only added files')),
     ('r', 'removed', None, _('show only removed files')),
     ('d', 'deleted', None, _('show only deleted (but tracked) files')),
     ('c', 'clean', None, _('show only files without changes')),
     ('u', 'unknown', None, _('show only unknown (not tracked) files')),
     ('i', 'ignored', None, _('show only ignored files')),
     ('n', 'no-status', None, _('hide status prefix')),
     ('t', 'terse', _NOTTERSE, _('show the terse output (EXPERIMENTAL)')),
     ('C', 'copies', None, _('show source of copied files')),
     ('0', 'print0', None, _('end filenames with NUL, for use with xargs')),
     ('', 'rev', [], _('show difference from revision'), _('REV')),
     ('', 'change', '', _('list the changed files of a revision'), _('REV')),
     ] + walkopts + subrepoopts + formatteropts,
     _('[OPTION]... [FILE]...'),
     inferrepo=True,
     intents={INTENT_READONLY})
 def status(ui, repo, *pats, **opts):
     """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)
 
     .. container:: verbose
 
       The -t/--terse option abbreviates the output by showing only the directory
       name if all the files in it share the same status. The option takes an
       argument indicating the statuses to abbreviate: 'm' for 'modified', 'a'
       for 'added', 'r' for 'removed', 'd' for 'deleted', 'u' for 'unknown', 'i'
       for 'ignored' and 'c' for clean.
 
       It abbreviates only those statuses which are passed. Note that clean and
       ignored files are not displayed with '--terse ic' unless the -c/--clean
       and -i/--ignored options are also used.
 
       The -v/--verbose option shows information when the repository is in an
       unfinished merge, shelve, rebase state etc. You can have this behavior
       turned on by default by enabling the ``commands.status.verbose`` option.
 
       You can skip displaying some of these states by setting
       ``commands.status.skipstates`` to one or more of: 'bisect', 'graft',
       'histedit', 'merge', 'rebase', or 'unshelve'.
 
       Examples:
 
       - show changes in the working directory relative to a
         changeset::
 
           hg status --rev 9353
 
       - show changes in the working directory relative to the
         current directory (see :hg:`help patterns` for more information)::
 
           hg status re:
 
       - show all changes including copies in an existing changeset::
 
           hg status --copies --change 9353
 
       - get a NUL separated list of added files, suitable for xargs::
 
           hg status -an0
 
       - show more information about the repository status, abbreviating
         added, removed, modified, deleted, and untracked paths::
 
           hg status -v -t mardu
 
     Returns 0 on success.
 
     """
 
     opts = pycompat.byteskwargs(opts)
     revs = opts.get('rev')
     change = opts.get('change')
     terse = opts.get('terse')
     if terse is _NOTTERSE:
         if revs:
             terse = ''
         else:
             terse = ui.config('commands', 'status.terse')
 
     if revs and change:
         msg = _('cannot specify --rev and --change at the same time')
         raise error.Abort(msg)
     elif revs and terse:
         msg = _('cannot use --terse with --rev')
         raise error.Abort(msg)
     elif change:
         repo = scmutil.unhidehashlikerevs(repo, [change], 'nowarn')
         ctx2 = scmutil.revsingle(repo, change, None)
         ctx1 = ctx2.p1()
     else:
         repo = scmutil.unhidehashlikerevs(repo, revs, 'nowarn')
         ctx1, ctx2 = scmutil.revpair(repo, revs)
 
     if pats or ui.configbool('commands', 'status.relative'):
         cwd = repo.getcwd()
     else:
         cwd = ''
 
     if opts.get('print0'):
         end = '\0'
     else:
         end = '\n'
     copy = {}
     states = 'modified added removed deleted unknown ignored clean'.split()
     show = [k for k in states if opts.get(k)]
     if opts.get('all'):
         show += ui.quiet and (states[:4] + ['clean']) or states
 
     if not show:
         if ui.quiet:
             show = states[:4]
         else:
             show = states[:5]
 
     m = scmutil.match(ctx2, pats, opts)
     if terse:
         # we need to compute clean and unknown to terse
         stat = repo.status(ctx1.node(), ctx2.node(), m,
                            'ignored' in show or 'i' in terse,
                             clean=True, unknown=True,
                             listsubrepos=opts.get('subrepos'))
 
         stat = cmdutil.tersedir(stat, terse)
     else:
         stat = repo.status(ctx1.node(), ctx2.node(), m,
                            'ignored' in show, 'clean' in show,
                            'unknown' in show, opts.get('subrepos'))
 
     changestates = zip(states, pycompat.iterbytestr('MAR!?IC'), stat)
 
     if (opts.get('all') or opts.get('copies')
         or ui.configbool('ui', 'statuscopies')) and not opts.get('no_status'):
         copy = copies.pathcopies(ctx1, ctx2, m)
 
     ui.pager('status')
     fm = ui.formatter('status', opts)
     fmt = '%s' + end
     showchar = not opts.get('no_status')
 
     for state, char, files in changestates:
         if state in show:
             label = 'status.' + state
             for f in files:
                 fm.startitem()
                 fm.context(ctx=ctx2)
                 fm.condwrite(showchar, 'status', '%s ', char, label=label)
                 fm.write('path', fmt, repo.pathto(f, cwd), label=label)
                 if f in copy:
                     fm.write("copy", '  %s' + end, repo.pathto(copy[f], cwd),
                              label='status.copied')
 
     if ((ui.verbose or ui.configbool('commands', 'status.verbose'))
         and not ui.plain()):
         cmdutil.morestatus(repo, fm)
     fm.end()
 
 @command('^summary|sum',
     [('', 'remote', None, _('check for push and pull'))],
     '[--remote]',
     intents={INTENT_READONLY})
 def summary(ui, repo, **opts):
     """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.
     """
 
     opts = pycompat.byteskwargs(opts)
     ui.pager('summary')
     ctx = repo[None]
     parents = ctx.parents()
     pnode = parents[0].node()
     marks = []
 
     ms = None
     try:
         ms = mergemod.mergestate.read(repo)
     except error.UnsupportedMergeRecords as e:
         s = ' '.join(e.recordtypes)
         ui.warn(
             _('warning: merge state has unsupported record types: %s\n') % s)
         unresolved = []
     else:
         unresolved = list(ms.unresolved())
 
     for p in parents:
         # label with log.changeset (instead of log.parent) since this
         # shows a working directory parent *changeset*:
         # i18n: column positioning for "hg summary"
         ui.write(_('parent: %d:%s ') % (p.rev(), p),
                  label=logcmdutil.changesetlabels(p))
         ui.write(' '.join(p.tags()), label='log.tag')
         if p.bookmarks():
             marks.extend(p.bookmarks())
         if p.rev() == -1:
             if not len(repo):
                 ui.write(_(' (empty repository)'))
             else:
                 ui.write(_(' (no revision checked out)'))
         if p.obsolete():
             ui.write(_(' (obsolete)'))
         if p.isunstable():
             instabilities = (ui.label(instability, 'trouble.%s' % instability)
                              for instability in p.instabilities())
             ui.write(' ('
                      + ', '.join(instabilities)
                      + ')')
         ui.write('\n')
         if p.description():
             ui.status(' ' + p.description().splitlines()[0].strip() + '\n',
                       label='log.summary')
 
     branch = ctx.branch()
     bheads = repo.branchheads(branch)
     # i18n: column positioning for "hg summary"
     m = _('branch: %s\n') % branch
     if branch != 'default':
         ui.write(m, label='log.branch')
     else:
         ui.status(m, label='log.branch')
 
     if marks:
         active = repo._activebookmark
         # i18n: column positioning for "hg summary"
         ui.write(_('bookmarks:'), label='log.bookmark')
         if active is not None:
             if active in marks:
                 ui.write(' *' + active, label=bookmarks.activebookmarklabel)
                 marks.remove(active)
             else:
                 ui.write(' [%s]' % active, label=bookmarks.activebookmarklabel)
         for m in marks:
             ui.write(' ' + m, label='log.bookmark')
         ui.write('\n', label='log.bookmark')
 
     status = repo.status(unknown=True)
 
     c = repo.dirstate.copies()
     copied, renamed = [], []
     for d, s in c.iteritems():
         if s in status.removed:
             status.removed.remove(s)
             renamed.append(d)
         else:
             copied.append(d)
         if d in status.added:
             status.added.remove(d)
 
     subs = [s for s in ctx.substate if ctx.sub(s).dirty()]
 
     labels = [(ui.label(_('%d modified'), 'status.modified'), status.modified),
               (ui.label(_('%d added'), 'status.added'), status.added),
               (ui.label(_('%d removed'), 'status.removed'), status.removed),
               (ui.label(_('%d renamed'), 'status.copied'), renamed),
               (ui.label(_('%d copied'), 'status.copied'), copied),
               (ui.label(_('%d deleted'), 'status.deleted'), status.deleted),
               (ui.label(_('%d unknown'), 'status.unknown'), status.unknown),
               (ui.label(_('%d unresolved'), 'resolve.unresolved'), unresolved),
               (ui.label(_('%d subrepos'), 'status.modified'), subs)]
     t = []
     for l, s in labels:
         if s:
             t.append(l % len(s))
 
     t = ', '.join(t)
     cleanworkdir = False
 
     if repo.vfs.exists('graftstate'):
         t += _(' (graft in progress)')
     if repo.vfs.exists('updatestate'):
         t += _(' (interrupted update)')
     elif len(parents) > 1:
         t += _(' (merge)')
     elif branch != parents[0].branch():
         t += _(' (new branch)')
     elif (parents[0].closesbranch() and
           pnode in repo.branchheads(branch, closed=True)):
         t += _(' (head closed)')
     elif not (status.modified or status.added or status.removed or renamed or
               copied or subs):
         t += _(' (clean)')
         cleanworkdir = True
     elif pnode not in bheads:
         t += _(' (new branch head)')
 
     if parents:
         pendingphase = max(p.phase() for p in parents)
     else:
         pendingphase = phases.public
 
     if pendingphase > phases.newcommitphase(ui):
         t += ' (%s)' % phases.phasenames[pendingphase]
 
     if cleanworkdir:
         # i18n: column positioning for "hg summary"
         ui.status(_('commit: %s\n') % t.strip())
     else:
         # i18n: column positioning for "hg summary"
         ui.write(_('commit: %s\n') % t.strip())
 
     # all ancestors of branch heads - all ancestors of parent = new csets
     new = len(repo.changelog.findmissing([pctx.node() for pctx in parents],
                                          bheads))
 
     if new == 0:
         # i18n: column positioning for "hg summary"
         ui.status(_('update: (current)\n'))
     elif pnode not in bheads:
         # i18n: column positioning for "hg summary"
         ui.write(_('update: %d new changesets (update)\n') % new)
     else:
         # i18n: column positioning for "hg summary"
         ui.write(_('update: %d new changesets, %d branch heads (merge)\n') %
                  (new, len(bheads)))
 
     t = []
     draft = len(repo.revs('draft()'))
     if draft:
         t.append(_('%d draft') % draft)
     secret = len(repo.revs('secret()'))
     if secret:
         t.append(_('%d secret') % secret)
 
     if draft or secret:
         ui.status(_('phases: %s\n') % ', '.join(t))
 
     if obsolete.isenabled(repo, obsolete.createmarkersopt):
         for trouble in ("orphan", "contentdivergent", "phasedivergent"):
             numtrouble = len(repo.revs(trouble + "()"))
             # We write all the possibilities to ease translation
             troublemsg = {
                "orphan": _("orphan: %d changesets"),
                "contentdivergent": _("content-divergent: %d changesets"),
                "phasedivergent": _("phase-divergent: %d changesets"),
             }
             if numtrouble > 0:
                 ui.status(troublemsg[trouble] % numtrouble + "\n")
 
     cmdutil.summaryhooks(ui, repo)
 
     if opts.get('remote'):
         needsincoming, needsoutgoing = True, True
     else:
         needsincoming, needsoutgoing = False, False
         for i, o in cmdutil.summaryremotehooks(ui, repo, opts, None):
             if i:
                 needsincoming = True
             if o:
                 needsoutgoing = True
         if not needsincoming and not needsoutgoing:
             return
 
     def getincoming():
         source, branches = hg.parseurl(ui.expandpath('default'))
         sbranch = branches[0]
         try:
             other = hg.peer(repo, {}, source)
         except error.RepoError:
             if opts.get('remote'):
                 raise
             return source, sbranch, None, None, None
         revs, checkout = hg.addbranchrevs(repo, other, branches, None)
         if revs:
             revs = [other.lookup(rev) for rev in revs]
         ui.debug('comparing with %s\n' % util.hidepassword(source))
         repo.ui.pushbuffer()
         commoninc = discovery.findcommonincoming(repo, other, heads=revs)
         repo.ui.popbuffer()
         return source, sbranch, other, commoninc, commoninc[1]
 
     if needsincoming:
         source, sbranch, sother, commoninc, incoming = getincoming()
     else:
         source = sbranch = sother = commoninc = incoming = None
 
     def getoutgoing():
         dest, branches = hg.parseurl(ui.expandpath('default-push', 'default'))
         dbranch = branches[0]
         revs, checkout = hg.addbranchrevs(repo, repo, branches, None)
         if source != dest:
             try:
                 dother = hg.peer(repo, {}, dest)
             except error.RepoError:
                 if opts.get('remote'):
                     raise
                 return dest, dbranch, None, None
             ui.debug('comparing with %s\n' % util.hidepassword(dest))
         elif sother is None:
             # there is no explicit destination peer, but source one is invalid
             return dest, dbranch, None, None
         else:
             dother = sother
         if (source != dest or (sbranch is not None and sbranch != dbranch)):
             common = None
         else:
             common = commoninc
         if revs:
             revs = [repo.lookup(rev) for rev in revs]
         repo.ui.pushbuffer()
         outgoing = discovery.findcommonoutgoing(repo, dother, onlyheads=revs,
                                                 commoninc=common)
         repo.ui.popbuffer()
         return dest, dbranch, dother, outgoing
 
     if needsoutgoing:
         dest, dbranch, dother, outgoing = getoutgoing()
     else:
         dest = dbranch = dother = outgoing = None
 
     if opts.get('remote'):
         t = []
         if incoming:
             t.append(_('1 or more incoming'))
         o = outgoing.missing
         if o:
             t.append(_('%d outgoing') % len(o))
         other = dother or sother
         if 'bookmarks' in other.listkeys('namespaces'):
             counts = bookmarks.summary(repo, other)
             if counts[0] > 0:
                 t.append(_('%d incoming bookmarks') % counts[0])
             if counts[1] > 0:
                 t.append(_('%d outgoing bookmarks') % counts[1])
 
         if t:
             # i18n: column positioning for "hg summary"
             ui.write(_('remote: %s\n') % (', '.join(t)))
         else:
             # i18n: column positioning for "hg summary"
             ui.status(_('remote: (synced)\n'))
 
     cmdutil.summaryremotehooks(ui, repo, opts,
                                ((source, sbranch, sother, commoninc),
                                 (dest, dbranch, dother, outgoing)))
 
 @command('tag',
     [('f', 'force', None, _('force tag')),
     ('l', 'local', None, _('make the tag local')),
     ('r', 'rev', '', _('revision to tag'), _('REV')),
     ('', 'remove', None, _('remove a tag')),
     # -l/--local is already there, commitopts cannot be used
     ('e', 'edit', None, _('invoke editor on commit messages')),
     ('m', 'message', '', _('use text as commit message'), _('TEXT')),
     ] + commitopts2,
     _('[-f] [-l] [-m TEXT] [-d DATE] [-u USER] [-r REV] NAME...'))
 def tag(ui, repo, name1, *names, **opts):
     """add one or more tags for the current or given revision
 
     Name a particular revision using <name>.
 
     Tags are used to name particular revisions of the repository and are
     very useful to compare different revisions, to go back to significant
     earlier versions or to mark branch points as releases, etc. Changing
     an existing tag is normally disallowed; use -f/--force to override.
 
     If no revision is given, the parent of the working directory is
     used.
 
     To facilitate version control, distribution, and merging of tags,
     they are stored as a file named ".hgtags" which is managed similarly
     to other project files and can be hand-edited if necessary. This
     also means that tagging creates a new commit. The file
     ".hg/localtags" is used for local tags (not shared among
     repositories).
 
     Tag commits are usually made at the head of a branch. If the parent
     of the working directory is not a branch head, :hg:`tag` aborts; use
     -f/--force to force the tag commit to be based on a non-head
     changeset.
 
     See :hg:`help dates` for a list of formats valid for -d/--date.
 
     Since tag names have priority over branch names during revision
     lookup, using an existing branch name as a tag name is discouraged.
 
     Returns 0 on success.
     """
     opts = pycompat.byteskwargs(opts)
     with repo.wlock(), repo.lock():
         rev_ = "."
         names = [t.strip() for t in (name1,) + names]
         if len(names) != len(set(names)):
             raise error.Abort(_('tag names must be unique'))
         for n in names:
             scmutil.checknewlabel(repo, n, 'tag')
             if not n:
                 raise error.Abort(_('tag names cannot consist entirely of '
                                    'whitespace'))
         if opts.get('rev') and opts.get('remove'):
             raise error.Abort(_("--rev and --remove are incompatible"))
         if opts.get('rev'):
             rev_ = opts['rev']
         message = opts.get('message')
         if opts.get('remove'):
             if opts.get('local'):
                 expectedtype = 'local'
             else:
                 expectedtype = 'global'
 
             for n in names:
                 if not repo.tagtype(n):
                     raise error.Abort(_("tag '%s' does not exist") % n)
                 if repo.tagtype(n) != expectedtype:
                     if expectedtype == 'global':
                         raise error.Abort(_("tag '%s' is not a global tag") % n)
                     else:
                         raise error.Abort(_("tag '%s' is not a local tag") % n)
             rev_ = 'null'
             if not message:
                 # we don't translate commit messages
                 message = 'Removed tag %s' % ', '.join(names)
         elif not opts.get('force'):
             for n in names:
                 if n in repo.tags():
                     raise error.Abort(_("tag '%s' already exists "
                                        "(use -f to force)") % n)
         if not opts.get('local'):
             p1, p2 = repo.dirstate.parents()
             if p2 != nullid:
                 raise error.Abort(_('uncommitted merge'))
             bheads = repo.branchheads()
             if not opts.get('force') and bheads and p1 not in bheads:
                 raise error.Abort(_('working directory is not at a branch head '
                                     '(use -f to force)'))
         node = scmutil.revsingle(repo, rev_).node()
 
         if not message:
             # we don't translate commit messages
             message = ('Added tag %s for changeset %s' %
                        (', '.join(names), short(node)))
 
         date = opts.get('date')
         if date:
             date = dateutil.parsedate(date)
 
         if opts.get('remove'):
             editform = 'tag.remove'
         else:
             editform = 'tag.add'
         editor = cmdutil.getcommiteditor(editform=editform,
                                          **pycompat.strkwargs(opts))
 
         # don't allow tagging the null rev
         if (not opts.get('remove') and
             scmutil.revsingle(repo, rev_).rev() == nullrev):
             raise error.Abort(_("cannot tag null revision"))
 
         tagsmod.tag(repo, names, node, message, opts.get('local'),
                     opts.get('user'), date, editor=editor)
 
 @command('tags', formatteropts, '', intents={INTENT_READONLY})
 def tags(ui, repo, **opts):
     """list repository tags
 
     This lists both regular and local tags. When the -v/--verbose
     switch is used, a third column "local" is printed for local tags.
     When the -q/--quiet switch is used, only the tag name is printed.
 
     Returns 0 on success.
     """
 
     opts = pycompat.byteskwargs(opts)
     ui.pager('tags')
     fm = ui.formatter('tags', opts)
     contexthint = fm.contexthint('tag rev node type')
     hexfunc = fm.hexfunc
     tagtype = ""
 
     for t, n in reversed(repo.tagslist()):
         hn = hexfunc(n)
         label = 'tags.normal'
         tagtype = ''
         if repo.tagtype(t) == 'local':
             label = 'tags.local'
             tagtype = 'local'
 
         fm.startitem()
         if 'ctx' in contexthint:
             fm.context(ctx=repo[n])
         fm.write('tag', '%s', t, label=label)
         fmt = " " * (30 - encoding.colwidth(t)) + ' %5d:%s'
         fm.condwrite(not ui.quiet, 'rev node', fmt,
                      repo.changelog.rev(n), hn, label=label)
         fm.condwrite(ui.verbose and tagtype, 'type', ' %s',
                      tagtype, label=label)
         fm.plain('\n')
     fm.end()
 
 @command('tip',
     [('p', 'patch', None, _('show patch')),
     ('g', 'git', None, _('use git extended diff format')),
     ] + templateopts,
     _('[-p] [-g]'))
 def tip(ui, repo, **opts):
     """show the tip revision (DEPRECATED)
 
     The tip revision (usually just called the tip) is the changeset
     most recently added to the repository (and therefore the most
     recently changed head).
 
     If you have just made a commit, that commit will be the tip. If
     you have just pulled changes from another repository, the tip of
     that repository becomes the current tip. The "tip" tag is special
     and cannot be renamed or assigned to a different changeset.
 
     This command is deprecated, please use :hg:`heads` instead.
 
     Returns 0 on success.
     """
     opts = pycompat.byteskwargs(opts)
     displayer = logcmdutil.changesetdisplayer(ui, repo, opts)
     displayer.show(repo['tip'])
     displayer.close()
 
 @command('unbundle',
     [('u', 'update', None,
      _('update to new branch head if changesets were unbundled'))],
     _('[-u] FILE...'))
 def unbundle(ui, repo, fname1, *fnames, **opts):
     """apply one or more bundle files
 
     Apply one or more bundle files generated by :hg:`bundle`.
 
     Returns 0 on success, 1 if an update has unresolved files.
     """
     fnames = (fname1,) + fnames
 
     with repo.lock():
         for fname in fnames:
             f = hg.openpath(ui, fname)
             gen = exchange.readbundle(ui, f, fname)
             if isinstance(gen, streamclone.streamcloneapplier):
                 raise error.Abort(
                         _('packed bundles cannot be applied with '
                           '"hg unbundle"'),
                         hint=_('use "hg debugapplystreamclonebundle"'))
             url = 'bundle:' + fname
             try:
                 txnname = 'unbundle'
                 if not isinstance(gen, bundle2.unbundle20):
                     txnname = 'unbundle\n%s' % util.hidepassword(url)
                 with repo.transaction(txnname) as tr:
                     op = bundle2.applybundle(repo, gen, tr, source='unbundle',
                                              url=url)
             except error.BundleUnknownFeatureError as exc:
                 raise error.Abort(
                     _('%s: unknown bundle feature, %s') % (fname, exc),
                     hint=_("see https://mercurial-scm.org/"
                            "wiki/BundleFeature for more "
                            "information"))
             modheads = bundle2.combinechangegroupresults(op)
 
     return postincoming(ui, repo, modheads, opts.get(r'update'), None, None)
 
 @command('^update|up|checkout|co',
     [('C', 'clean', None, _('discard uncommitted changes (no backup)')),
     ('c', 'check', None, _('require clean working directory')),
     ('m', 'merge', None, _('merge uncommitted changes')),
     ('d', 'date', '', _('tipmost revision matching date'), _('DATE')),
     ('r', 'rev', '', _('revision'), _('REV'))
      ] + mergetoolopts,
     _('[-C|-c|-m] [-d DATE] [[-r] REV]'))
 def update(ui, repo, node=None, **opts):
     """update working directory (or switch revisions)
 
     Update the repository's working directory to the specified
     changeset. If no changeset is specified, update to the tip of the
     current named branch and move the active bookmark (see :hg:`help
     bookmarks`).
 
     Update sets the working directory's parent revision to the specified
     changeset (see :hg:`help parents`).
 
     If the changeset is not a descendant or ancestor of the working
     directory's parent and there are uncommitted changes, the update is
     aborted. With the -c/--check option, the working directory is checked
     for uncommitted changes; if none are found, the working directory is
     updated to the specified changeset.
 
     .. container:: verbose
 
       The -C/--clean, -c/--check, and -m/--merge options control what
       happens if the working directory contains uncommitted changes.
       At most of one of them can be specified.
 
       1. If no option is specified, and if
          the requested changeset is an ancestor or descendant of
          the working directory's parent, the uncommitted changes
          are merged into the requested changeset and the merged
          result is left uncommitted. If the requested changeset is
          not an ancestor or descendant (that is, it is on another
          branch), the update is aborted and the uncommitted changes
          are preserved.
 
       2. With the -m/--merge option, the update is allowed even if the
          requested changeset is not an ancestor or descendant of
          the working directory's parent.
 
       3. With the -c/--check option, the update is aborted and the
          uncommitted changes are preserved.
 
       4. With the -C/--clean option, uncommitted changes are discarded and
          the working directory is updated to the requested changeset.
 
     To cancel an uncommitted merge (and lose your changes), use
     :hg:`merge --abort`.
 
     Use null as the changeset to remove the working directory (like
     :hg:`clone -U`).
 
     If you want to revert just one file to an older revision, use
     :hg:`revert [-r REV] NAME`.
 
     See :hg:`help dates` for a list of formats valid for -d/--date.
 
     Returns 0 on success, 1 if there are unresolved files.
     """
     rev = opts.get(r'rev')
     date = opts.get(r'date')
     clean = opts.get(r'clean')
     check = opts.get(r'check')
     merge = opts.get(r'merge')
     if rev and node:
         raise error.Abort(_("please specify just one revision"))
 
     if ui.configbool('commands', 'update.requiredest'):
         if not node and not rev and not date:
             raise error.Abort(_('you must specify a destination'),
                               hint=_('for example: hg update ".::"'))
 
     if rev is None or rev == '':
         rev = node
 
     if date and rev is not None:
         raise error.Abort(_("you can't specify a revision and a date"))
 
     if len([x for x in (clean, check, merge) if x]) > 1:
         raise error.Abort(_("can only specify one of -C/--clean, -c/--check, "
                             "or -m/--merge"))
 
     updatecheck = None
     if check:
         updatecheck = 'abort'
     elif merge:
         updatecheck = 'none'
 
     with repo.wlock():
         cmdutil.clearunfinished(repo)
 
         if date:
             rev = cmdutil.finddate(ui, repo, date)
 
         # if we defined a bookmark, we have to remember the original name
         brev = rev
         if rev:
             repo = scmutil.unhidehashlikerevs(repo, [rev], 'nowarn')
         ctx = scmutil.revsingle(repo, rev, rev)
         rev = ctx.rev()
         hidden = ctx.hidden()
         overrides = {('ui', 'forcemerge'): opts.get(r'tool', '')}
         with ui.configoverride(overrides, 'update'):
             ret = hg.updatetotally(ui, repo, rev, brev, clean=clean,
                                    updatecheck=updatecheck)
         if hidden:
             ctxstr = ctx.hex()[:12]
             ui.warn(_("updated to hidden changeset %s\n") % ctxstr)
 
             if ctx.obsolete():
                 obsfatemsg = obsutil._getfilteredreason(repo, ctxstr, ctx)
                 ui.warn("(%s)\n" % obsfatemsg)
         return ret
 
 @command('verify', [])
 def verify(ui, repo):
     """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.
     """
     return hg.verify(repo)
 
 @command('version', [] + formatteropts, norepo=True,
          intents={INTENT_READONLY})
 def version_(ui, **opts):
     """output version and copyright information"""
     opts = pycompat.byteskwargs(opts)
     if ui.verbose:
         ui.pager('version')
     fm = ui.formatter("version", opts)
     fm.startitem()
     fm.write("ver", _("Mercurial Distributed SCM (version %s)\n"),
              util.version())
     license = _(
         "(see https://mercurial-scm.org for more information)\n"
         "\nCopyright (C) 2005-2018 Matt Mackall and others\n"
         "This is free software; see the source for copying conditions. "
         "There is NO\nwarranty; "
         "not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n"
     )
     if not ui.quiet:
         fm.plain(license)
 
     if ui.verbose:
         fm.plain(_("\nEnabled extensions:\n\n"))
     # format names and versions into columns
     names = []
     vers = []
     isinternals = []
     for name, module in extensions.extensions():
         names.append(name)
         vers.append(extensions.moduleversion(module) or None)
         isinternals.append(extensions.ismoduleinternal(module))
     fn = fm.nested("extensions", tmpl='{name}\n')
     if names:
         namefmt = "  %%-%ds  " % max(len(n) for n in names)
         places = [_("external"), _("internal")]
         for n, v, p in zip(names, vers, isinternals):
             fn.startitem()
             fn.condwrite(ui.verbose, "name", namefmt, n)
             if ui.verbose:
                 fn.plain("%s  " % places[p])
             fn.data(bundled=p)
             fn.condwrite(ui.verbose and v, "ver", "%s", v)
             if ui.verbose:
                 fn.plain("\n")
     fn.end()
     fm.end()
 
 def loadcmdtable(ui, name, cmdtable):
     """Load command functions from specified cmdtable
     """
     overrides = [cmd for cmd in cmdtable if cmd in table]
     if overrides:
         ui.warn(_("extension '%s' overrides commands: %s\n")
                 % (name, " ".join(overrides)))
     table.update(cmdtable)

mercurial/configitems.py

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

mercurial/help/config.txt

@@ -1,2696 +1,2706 b''
 The Mercurial system uses a set of configuration files to control
 aspects of its behavior.
 
 Troubleshooting
 ===============
 
 If you're having problems with your configuration,
 :hg:`config --debug` can help you understand what is introducing
 a setting into your environment.
 
 See :hg:`help config.syntax` and :hg:`help config.files`
 for information about how and where to override things.
 
 Structure
 =========
 
 The configuration files use a simple ini-file format. A configuration
 file consists of sections, led by a ``[section]`` header and followed
 by ``name = value`` entries::
 
   [ui]
   username = Firstname Lastname <[e-mail]>
   verbose = True
 
 The above entries will be referred to as ``ui.username`` and
 ``ui.verbose``, respectively. See :hg:`help config.syntax`.
 
 Files
 =====
 
 Mercurial reads configuration data from several files, if they exist.
 These files do not exist by default and you will have to create the
 appropriate configuration files yourself:
 
 Local configuration is put into the per-repository ``<repo>/.hg/hgrc`` file.
 
 Global configuration like the username setting is typically put into:
 
 .. container:: windows
 
   - ``%USERPROFILE%\mercurial.ini`` (on Windows)
 
 .. container:: unix.plan9
 
   - ``$HOME/.hgrc`` (on Unix, Plan9)
 
 The names of these files depend on the system on which Mercurial is
 installed. ``*.rc`` files from a single directory are read in
 alphabetical order, later ones overriding earlier ones. Where multiple
 paths are given below, settings from earlier paths override later
 ones.
 
 .. container:: verbose.unix
 
   On Unix, the following files are consulted:
 
   - ``<repo>/.hg/hgrc`` (per-repository)
   - ``$HOME/.hgrc`` (per-user)
   - ``${XDG_CONFIG_HOME:-$HOME/.config}/hg/hgrc`` (per-user)
   - ``<install-root>/etc/mercurial/hgrc`` (per-installation)
   - ``<install-root>/etc/mercurial/hgrc.d/*.rc`` (per-installation)
   - ``/etc/mercurial/hgrc`` (per-system)
   - ``/etc/mercurial/hgrc.d/*.rc`` (per-system)
   - ``<internal>/default.d/*.rc`` (defaults)
 
 .. container:: verbose.windows
 
   On Windows, the following files are consulted:
 
   - ``<repo>/.hg/hgrc`` (per-repository)
   - ``%USERPROFILE%\.hgrc`` (per-user)
   - ``%USERPROFILE%\Mercurial.ini`` (per-user)
   - ``%HOME%\.hgrc`` (per-user)
   - ``%HOME%\Mercurial.ini`` (per-user)
   - ``HKEY_LOCAL_MACHINE\SOFTWARE\Mercurial`` (per-installation)
   - ``<install-dir>\hgrc.d\*.rc`` (per-installation)
   - ``<install-dir>\Mercurial.ini`` (per-installation)
   - ``<internal>/default.d/*.rc`` (defaults)
 
   .. note::
 
    The registry key ``HKEY_LOCAL_MACHINE\SOFTWARE\Wow6432Node\Mercurial``
    is used when running 32-bit Python on 64-bit Windows.
 
 .. container:: windows
 
   On Windows 9x, ``%HOME%`` is replaced by ``%APPDATA%``.
 
 .. container:: verbose.plan9
 
   On Plan9, the following files are consulted:
 
   - ``<repo>/.hg/hgrc`` (per-repository)
   - ``$home/lib/hgrc`` (per-user)
   - ``<install-root>/lib/mercurial/hgrc`` (per-installation)
   - ``<install-root>/lib/mercurial/hgrc.d/*.rc`` (per-installation)
   - ``/lib/mercurial/hgrc`` (per-system)
   - ``/lib/mercurial/hgrc.d/*.rc`` (per-system)
   - ``<internal>/default.d/*.rc`` (defaults)
 
 Per-repository configuration options only apply in a
 particular repository. This file is not version-controlled, and
 will not get transferred during a "clone" operation. Options in
 this file override options in all other configuration files.
 
 .. container:: unix.plan9
 
   On Plan 9 and Unix, most of this file will be ignored if it doesn't
   belong to a trusted user or to a trusted group. See
   :hg:`help config.trusted` for more details.
 
 Per-user configuration file(s) are for the user running Mercurial.  Options
 in these files apply to all Mercurial commands executed by this user in any
 directory. Options in these files override per-system and per-installation
 options.
 
 Per-installation configuration files are searched for in the
 directory where Mercurial is installed. ``<install-root>`` is the
 parent directory of the **hg** executable (or symlink) being run.
 
 .. container:: unix.plan9
 
   For example, if installed in ``/shared/tools/bin/hg``, Mercurial
   will look in ``/shared/tools/etc/mercurial/hgrc``. Options in these
   files apply to all Mercurial commands executed by any user in any
   directory.
 
 Per-installation configuration files are for the system on
 which Mercurial is running. Options in these files apply to all
 Mercurial commands executed by any user in any directory. Registry
 keys contain PATH-like strings, every part of which must reference
 a ``Mercurial.ini`` file or be a directory where ``*.rc`` files will
 be read.  Mercurial checks each of these locations in the specified
 order until one or more configuration files are detected.
 
 Per-system configuration files are for the system on which Mercurial
 is running. Options in these files apply to all Mercurial commands
 executed by any user in any directory. Options in these files
 override per-installation options.
 
 Mercurial comes with some default configuration. The default configuration
 files are installed with Mercurial and will be overwritten on upgrades. Default
 configuration files should never be edited by users or administrators but can
 be overridden in other configuration files. So far the directory only contains
 merge tool configuration but packagers can also put other default configuration
 there.
 
 Syntax
 ======
 
 A configuration file consists of sections, led by a ``[section]`` header
 and followed by ``name = value`` entries (sometimes called
 ``configuration keys``)::
 
     [spam]
     eggs=ham
     green=
        eggs
 
 Each line contains one entry. If the lines that follow are indented,
 they are treated as continuations of that entry. Leading whitespace is
 removed from values. Empty lines are skipped. Lines beginning with
 ``#`` or ``;`` are ignored and may be used to provide comments.
 
 Configuration keys can be set multiple times, in which case Mercurial
 will use the value that was configured last. As an example::
 
     [spam]
     eggs=large
     ham=serrano
     eggs=small
 
 This would set the configuration key named ``eggs`` to ``small``.
 
 It is also possible to define a section multiple times. A section can
 be redefined on the same and/or on different configuration files. For
 example::
 
     [foo]
     eggs=large
     ham=serrano
     eggs=small
 
     [bar]
     eggs=ham
     green=
        eggs
 
     [foo]
     ham=prosciutto
     eggs=medium
     bread=toasted
 
 This would set the ``eggs``, ``ham``, and ``bread`` configuration keys
 of the ``foo`` section to ``medium``, ``prosciutto``, and ``toasted``,
 respectively. As you can see there only thing that matters is the last
 value that was set for each of the configuration keys.
 
 If a configuration key is set multiple times in different
 configuration files the final value will depend on the order in which
 the different configuration files are read, with settings from earlier
 paths overriding later ones as described on the ``Files`` section
 above.
 
 A line of the form ``%include file`` will include ``file`` into the
 current configuration file. The inclusion is recursive, which means
 that included files can include other files. Filenames are relative to
 the configuration file in which the ``%include`` directive is found.
 Environment variables and ``~user`` constructs are expanded in
 ``file``. This lets you do something like::
 
   %include ~/.hgrc.d/$HOST.rc
 
 to include a different configuration file on each computer you use.
 
 A line with ``%unset name`` will remove ``name`` from the current
 section, if it has been set previously.
 
 The values are either free-form text strings, lists of text strings,
 or Boolean values. Boolean values can be set to true using any of "1",
 "yes", "true", or "on" and to false using "0", "no", "false", or "off"
 (all case insensitive).
 
 List values are separated by whitespace or comma, except when values are
 placed in double quotation marks::
 
   allow_read = "John Doe, PhD", brian, betty
 
 Quotation marks can be escaped by prefixing them with a backslash. Only
 quotation marks at the beginning of a word is counted as a quotation
 (e.g., ``foo"bar baz`` is the list of ``foo"bar`` and ``baz``).
 
 Sections
 ========
 
 This section describes the different sections that may appear in a
 Mercurial configuration file, the purpose of each section, its possible
 keys, and their possible values.
 
 ``alias``
 ---------
 
 Defines command aliases.
 
 Aliases allow you to define your own commands in terms of other
 commands (or aliases), optionally including arguments. Positional
 arguments in the form of ``$1``, ``$2``, etc. in the alias definition
 are expanded by Mercurial before execution. Positional arguments not
 already used by ``$N`` in the definition are put at the end of the
 command to be executed.
 
 Alias definitions consist of lines of the form::
 
     <alias> = <command> [<argument>]...
 
 For example, this definition::
 
     latest = log --limit 5
 
 creates a new command ``latest`` that shows only the five most recent
 changesets. You can define subsequent aliases using earlier ones::
 
     stable5 = latest -b stable
 
 .. note::
 
    It is possible to create aliases with the same names as
    existing commands, which will then override the original
    definitions. This is almost always a bad idea!
 
 An alias can start with an exclamation point (``!``) to make it a
 shell alias. A shell alias is executed with the shell and will let you
 run arbitrary commands. As an example, ::
 
    echo = !echo $@
 
 will let you do ``hg echo foo`` to have ``foo`` printed in your
 terminal. A better example might be::
 
    purge = !$HG status --no-status --unknown -0 re: | xargs -0 rm -f
 
 which will make ``hg purge`` delete all unknown files in the
 repository in the same manner as the purge extension.
 
 Positional arguments like ``$1``, ``$2``, etc. in the alias definition
 expand to the command arguments. Unmatched arguments are
 removed. ``$0`` expands to the alias name and ``$@`` expands to all
 arguments separated by a space. ``"$@"`` (with quotes) expands to all
 arguments quoted individually and separated by a space. These expansions
 happen before the command is passed to the shell.
 
 Shell aliases are executed in an environment where ``$HG`` expands to
 the path of the Mercurial that was used to execute the alias. This is
 useful when you want to call further Mercurial commands in a shell
 alias, as was done above for the purge alias. In addition,
 ``$HG_ARGS`` expands to the arguments given to Mercurial. In the ``hg
 echo foo`` call above, ``$HG_ARGS`` would expand to ``echo foo``.
 
 .. note::
 
    Some global configuration options such as ``-R`` are
    processed before shell aliases and will thus not be passed to
    aliases.
 
 
 ``annotate``
 ------------
 
 Settings used when displaying file annotations. All values are
 Booleans and default to False. See :hg:`help config.diff` for
 related options for the diff command.
 
 ``ignorews``
     Ignore white space when comparing lines.
 
 ``ignorewseol``
     Ignore white space at the end of a line when comparing lines.
 
 ``ignorewsamount``
     Ignore changes in the amount of white space.
 
 ``ignoreblanklines``
     Ignore changes whose lines are all blank.
 
 
 ``auth``
 --------
 
 Authentication credentials and other authentication-like configuration
 for HTTP connections. This section allows you to store usernames and
 passwords for use when logging *into* HTTP servers. See
 :hg:`help config.web` if you want to configure *who* can login to
 your HTTP server.
 
 The following options apply to all hosts.
 
 ``cookiefile``
     Path to a file containing HTTP cookie lines. Cookies matching a
     host will be sent automatically.
 
     The file format uses the Mozilla cookies.txt format, which defines cookies
     on their own lines. Each line contains 7 fields delimited by the tab
     character (domain, is_domain_cookie, path, is_secure, expires, name,
     value). For more info, do an Internet search for "Netscape cookies.txt
     format."
 
     Note: the cookies parser does not handle port numbers on domains. You
     will need to remove ports from the domain for the cookie to be recognized.
     This could result in a cookie being disclosed to an unwanted server.
 
     The cookies file is read-only.
 
 Other options in this section are grouped by name and have the following
 format::
 
     <name>.<argument> = <value>
 
 where ``<name>`` is used to group arguments into authentication
 entries. Example::
 
     foo.prefix = hg.intevation.de/mercurial
     foo.username = foo
     foo.password = bar
     foo.schemes = http https
 
     bar.prefix = secure.example.org
     bar.key = path/to/file.key
     bar.cert = path/to/file.cert
     bar.schemes = https
 
 Supported arguments:
 
 ``prefix``
     Either ``*`` or a URI prefix with or without the scheme part.
     The authentication entry with the longest matching prefix is used
     (where ``*`` matches everything and counts as a match of length
     1). If the prefix doesn't include a scheme, the match is performed
     against the URI with its scheme stripped as well, and the schemes
     argument, q.v., is then subsequently consulted.
 
 ``username``
     Optional. Username to authenticate with. If not given, and the
     remote site requires basic or digest authentication, the user will
     be prompted for it. Environment variables are expanded in the
     username letting you do ``foo.username = $USER``. If the URI
     includes a username, only ``[auth]`` entries with a matching
     username or without a username will be considered.
 
 ``password``
     Optional. Password to authenticate with. If not given, and the
     remote site requires basic or digest authentication, the user
     will be prompted for it.
 
 ``key``
     Optional. PEM encoded client certificate key file. Environment
     variables are expanded in the filename.
 
 ``cert``
     Optional. PEM encoded client certificate chain file. Environment
     variables are expanded in the filename.
 
 ``schemes``
     Optional. Space separated list of URI schemes to use this
     authentication entry with. Only used if the prefix doesn't include
     a scheme. Supported schemes are http and https. They will match
     static-http and static-https respectively, as well.
     (default: https)
 
 If no suitable authentication entry is found, the user is prompted
 for credentials as usual if required by the remote.
 
 ``color``
 ---------
 
 Configure the Mercurial color mode. For details about how to define your custom
 effect and style see :hg:`help color`.
 
 ``mode``
     String: control the method used to output color. One of ``auto``, ``ansi``,
     ``win32``, ``terminfo`` or ``debug``. In auto mode, Mercurial will
     use ANSI mode by default (or win32 mode prior to Windows 10) if it detects a
     terminal. Any invalid value will disable color.
 
 ``pagermode``
     String: optional override of ``color.mode`` used with pager.
 
     On some systems, terminfo mode may cause problems when using
     color with ``less -R`` as a pager program. less with the -R option
     will only display ECMA-48 color codes, and terminfo mode may sometimes
     emit codes that less doesn't understand. You can work around this by
     either using ansi mode (or auto mode), or by using less -r (which will
     pass through all terminal control codes, not just color control
     codes).
 
     On some systems (such as MSYS in Windows), the terminal may support
     a different color mode than the pager program.
 
 ``commands``
 ------------
 
 ``resolve.confirm``
     Confirm before re-merging all unresolved files when running
     :hg:`resolve --all`.
     (default: False)
 
+``resolve.mark-check``
+    Determines what level of checking :hg:`resolve --mark` will perform before
+    marking files as resolved. Valid values are ``none`, ``warn``, and
+    ``abort``. ``warn`` will output a warning listing the file(s) that still
+    have conflict markers in them, but will still mark everything resolved.
+    ``abort`` will output the same warning but will not mark things as resolved.
+    If --all is passed and this is set to ``abort``, only a warning will be
+    shown (an error will not be raised).
+    (default: ``none``)
+
 ``status.relative``
     Make paths in :hg:`status` output relative to the current directory.
     (default: False)
 
 ``status.terse``
     Default value for the --terse flag, which condenes status output.
     (default: empty)
 
 ``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``)
 
 ``update.requiredest``
     Require that the user pass a destination when running :hg:`update`.
     For example, :hg:`update .::` will be allowed, but a plain :hg:`update`
     will be disallowed.
     (default: False)
 
 ``committemplate``
 ------------------
 
 ``changeset``
     String: configuration in this section is used as the template to
     customize the text shown in the editor when committing.
 
 In addition to pre-defined template keywords, commit log specific one
 below can be used for customization:
 
 ``extramsg``
     String: Extra message (typically 'Leave message empty to abort
     commit.'). This may be changed by some commands or extensions.
 
 For example, the template configuration below shows as same text as
 one shown by default::
 
     [committemplate]
     changeset = {desc}\n\n
         HG: Enter commit message.  Lines beginning with 'HG:' are removed.
         HG: {extramsg}
         HG: --
         HG: user: {author}\n{ifeq(p2rev, "-1", "",
        "HG: branch merge\n")
        }HG: branch '{branch}'\n{if(activebookmark,
        "HG: bookmark '{activebookmark}'\n")   }{subrepos %
        "HG: subrepo {subrepo}\n"              }{file_adds %
        "HG: added {file}\n"                   }{file_mods %
        "HG: changed {file}\n"                 }{file_dels %
        "HG: removed {file}\n"                 }{if(files, "",
        "HG: no files changed\n")}
 
 ``diff()``
     String: show the diff (see :hg:`help templates` for detail)
 
 Sometimes it is helpful to show the diff of the changeset in the editor without
 having to prefix 'HG: ' to each line so that highlighting works correctly. For
 this, Mercurial provides a special string which will ignore everything below
 it::
 
      HG: ------------------------ >8 ------------------------
 
 For example, the template configuration below will show the diff below the
 extra message::
 
     [committemplate]
     changeset = {desc}\n\n
         HG: Enter commit message.  Lines beginning with 'HG:' are removed.
         HG: {extramsg}
         HG: ------------------------ >8 ------------------------
         HG: Do not touch the line above.
         HG: Everything below will be removed.
         {diff()}
 
 .. note::
 
    For some problematic encodings (see :hg:`help win32mbcs` for
    detail), this customization should be configured carefully, to
    avoid showing broken characters.
 
    For example, if a multibyte character ending with backslash (0x5c) is
    followed by the ASCII character 'n' in the customized template,
    the sequence of backslash and 'n' is treated as line-feed unexpectedly
    (and the multibyte character is broken, too).
 
 Customized template is used for commands below (``--edit`` may be
 required):
 
 - :hg:`backout`
 - :hg:`commit`
 - :hg:`fetch` (for merge commit only)
 - :hg:`graft`
 - :hg:`histedit`
 - :hg:`import`
 - :hg:`qfold`, :hg:`qnew` and :hg:`qrefresh`
 - :hg:`rebase`
 - :hg:`shelve`
 - :hg:`sign`
 - :hg:`tag`
 - :hg:`transplant`
 
 Configuring items below instead of ``changeset`` allows showing
 customized message only for specific actions, or showing different
 messages for each action.
 
 - ``changeset.backout`` for :hg:`backout`
 - ``changeset.commit.amend.merge`` for :hg:`commit --amend` on merges
 - ``changeset.commit.amend.normal`` for :hg:`commit --amend` on other
 - ``changeset.commit.normal.merge`` for :hg:`commit` on merges
 - ``changeset.commit.normal.normal`` for :hg:`commit` on other
 - ``changeset.fetch`` for :hg:`fetch` (impling merge commit)
 - ``changeset.gpg.sign`` for :hg:`sign`
 - ``changeset.graft`` for :hg:`graft`
 - ``changeset.histedit.edit`` for ``edit`` of :hg:`histedit`
 - ``changeset.histedit.fold`` for ``fold`` of :hg:`histedit`
 - ``changeset.histedit.mess`` for ``mess`` of :hg:`histedit`
 - ``changeset.histedit.pick`` for ``pick`` of :hg:`histedit`
 - ``changeset.import.bypass`` for :hg:`import --bypass`
 - ``changeset.import.normal.merge`` for :hg:`import` on merges
 - ``changeset.import.normal.normal`` for :hg:`import` on other
 - ``changeset.mq.qnew`` for :hg:`qnew`
 - ``changeset.mq.qfold`` for :hg:`qfold`
 - ``changeset.mq.qrefresh`` for :hg:`qrefresh`
 - ``changeset.rebase.collapse`` for :hg:`rebase --collapse`
 - ``changeset.rebase.merge`` for :hg:`rebase` on merges
 - ``changeset.rebase.normal`` for :hg:`rebase` on other
 - ``changeset.shelve.shelve`` for :hg:`shelve`
 - ``changeset.tag.add`` for :hg:`tag` without ``--remove``
 - ``changeset.tag.remove`` for :hg:`tag --remove`
 - ``changeset.transplant.merge`` for :hg:`transplant` on merges
 - ``changeset.transplant.normal`` for :hg:`transplant` on other
 
 These dot-separated lists of names are treated as hierarchical ones.
 For example, ``changeset.tag.remove`` customizes the commit message
 only for :hg:`tag --remove`, but ``changeset.tag`` customizes the
 commit message for :hg:`tag` regardless of ``--remove`` option.
 
 When the external editor is invoked for a commit, the corresponding
 dot-separated list of names without the ``changeset.`` prefix
 (e.g. ``commit.normal.normal``) is in the ``HGEDITFORM`` environment
 variable.
 
 In this section, items other than ``changeset`` can be referred from
 others. For example, the configuration to list committed files up
 below can be referred as ``{listupfiles}``::
 
     [committemplate]
     listupfiles = {file_adds %
        "HG: added {file}\n"     }{file_mods %
        "HG: changed {file}\n"   }{file_dels %
        "HG: removed {file}\n"   }{if(files, "",
        "HG: no files changed\n")}
 
 ``decode/encode``
 -----------------
 
 Filters for transforming files on checkout/checkin. This would
 typically be used for newline processing or other
 localization/canonicalization of files.
 
 Filters consist of a filter pattern followed by a filter command.
 Filter patterns are globs by default, rooted at the repository root.
 For example, to match any file ending in ``.txt`` in the root
 directory only, use the pattern ``*.txt``. To match any file ending
 in ``.c`` anywhere in the repository, use the pattern ``**.c``.
 For each file only the first matching filter applies.
 
 The filter command can start with a specifier, either ``pipe:`` or
 ``tempfile:``. If no specifier is given, ``pipe:`` is used by default.
 
 A ``pipe:`` command must accept data on stdin and return the transformed
 data on stdout.
 
 Pipe example::
 
   [encode]
   # uncompress gzip files on checkin to improve delta compression
   # note: not necessarily a good idea, just an example
   *.gz = pipe: gunzip
 
   [decode]
   # recompress gzip files when writing them to the working dir (we
   # can safely omit "pipe:", because it's the default)
   *.gz = gzip
 
 A ``tempfile:`` command is a template. The string ``INFILE`` is replaced
 with the name of a temporary file that contains the data to be
 filtered by the command. The string ``OUTFILE`` is replaced with the name
 of an empty temporary file, where the filtered data must be written by
 the command.
 
 .. container:: windows
 
    .. note::
 
      The tempfile mechanism is recommended for Windows systems,
      where the standard shell I/O redirection operators often have
      strange effects and may corrupt the contents of your files.
 
 This filter mechanism is used internally by the ``eol`` extension to
 translate line ending characters between Windows (CRLF) and Unix (LF)
 format. We suggest you use the ``eol`` extension for convenience.
 
 
 ``defaults``
 ------------
 
 (defaults are deprecated. Don't use them. Use aliases instead.)
 
 Use the ``[defaults]`` section to define command defaults, i.e. the
 default options/arguments to pass to the specified commands.
 
 The following example makes :hg:`log` run in verbose mode, and
 :hg:`status` show only the modified files, by default::
 
   [defaults]
   log = -v
   status = -m
 
 The actual commands, instead of their aliases, must be used when
 defining command defaults. The command defaults will also be applied
 to the aliases of the commands defined.
 
 
 ``diff``
 --------
 
 Settings used when displaying diffs. Everything except for ``unified``
 is a Boolean and defaults to False. See :hg:`help config.annotate`
 for related options for the annotate command.
 
 ``git``
     Use git extended diff format.
 
 ``nobinary``
     Omit git binary patches.
 
 ``nodates``
     Don't include dates in diff headers.
 
 ``noprefix``
     Omit 'a/' and 'b/' prefixes from filenames. Ignored in plain mode.
 
 ``showfunc``
     Show which function each change is in.
 
 ``ignorews``
     Ignore white space when comparing lines.
 
 ``ignorewsamount``
     Ignore changes in the amount of white space.
 
 ``ignoreblanklines``
     Ignore changes whose lines are all blank.
 
 ``unified``
     Number of lines of context to show.
 
 ``word-diff``
     Highlight changed words.
 
 ``email``
 ---------
 
 Settings for extensions that send email messages.
 
 ``from``
     Optional. Email address to use in "From" header and SMTP envelope
     of outgoing messages.
 
 ``to``
     Optional. Comma-separated list of recipients' email addresses.
 
 ``cc``
     Optional. Comma-separated list of carbon copy recipients'
     email addresses.
 
 ``bcc``
     Optional. Comma-separated list of blind carbon copy recipients'
     email addresses.
 
 ``method``
     Optional. Method to use to send email messages. If value is ``smtp``
     (default), use SMTP (see the ``[smtp]`` section for configuration).
     Otherwise, use as name of program to run that acts like sendmail
     (takes ``-f`` option for sender, list of recipients on command line,
     message on stdin). Normally, setting this to ``sendmail`` or
     ``/usr/sbin/sendmail`` is enough to use sendmail to send messages.
 
 ``charsets``
     Optional. Comma-separated list of character sets considered
     convenient for recipients. Addresses, headers, and parts not
     containing patches of outgoing messages will be encoded in the
     first character set to which conversion from local encoding
     (``$HGENCODING``, ``ui.fallbackencoding``) succeeds. If correct
     conversion fails, the text in question is sent as is.
     (default: '')
 
     Order of outgoing email character sets:
 
     1. ``us-ascii``: always first, regardless of settings
     2. ``email.charsets``: in order given by user
     3. ``ui.fallbackencoding``: if not in email.charsets
     4. ``$HGENCODING``: if not in email.charsets
     5. ``utf-8``: always last, regardless of settings
 
 Email example::
 
   [email]
   from = Joseph User <[e-mail]>
   method = /usr/sbin/sendmail
   # charsets for western Europeans
   # us-ascii, utf-8 omitted, as they are tried first and last
   charsets = iso-8859-1, iso-8859-15, windows-1252
 
 
 ``extensions``
 --------------
 
 Mercurial has an extension mechanism for adding new features. To
 enable an extension, create an entry for it in this section.
 
 If you know that the extension is already in Python's search path,
 you can give the name of the module, followed by ``=``, with nothing
 after the ``=``.
 
 Otherwise, give a name that you choose, followed by ``=``, followed by
 the path to the ``.py`` file (including the file name extension) that
 defines the extension.
 
 To explicitly disable an extension that is enabled in an hgrc of
 broader scope, prepend its path with ``!``, as in ``foo = !/ext/path``
 or ``foo = !`` when path is not supplied.
 
 Example for ``~/.hgrc``::
 
   [extensions]
   # (the churn extension will get loaded from Mercurial's path)
   churn =
   # (this extension will get loaded from the file specified)
   myfeature = ~/.hgext/myfeature.py
 
 
 ``format``
 ----------
 
 Configuration that controls the repository format. Newer format options are more
 powerful but incompatible with some older versions of Mercurial. Format options
 are considered at repository initialization only. You need to make a new clone
 for config change to be taken into account.
 
 For more details about repository format and version compatibility, see
 https://www.mercurial-scm.org/wiki/MissingRequirement
 
 ``usegeneraldelta``
     Enable or disable the "generaldelta" repository format which improves
     repository compression by allowing "revlog" to store delta against arbitrary
     revision instead of the previous stored one. This provides significant
     improvement for repositories with branches.
 
     Repositories with this on-disk format require Mercurial version 1.9.
 
     Enabled by default.
 
 ``dotencode``
     Enable or disable the "dotencode" repository format which enhances
     the "fncache" repository format (which has to be enabled to use
     dotencode) to avoid issues with filenames starting with ._ on
     Mac OS X and spaces on Windows.
 
     Repositories with this on-disk format require Mercurial version 1.7.
 
     Enabled by default.
 
 ``usefncache``
     Enable or disable the "fncache" repository format which enhances
     the "store" repository format (which has to be enabled to use
     fncache) to allow longer filenames and avoids using Windows
     reserved names, e.g. "nul".
 
     Repositories with this on-disk format require Mercurial version 1.1.
 
     Enabled by default.
 
 ``usestore``
     Enable or disable the "store" repository format which improves
     compatibility with systems that fold case or otherwise mangle
     filenames. Disabling this option will allow you to store longer filenames
     in some situations at the expense of compatibility.
 
     Repositories with this on-disk format require Mercurial version 0.9.4.
 
     Enabled by default.
 
 ``graph``
 ---------
 
 Web graph view configuration. This section let you change graph
 elements display properties by branches, for instance to make the
 ``default`` branch stand out.
 
 Each line has the following format::
 
     <branch>.<argument> = <value>
 
 where ``<branch>`` is the name of the branch being
 customized. Example::
 
     [graph]
     # 2px width
     default.width = 2
     # red color
     default.color = FF0000
 
 Supported arguments:
 
 ``width``
     Set branch edges width in pixels.
 
 ``color``
     Set branch edges color in hexadecimal RGB notation.
 
 ``hooks``
 ---------
 
 Commands or Python functions that get automatically executed by
 various actions such as starting or finishing a commit. Multiple
 hooks can be run for the same action by appending a suffix to the
 action. Overriding a site-wide hook can be done by changing its
 value or setting it to an empty string.  Hooks can be prioritized
 by adding a prefix of ``priority.`` to the hook name on a new line
 and setting the priority. The default priority is 0.
 
 Example ``.hg/hgrc``::
 
   [hooks]
   # update working directory after adding changesets
   changegroup.update = hg update
   # do not use the site-wide hook
   incoming =
   incoming.email = /my/email/hook
   incoming.autobuild = /my/build/hook
   # force autobuild hook to run before other incoming hooks
   priority.incoming.autobuild = 1
 
 Most hooks are run with environment variables set that give useful
 additional information. For each hook below, the environment variables
 it is passed are listed with names in the form ``$HG_foo``. The
 ``$HG_HOOKTYPE`` and ``$HG_HOOKNAME`` variables are set for all hooks.
 They contain the type of hook which triggered the run and the full name
 of the hook in the config, respectively. In the example above, this will
 be ``$HG_HOOKTYPE=incoming`` and ``$HG_HOOKNAME=incoming.email``.
 
 .. container:: windows
 
   Some basic Unix syntax can be enabled for portability, including ``$VAR``
   and ``${VAR}`` style variables.  A ``~`` followed by ``\`` or ``/`` will
   be expanded to ``%USERPROFILE%`` to simulate a subset of tilde expansion
   on Unix.  To use a literal ``$`` or ``~``, it must be escaped with a back
   slash or inside of a strong quote.  Strong quotes will be replaced by
   double quotes after processing.
 
   This feature is enabled by adding a prefix of ``tonative.`` to the hook
   name on a new line, and setting it to ``True``.  For example::
 
     [hooks]
     incoming.autobuild = /my/build/hook
     # enable translation to cmd.exe syntax for autobuild hook
     tonative.incoming.autobuild = True
 
 ``changegroup``
   Run after a changegroup has been added via push, pull or unbundle.  The ID of
   the first new changeset is in ``$HG_NODE`` and last is in ``$HG_NODE_LAST``.
   The URL from which changes came is in ``$HG_URL``.
 
 ``commit``
   Run after a changeset has been created in the local repository. The ID
   of the newly created changeset is in ``$HG_NODE``. Parent changeset
   IDs are in ``$HG_PARENT1`` and ``$HG_PARENT2``.
 
 ``incoming``
   Run after a changeset has been pulled, pushed, or unbundled into
   the local repository. The ID of the newly arrived changeset is in
   ``$HG_NODE``. The URL that was source of the changes is in ``$HG_URL``.
 
 ``outgoing``
   Run after sending changes from the local repository to another. The ID of
   first changeset sent is in ``$HG_NODE``. The source of operation is in
   ``$HG_SOURCE``. Also see :hg:`help config.hooks.preoutgoing`.
 
 ``post-<command>``
   Run after successful invocations of the associated command. The
   contents of the command line are passed as ``$HG_ARGS`` and the result
   code in ``$HG_RESULT``. Parsed command line arguments are passed as
   ``$HG_PATS`` and ``$HG_OPTS``. These contain string representations of
   the python data internally passed to <command>. ``$HG_OPTS`` is a
   dictionary of options (with unspecified options set to their defaults).
   ``$HG_PATS`` is a list of arguments. Hook failure is ignored.
 
 ``fail-<command>``
   Run after a failed invocation of an associated command. The contents
   of the command line are passed as ``$HG_ARGS``. Parsed command line
   arguments are passed as ``$HG_PATS`` and ``$HG_OPTS``. These contain
   string representations of the python data internally passed to
   <command>. ``$HG_OPTS`` is a dictionary of options (with unspecified
   options set to their defaults). ``$HG_PATS`` is a list of arguments.
   Hook failure is ignored.
 
 ``pre-<command>``
   Run before executing the associated command. The contents of the
   command line are passed as ``$HG_ARGS``. Parsed command line arguments
   are passed as ``$HG_PATS`` and ``$HG_OPTS``. These contain string
   representations of the data internally passed to <command>. ``$HG_OPTS``
   is a dictionary of options (with unspecified options set to their
   defaults). ``$HG_PATS`` is a list of arguments. If the hook returns
   failure, the command doesn't execute and Mercurial returns the failure
   code.
 
 ``prechangegroup``
   Run before a changegroup is added via push, pull or unbundle. Exit
   status 0 allows the changegroup to proceed. A non-zero status will
   cause the push, pull or unbundle to fail. The URL from which changes
   will come is in ``$HG_URL``.
 
 ``precommit``
   Run before starting a local commit. Exit status 0 allows the
   commit to proceed. A non-zero status will cause the commit to fail.
   Parent changeset IDs are in ``$HG_PARENT1`` and ``$HG_PARENT2``.
 
 ``prelistkeys``
   Run before listing pushkeys (like bookmarks) in the
   repository. A non-zero status will cause failure. The key namespace is
   in ``$HG_NAMESPACE``.
 
 ``preoutgoing``
   Run before collecting changes to send from the local repository to
   another. A non-zero status will cause failure. This lets you prevent
   pull over HTTP or SSH. It can also prevent propagating commits (via
   local pull, push (outbound) or bundle commands), but not completely,
   since you can just copy files instead. The source of operation is in
   ``$HG_SOURCE``. If "serve", the operation is happening on behalf of a remote
   SSH or HTTP repository. If "push", "pull" or "bundle", the operation
   is happening on behalf of a repository on same system.
 
 ``prepushkey``
   Run before a pushkey (like a bookmark) is added to the
   repository. A non-zero status will cause the key to be rejected. The
   key namespace is in ``$HG_NAMESPACE``, the key is in ``$HG_KEY``,
   the old value (if any) is in ``$HG_OLD``, and the new value is in
   ``$HG_NEW``.
 
 ``pretag``
   Run before creating a tag. Exit status 0 allows the tag to be
   created. A non-zero status will cause the tag to fail. The ID of the
   changeset to tag is in ``$HG_NODE``. The name of tag is in ``$HG_TAG``. The
   tag is local if ``$HG_LOCAL=1``, or in the repository if ``$HG_LOCAL=0``.
 
 ``pretxnopen``
   Run before any new repository transaction is open. The reason for the
   transaction will be in ``$HG_TXNNAME``, and a unique identifier for the
   transaction will be in ``HG_TXNID``. A non-zero status will prevent the
   transaction from being opened.
 
 ``pretxnclose``
   Run right before the transaction is actually finalized. Any repository change
   will be visible to the hook program. This lets you validate the transaction
   content or change it. Exit status 0 allows the commit to proceed. A non-zero
   status will cause the transaction to be rolled back. The reason for the
   transaction opening will be in ``$HG_TXNNAME``, and a unique identifier for
   the transaction will be in ``HG_TXNID``. The rest of the available data will
   vary according the transaction type. New changesets will add ``$HG_NODE``
   (the ID of the first added changeset), ``$HG_NODE_LAST`` (the ID of the last
   added changeset), ``$HG_URL`` and ``$HG_SOURCE`` variables.  Bookmark and
   phase changes will set ``HG_BOOKMARK_MOVED`` and ``HG_PHASES_MOVED`` to ``1``
   respectively, etc.
 
 ``pretxnclose-bookmark``
   Run right before a bookmark change is actually finalized. Any repository
   change will be visible to the hook program. This lets you validate the
   transaction content or change it. Exit status 0 allows the commit to
   proceed. A non-zero status will cause the transaction to be rolled back.
   The name of the bookmark will be available in ``$HG_BOOKMARK``, the new
   bookmark location will be available in ``$HG_NODE`` while the previous
   location will be available in ``$HG_OLDNODE``. In case of a bookmark
   creation ``$HG_OLDNODE`` will be empty. In case of deletion ``$HG_NODE``
   will be empty.
   In addition, the reason for the transaction opening will be in
   ``$HG_TXNNAME``, and a unique identifier for the transaction will be in
   ``HG_TXNID``.
 
 ``pretxnclose-phase``
   Run right before a phase change is actually finalized. Any repository change
   will be visible to the hook program. This lets you validate the transaction
   content or change it. Exit status 0 allows the commit to proceed.  A non-zero
   status will cause the transaction to be rolled back. The hook is called
   multiple times, once for each revision affected by a phase change.
   The affected node is available in ``$HG_NODE``, the phase in ``$HG_PHASE``
   while the previous ``$HG_OLDPHASE``. In case of new node, ``$HG_OLDPHASE``
   will be empty.  In addition, the reason for the transaction opening will be in
   ``$HG_TXNNAME``, and a unique identifier for the transaction will be in
   ``HG_TXNID``. The hook is also run for newly added revisions. In this case
   the ``$HG_OLDPHASE`` entry will be empty.
 
 ``txnclose``
   Run after any repository transaction has been committed. At this
   point, the transaction can no longer be rolled back. The hook will run
   after the lock is released. See :hg:`help config.hooks.pretxnclose` for
   details about available variables.
 
 ``txnclose-bookmark``
   Run after any bookmark change has been committed. At this point, the
   transaction can no longer be rolled back. The hook will run after the lock
   is released. See :hg:`help config.hooks.pretxnclose-bookmark` for details
   about available variables.
 
 ``txnclose-phase``
   Run after any phase change has been committed. At this point, the
   transaction can no longer be rolled back. The hook will run after the lock
   is released. See :hg:`help config.hooks.pretxnclose-phase` for details about
   available variables.
 
 ``txnabort``
   Run when a transaction is aborted. See :hg:`help config.hooks.pretxnclose`
   for details about available variables.
 
 ``pretxnchangegroup``
   Run after a changegroup has been added via push, pull or unbundle, but before
   the transaction has been committed. The changegroup is visible to the hook
   program. This allows validation of incoming changes before accepting them.
   The ID of the first new changeset is in ``$HG_NODE`` and last is in
   ``$HG_NODE_LAST``. Exit status 0 allows the transaction to commit. A non-zero
   status will cause the transaction to be rolled back, and the push, pull or
   unbundle will fail. The URL that was the source of changes is in ``$HG_URL``.
 
 ``pretxncommit``
   Run after a changeset has been created, but before the transaction is
   committed. The changeset is visible to the hook program. This allows
   validation of the commit message and changes. Exit status 0 allows the
   commit to proceed. A non-zero status will cause the transaction to
   be rolled back. The ID of the new changeset is in ``$HG_NODE``. The parent
   changeset IDs are in ``$HG_PARENT1`` and ``$HG_PARENT2``.
 
 ``preupdate``
   Run before updating the working directory. Exit status 0 allows
   the update to proceed. A non-zero status will prevent the update.
   The changeset ID of first new parent is in ``$HG_PARENT1``. If updating to a
   merge, the ID of second new parent is in ``$HG_PARENT2``.
 
 ``listkeys``
   Run after listing pushkeys (like bookmarks) in the repository. The
   key namespace is in ``$HG_NAMESPACE``. ``$HG_VALUES`` is a
   dictionary containing the keys and values.
 
 ``pushkey``
   Run after a pushkey (like a bookmark) is added to the
   repository. The key namespace is in ``$HG_NAMESPACE``, the key is in
   ``$HG_KEY``, the old value (if any) is in ``$HG_OLD``, and the new
   value is in ``$HG_NEW``.
 
 ``tag``
   Run after a tag is created. The ID of the tagged changeset is in ``$HG_NODE``.
   The name of tag is in ``$HG_TAG``. The tag is local if ``$HG_LOCAL=1``, or in
   the repository if ``$HG_LOCAL=0``.
 
 ``update``
   Run after updating the working directory. The changeset ID of first
   new parent is in ``$HG_PARENT1``. If updating to a merge, the ID of second new
   parent is in ``$HG_PARENT2``. If the update succeeded, ``$HG_ERROR=0``. If the
   update failed (e.g. because conflicts were not resolved), ``$HG_ERROR=1``.
 
 .. note::
 
    It is generally better to use standard hooks rather than the
    generic pre- and post- command hooks, as they are guaranteed to be
    called in the appropriate contexts for influencing transactions.
    Also, hooks like "commit" will be called in all contexts that
    generate a commit (e.g. tag) and not just the commit command.
 
 .. note::
 
    Environment variables with empty values may not be passed to
    hooks on platforms such as Windows. As an example, ``$HG_PARENT2``
    will have an empty value under Unix-like platforms for non-merge
    changesets, while it will not be available at all under Windows.
 
 The syntax for Python hooks is as follows::
 
   hookname = python:modulename.submodule.callable
   hookname = python:/path/to/python/module.py:callable
 
 Python hooks are run within the Mercurial process. Each hook is
 called with at least three keyword arguments: a ui object (keyword
 ``ui``), a repository object (keyword ``repo``), and a ``hooktype``
 keyword that tells what kind of hook is used. Arguments listed as
 environment variables above are passed as keyword arguments, with no
 ``HG_`` prefix, and names in lower case.
 
 If a Python hook returns a "true" value or raises an exception, this
 is treated as a failure.
 
 
 ``hostfingerprints``
 --------------------
 
 (Deprecated. Use ``[hostsecurity]``'s ``fingerprints`` options instead.)
 
 Fingerprints of the certificates of known HTTPS servers.
 
 A HTTPS connection to a server with a fingerprint configured here will
 only succeed if the servers certificate matches the fingerprint.
 This is very similar to how ssh known hosts works.
 
 The fingerprint is the SHA-1 hash value of the DER encoded certificate.
 Multiple values can be specified (separated by spaces or commas). This can
 be used to define both old and new fingerprints while a host transitions
 to a new certificate.
 
 The CA chain and web.cacerts is not used for servers with a fingerprint.
 
 For example::
 
     [hostfingerprints]
     hg.intevation.de = fc:e2:8d:d9:51:cd:cb:c1:4d:18:6b:b7:44:8d:49:72:57:e6:cd:33
     hg.intevation.org = fc:e2:8d:d9:51:cd:cb:c1:4d:18:6b:b7:44:8d:49:72:57:e6:cd:33
 
 ``hostsecurity``
 ----------------
 
 Used to specify global and per-host security settings for connecting to
 other machines.
 
 The following options control default behavior for all hosts.
 
 ``ciphers``
     Defines the cryptographic ciphers to use for connections.
 
     Value must be a valid OpenSSL Cipher List Format as documented at
     https://www.openssl.org/docs/manmaster/apps/ciphers.html#CIPHER-LIST-FORMAT.
 
     This setting is for advanced users only. Setting to incorrect values
     can significantly lower connection security or decrease performance.
     You have been warned.
 
     This option requires Python 2.7.
 
 ``minimumprotocol``
     Defines the minimum channel encryption protocol to use.
 
     By default, the highest version of TLS supported by both client and server
     is used.
 
     Allowed values are: ``tls1.0``, ``tls1.1``, ``tls1.2``.
 
     When running on an old Python version, only ``tls1.0`` is allowed since
     old versions of Python only support up to TLS 1.0.
 
     When running a Python that supports modern TLS versions, the default is
     ``tls1.1``. ``tls1.0`` can still be used to allow TLS 1.0. However, this
     weakens security and should only be used as a feature of last resort if
     a server does not support TLS 1.1+.
 
 Options in the ``[hostsecurity]`` section can have the form
 ``hostname``:``setting``. This allows multiple settings to be defined on a
 per-host basis.
 
 The following per-host settings can be defined.
 
 ``ciphers``
     This behaves like ``ciphers`` as described above except it only applies
     to the host on which it is defined.
 
 ``fingerprints``
     A list of hashes of the DER encoded peer/remote certificate. Values have
     the form ``algorithm``:``fingerprint``. e.g.
     ``sha256:c3ab8ff13720e8ad9047dd39466b3c8974e592c2fa383d4a3960714caef0c4f2``.
     In addition, colons (``:``) can appear in the fingerprint part.
 
     The following algorithms/prefixes are supported: ``sha1``, ``sha256``,
     ``sha512``.
 
     Use of ``sha256`` or ``sha512`` is preferred.
 
     If a fingerprint is specified, the CA chain is not validated for this
     host and Mercurial will require the remote certificate to match one
     of the fingerprints specified. This means if the server updates its
     certificate, Mercurial will abort until a new fingerprint is defined.
     This can provide stronger security than traditional CA-based validation
     at the expense of convenience.
 
     This option takes precedence over ``verifycertsfile``.
 
 ``minimumprotocol``
     This behaves like ``minimumprotocol`` as described above except it
     only applies to the host on which it is defined.
 
 ``verifycertsfile``
     Path to file a containing a list of PEM encoded certificates used to
     verify the server certificate. Environment variables and ``~user``
     constructs are expanded in the filename.
 
     The server certificate or the certificate's certificate authority (CA)
     must match a certificate from this file or certificate verification
     will fail and connections to the server will be refused.
 
     If defined, only certificates provided by this file will be used:
     ``web.cacerts`` and any system/default certificates will not be
     used.
 
     This option has no effect if the per-host ``fingerprints`` option
     is set.
 
     The format of the file is as follows::
 
         -----BEGIN CERTIFICATE-----
         ... (certificate in base64 PEM encoding) ...
         -----END CERTIFICATE-----
         -----BEGIN CERTIFICATE-----
         ... (certificate in base64 PEM encoding) ...
         -----END CERTIFICATE-----
 
 For example::
 
     [hostsecurity]
     hg.example.com:fingerprints = sha256:c3ab8ff13720e8ad9047dd39466b3c8974e592c2fa383d4a3960714caef0c4f2
     hg2.example.com:fingerprints = sha1:914f1aff87249c09b6859b88b1906d30756491ca, sha1:fc:e2:8d:d9:51:cd:cb:c1:4d:18:6b:b7:44:8d:49:72:57:e6:cd:33
     hg3.example.com:fingerprints = sha256:9a:b0:dc:e2:75:ad:8a:b7:84:58:e5:1f:07:32:f1:87:e6:bd:24:22:af:b7:ce:8e:9c:b4:10:cf:b9:f4:0e:d2
     foo.example.com:verifycertsfile = /etc/ssl/trusted-ca-certs.pem
 
 To change the default minimum protocol version to TLS 1.2 but to allow TLS 1.1
 when connecting to ``hg.example.com``::
 
     [hostsecurity]
     minimumprotocol = tls1.2
     hg.example.com:minimumprotocol = tls1.1
 
 ``http_proxy``
 --------------
 
 Used to access web-based Mercurial repositories through a HTTP
 proxy.
 
 ``host``
     Host name and (optional) port of the proxy server, for example
     "myproxy:8000".
 
 ``no``
     Optional. Comma-separated list of host names that should bypass
     the proxy.
 
 ``passwd``
     Optional. Password to authenticate with at the proxy server.
 
 ``user``
     Optional. User name to authenticate with at the proxy server.
 
 ``always``
     Optional. Always use the proxy, even for localhost and any entries
     in ``http_proxy.no``. (default: False)
 
 ``merge``
 ---------
 
 This section specifies behavior during merges and updates.
 
 ``checkignored``
    Controls behavior when an ignored file on disk has the same name as a tracked
    file in the changeset being merged or updated to, and has different
    contents. Options are ``abort``, ``warn`` and ``ignore``. With ``abort``,
    abort on such files. With ``warn``, warn on such files and back them up as
    ``.orig``. With ``ignore``, don't print a warning and back them up as
    ``.orig``. (default: ``abort``)
 
 ``checkunknown``
    Controls behavior when an unknown file that isn't ignored has the same name
    as a tracked file in the changeset being merged or updated to, and has
    different contents. Similar to ``merge.checkignored``, except for files that
    are not ignored. (default: ``abort``)
 
 ``on-failure``
    When set to ``continue`` (the default), the merge process attempts to
    merge all unresolved files using the merge chosen tool, regardless of
    whether previous file merge attempts during the process succeeded or not.
    Setting this to ``prompt`` will prompt after any merge failure continue
    or halt the merge process. Setting this to ``halt`` will automatically
    halt the merge process on any merge tool failure. The merge process
    can be restarted by using the ``resolve`` command. When a merge is
    halted, the repository is left in a normal ``unresolved`` merge state.
    (default: ``continue``)
 
 ``merge-patterns``
 ------------------
 
 This section specifies merge tools to associate with particular file
 patterns. Tools matched here will take precedence over the default
 merge tool. Patterns are globs by default, rooted at the repository
 root.
 
 Example::
 
   [merge-patterns]
   **.c = kdiff3
   **.jpg = myimgmerge
 
 ``merge-tools``
 ---------------
 
 This section configures external merge tools to use for file-level
 merges. This section has likely been preconfigured at install time.
 Use :hg:`config merge-tools` to check the existing configuration.
 Also see :hg:`help merge-tools` for more details.
 
 Example ``~/.hgrc``::
 
   [merge-tools]
   # Override stock tool location
   kdiff3.executable = ~/bin/kdiff3
   # Specify command line
   kdiff3.args = $base $local $other -o $output
   # Give higher priority
   kdiff3.priority = 1
 
   # Changing the priority of preconfigured tool
   meld.priority = 0
 
   # Disable a preconfigured tool
   vimdiff.disabled = yes
 
   # Define new tool
   myHtmlTool.args = -m $local $other $base $output
   myHtmlTool.regkey = Software\FooSoftware\HtmlMerge
   myHtmlTool.priority = 1
 
 Supported arguments:
 
 ``priority``
   The priority in which to evaluate this tool.
   (default: 0)
 
 ``executable``
   Either just the name of the executable or its pathname.
 
   .. container:: windows
 
     On Windows, the path can use environment variables with ${ProgramFiles}
     syntax.
 
   (default: the tool name)
 
 ``args``
   The arguments to pass to the tool executable. You can refer to the
   files being merged as well as the output file through these
   variables: ``$base``, ``$local``, ``$other``, ``$output``.
 
   The meaning of ``$local`` and ``$other`` can vary depending on which action is
   being performed. During an update or merge, ``$local`` represents the original
   state of the file, while ``$other`` represents the commit you are updating to or
   the commit you are merging with. During a rebase, ``$local`` represents the
   destination of the rebase, and ``$other`` represents the commit being rebased.
 
   Some operations define custom labels to assist with identifying the revisions,
   accessible via ``$labellocal``, ``$labelother``, and ``$labelbase``. If custom
   labels are not available, these will be ``local``, ``other``, and ``base``,
   respectively.
   (default: ``$local $base $other``)
 
 ``premerge``
   Attempt to run internal non-interactive 3-way merge tool before
   launching external tool.  Options are ``true``, ``false``, ``keep`` or
   ``keep-merge3``. The ``keep`` option will leave markers in the file if the
   premerge fails. The ``keep-merge3`` will do the same but include information
   about the base of the merge in the marker (see internal :merge3 in
   :hg:`help merge-tools`).
   (default: True)
 
 ``binary``
   This tool can merge binary files. (default: False, unless tool
   was selected by file pattern match)
 
 ``symlink``
   This tool can merge symlinks. (default: False)
 
 ``check``
   A list of merge success-checking options:
 
   ``changed``
     Ask whether merge was successful when the merged file shows no changes.
   ``conflicts``
     Check whether there are conflicts even though the tool reported success.
   ``prompt``
     Always prompt for merge success, regardless of success reported by tool.
 
 ``fixeol``
   Attempt to fix up EOL changes caused by the merge tool.
   (default: False)
 
 ``gui``
   This tool requires a graphical interface to run. (default: False)
 
 ``mergemarkers``
   Controls whether the labels passed via ``$labellocal``, ``$labelother``, and
   ``$labelbase`` are ``detailed`` (respecting ``mergemarkertemplate``) or
   ``basic``. If ``premerge`` is ``keep`` or ``keep-merge3``, the conflict
   markers generated during premerge will be ``detailed`` if either this option or
   the corresponding option in the ``[ui]`` section is ``detailed``.
   (default: ``basic``)
 
 ``mergemarkertemplate``
   This setting can be used to override ``mergemarkertemplate`` from the ``[ui]``
   section on a per-tool basis; this applies to the ``$label``-prefixed variables
   and to the conflict markers that are generated if ``premerge`` is ``keep` or
   ``keep-merge3``. See the corresponding variable in ``[ui]`` for more
   information.
 
 .. container:: windows
 
   ``regkey``
     Windows registry key which describes install location of this
     tool. Mercurial will search for this key first under
     ``HKEY_CURRENT_USER`` and then under ``HKEY_LOCAL_MACHINE``.
     (default: None)
 
   ``regkeyalt``
     An alternate Windows registry key to try if the first key is not
     found.  The alternate key uses the same ``regname`` and ``regappend``
     semantics of the primary key.  The most common use for this key
     is to search for 32bit applications on 64bit operating systems.
     (default: None)
 
   ``regname``
     Name of value to read from specified registry key.
     (default: the unnamed (default) value)
 
   ``regappend``
     String to append to the value read from the registry, typically
     the executable name of the tool.
     (default: None)
 
 ``pager``
 ---------
 
 Setting used to control when to paginate and with what external tool. See
 :hg:`help pager` for details.
 
 ``pager``
     Define the external tool used as pager.
 
     If no pager is set, Mercurial uses the environment variable $PAGER.
     If neither pager.pager, nor $PAGER is set, a default pager will be
     used, typically `less` on Unix and `more` on Windows. Example::
 
       [pager]
       pager = less -FRX
 
 ``ignore``
     List of commands to disable the pager for. Example::
 
       [pager]
       ignore = version, help, update
 
 ``patch``
 ---------
 
 Settings used when applying patches, for instance through the 'import'
 command or with Mercurial Queues extension.
 
 ``eol``
     When set to 'strict' patch content and patched files end of lines
     are preserved. When set to ``lf`` or ``crlf``, both files end of
     lines are ignored when patching and the result line endings are
     normalized to either LF (Unix) or CRLF (Windows). When set to
     ``auto``, end of lines are again ignored while patching but line
     endings in patched files are normalized to their original setting
     on a per-file basis. If target file does not exist or has no end
     of line, patch line endings are preserved.
     (default: strict)
 
 ``fuzz``
     The number of lines of 'fuzz' to allow when applying patches. This
     controls how much context the patcher is allowed to ignore when
     trying to apply a patch.
     (default: 2)
 
 ``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.
 
 ``phases``
 ----------
 
 Specifies default handling of phases. See :hg:`help phases` for more
 information about working with phases.
 
 ``publish``
     Controls draft phase behavior when working as a server. When true,
     pushed changesets are set to public in both client and server and
     pulled or cloned changesets are set to public in the client.
     (default: True)
 
 ``new-commit``
     Phase of newly-created commits.
     (default: draft)
 
 ``checksubrepos``
     Check the phase of the current revision of each subrepository. Allowed
     values are "ignore", "follow" and "abort". For settings other than
     "ignore", the phase of the current revision of each subrepository is
     checked before committing the parent repository. If any of those phases is
     greater than the phase of the parent repository (e.g. if a subrepo is in a
     "secret" phase while the parent repo is in "draft" phase), the commit is
     either aborted (if checksubrepos is set to "abort") or the higher phase is
     used for the parent repository commit (if set to "follow").
     (default: follow)
 
 
 ``profiling``
 -------------
 
 Specifies profiling type, format, and file output. Two profilers are
 supported: an instrumenting profiler (named ``ls``), and a sampling
 profiler (named ``stat``).
 
 In this section description, 'profiling data' stands for the raw data
 collected during profiling, while 'profiling report' stands for a
 statistical text report generated from the profiling data.
 
 ``enabled``
     Enable the profiler.
     (default: false)
 
     This is equivalent to passing ``--profile`` on the command line.
 
 ``type``
     The type of profiler to use.
     (default: stat)
 
     ``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.
     ``stat``
       Use a statistical profiler, statprof. This profiler is most
       useful for profiling commands that run for longer than about 0.1
       seconds.
 
 ``format``
     Profiling format.  Specific to the ``ls`` instrumenting profiler.
     (default: text)
 
     ``text``
       Generate a profiling report. When saving to a file, it should be
       noted that only the report is saved, and the profiling data is
       not kept.
     ``kcachegrind``
       Format profiling data for kcachegrind use: when saving to a
       file, the generated file can directly be loaded into
       kcachegrind.
 
 ``statformat``
     Profiling format for the ``stat`` profiler.
     (default: hotpath)
 
     ``hotpath``
       Show a tree-based display containing the hot path of execution (where
       most time was spent).
     ``bymethod``
       Show a table of methods ordered by how frequently they are active.
     ``byline``
       Show a table of lines in files ordered by how frequently they are active.
     ``json``
       Render profiling data as JSON.
 
 ``frequency``
     Sampling frequency.  Specific to the ``stat`` sampling profiler.
     (default: 1000)
 
 ``output``
     File path where profiling data or report should be saved. If the
     file exists, it is replaced. (default: None, data is printed on
     stderr)
 
 ``sort``
     Sort field.  Specific to the ``ls`` instrumenting profiler.
     One of ``callcount``, ``reccallcount``, ``totaltime`` and
     ``inlinetime``.
     (default: inlinetime)
 
 ``time-track``
     Control if the stat profiler track ``cpu`` or ``real`` time.
     (default: ``cpu``)
 
 ``limit``
     Number of lines to show. Specific to the ``ls`` instrumenting profiler.
     (default: 30)
 
 ``nested``
     Show at most this number of lines of drill-down info after each main entry.
     This can help explain the difference between Total and Inline.
     Specific to the ``ls`` instrumenting profiler.
     (default: 0)
 
 ``showmin``
     Minimum fraction of samples an entry must have for it to be displayed.
     Can be specified as a float between ``0.0`` and ``1.0`` or can have a
     ``%`` afterwards to allow values up to ``100``. e.g. ``5%``.
 
     Only used by the ``stat`` profiler.
 
     For the ``hotpath`` format, default is ``0.05``.
     For the ``chrome`` format, default is ``0.005``.
 
     The option is unused on other formats.
 
 ``showmax``
     Maximum fraction of samples an entry can have before it is ignored in
     display. Values format is the same as ``showmin``.
 
     Only used by the ``stat`` profiler.
 
     For the ``chrome`` format, default is ``0.999``.
 
     The option is unused on other formats.
 
 ``progress``
 ------------
 
 Mercurial commands can draw progress bars that are as informative as
 possible. Some progress bars only offer indeterminate information, while others
 have a definite end point.
 
 ``delay``
     Number of seconds (float) before showing the progress bar. (default: 3)
 
 ``changedelay``
     Minimum delay before showing a new topic. When set to less than 3 * refresh,
     that value will be used instead. (default: 1)
 
 ``estimateinterval``
     Maximum sampling interval in seconds for speed and estimated time
     calculation. (default: 60)
 
 ``refresh``
     Time in seconds between refreshes of the progress bar. (default: 0.1)
 
 ``format``
     Format of the progress bar.
 
     Valid entries for the format field are ``topic``, ``bar``, ``number``,
     ``unit``, ``estimate``, ``speed``, and ``item``. ``item`` defaults to the
     last 20 characters of the item, but this can be changed by adding either
     ``-<num>`` which would take the last num characters, or ``+<num>`` for the
     first num characters.
 
     (default: topic bar number estimate)
 
 ``width``
     If set, the maximum width of the progress information (that is, min(width,
     term width) will be used).
 
 ``clear-complete``
     Clear the progress bar after it's done. (default: True)
 
 ``disable``
     If true, don't show a progress bar.
 
 ``assume-tty``
     If true, ALWAYS show a progress bar, unless disable is given.
 
 ``rebase``
 ----------
 
 ``evolution.allowdivergence``
     Default to False, when True allow creating divergence when performing
     rebase of obsolete changesets.
 
 ``revsetalias``
 ---------------
 
 Alias definitions for revsets. See :hg:`help revsets` for details.
 
 ``storage``
 -----------
 
 Control the strategy Mercurial uses internally to store history. Options in this
 category impact performance and repository size.
 
 ``revlog.optimize-delta-parent-choice``
     When storing a merge revision, both parents will be equally considered as
     a possible delta base. This results in better delta selection and improved
     revlog compression. This option is enabled by default.
 
     Turning this option off can result in large increase of repository size for
     repository with many merges.
 
 ``server``
 ----------
 
 Controls generic server settings.
 
 ``bookmarks-pushkey-compat``
     Trigger pushkey hook when being pushed bookmark updates. This config exist
     for compatibility purpose (default to True)
 
     If you use ``pushkey`` and ``pre-pushkey`` hooks to control bookmark
     movement we recommend you migrate them to ``txnclose-bookmark`` and
     ``pretxnclose-bookmark``.
 
 ``compressionengines``
     List of compression engines and their relative priority to advertise
     to clients.
 
     The order of compression engines determines their priority, the first
     having the highest priority. If a compression engine is not listed
     here, it won't be advertised to clients.
 
     If not set (the default), built-in defaults are used. Run
     :hg:`debuginstall` to list available compression engines and their
     default wire protocol priority.
 
     Older Mercurial clients only support zlib compression and this setting
     has no effect for legacy clients.
 
 ``uncompressed``
     Whether to allow clients to clone a repository using the
     uncompressed streaming protocol. This transfers about 40% more
     data than a regular clone, but uses less memory and CPU on both
     server and client. Over a LAN (100 Mbps or better) or a very fast
     WAN, an uncompressed streaming clone is a lot faster (~10x) than a
     regular clone. Over most WAN connections (anything slower than
     about 6 Mbps), uncompressed streaming is slower, because of the
     extra data transfer overhead. This mode will also temporarily hold
     the write lock while determining what data to transfer.
     (default: True)
 
 ``uncompressedallowsecret``
     Whether to allow stream clones when the repository contains secret
     changesets. (default: False)
 
 ``preferuncompressed``
     When set, clients will try to use the uncompressed streaming
     protocol. (default: False)
 
 ``disablefullbundle``
     When set, servers will refuse attempts to do pull-based clones.
     If this option is set, ``preferuncompressed`` and/or clone bundles
     are highly recommended. Partial clones will still be allowed.
     (default: False)
 
 ``streamunbundle``
     When set, servers will apply data sent from the client directly,
     otherwise it will be written to a temporary file first. This option
     effectively prevents concurrent pushes.
 
 ``pullbundle``
     When set, the server will check pullbundle.manifest for bundles
     covering the requested heads and common nodes. The first matching
     entry will be streamed to the client.
 
     For HTTP transport, the stream will still use zlib compression
     for older clients.
 
 ``concurrent-push-mode``
     Level of allowed race condition between two pushing clients.
 
     - 'strict': push is abort if another client touched the repository
       while the push was preparing. (default)
     - 'check-related': push is only aborted if it affects head that got also
       affected while the push was preparing.
 
     This requires compatible client (version 4.3 and later). Old client will
     use 'strict'.
 
 ``validate``
     Whether to validate the completeness of pushed changesets by
     checking that all new file revisions specified in manifests are
     present. (default: False)
 
 ``maxhttpheaderlen``
     Instruct HTTP clients not to send request headers longer than this
     many bytes. (default: 1024)
 
 ``bundle1``
     Whether to allow clients to push and pull using the legacy bundle1
     exchange format. (default: True)
 
 ``bundle1gd``
     Like ``bundle1`` but only used if the repository is using the
     *generaldelta* storage format. (default: True)
 
 ``bundle1.push``
     Whether to allow clients to push using the legacy bundle1 exchange
     format. (default: True)
 
 ``bundle1gd.push``
     Like ``bundle1.push`` but only used if the repository is using the
     *generaldelta* storage format. (default: True)
 
 ``bundle1.pull``
     Whether to allow clients to pull using the legacy bundle1 exchange
     format. (default: True)
 
 ``bundle1gd.pull``
     Like ``bundle1.pull`` but only used if the repository is using the
     *generaldelta* storage format. (default: True)
 
     Large repositories using the *generaldelta* storage format should
     consider setting this option because converting *generaldelta*
     repositories to the exchange format required by the bundle1 data
     format can consume a lot of CPU.
 
 ``zliblevel``
     Integer between ``-1`` and ``9`` that controls the zlib compression level
     for wire protocol commands that send zlib compressed output (notably the
     commands that send repository history data).
 
     The default (``-1``) uses the default zlib compression level, which is
     likely equivalent to ``6``. ``0`` means no compression. ``9`` means
     maximum compression.
 
     Setting this option allows server operators to make trade-offs between
     bandwidth and CPU used. Lowering the compression lowers CPU utilization
     but sends more bytes to clients.
 
     This option only impacts the HTTP server.
 
 ``zstdlevel``
     Integer between ``1`` and ``22`` that controls the zstd compression level
     for wire protocol commands. ``1`` is the minimal amount of compression and
     ``22`` is the highest amount of compression.
 
     The default (``3``) should be significantly faster than zlib while likely
     delivering better compression ratios.
 
     This option only impacts the HTTP server.
 
     See also ``server.zliblevel``.
 
 ``smtp``
 --------
 
 Configuration for extensions that need to send email messages.
 
 ``host``
     Host name of mail server, e.g. "mail.example.com".
 
 ``port``
     Optional. Port to connect to on mail server. (default: 465 if
     ``tls`` is smtps; 25 otherwise)
 
 ``tls``
     Optional. Method to enable TLS when connecting to mail server: starttls,
     smtps or none. (default: none)
 
 ``username``
     Optional. User name for authenticating with the SMTP server.
     (default: None)
 
 ``password``
     Optional. Password for authenticating with the SMTP server. If not
     specified, interactive sessions will prompt the user for a
     password; non-interactive sessions will fail. (default: None)
 
 ``local_hostname``
     Optional. The hostname that the sender can use to identify
     itself to the MTA.
 
 
 ``subpaths``
 ------------
 
 Subrepository source URLs can go stale if a remote server changes name
 or becomes temporarily unavailable. This section lets you define
 rewrite rules of the form::
 
     <pattern> = <replacement>
 
 where ``pattern`` is a regular expression matching a subrepository
 source URL and ``replacement`` is the replacement string used to
 rewrite it. Groups can be matched in ``pattern`` and referenced in
 ``replacements``. For instance::
 
     http://server/(.*)-hg/ = http://hg.server/\1/
 
 rewrites ``http://server/foo-hg/`` into ``http://hg.server/foo/``.
 
 Relative subrepository paths are first made absolute, and the
 rewrite rules are then applied on the full (absolute) path. If ``pattern``
 doesn't match the full path, an attempt is made to apply it on the
 relative path alone. The rules are applied in definition order.
 
 ``subrepos``
 ------------
 
 This section contains options that control the behavior of the
 subrepositories feature. See also :hg:`help subrepos`.
 
 Security note: auditing in Mercurial is known to be insufficient to
 prevent clone-time code execution with carefully constructed Git
 subrepos. It is unknown if a similar detect is present in Subversion
 subrepos. Both Git and Subversion subrepos are disabled by default
 out of security concerns. These subrepo types can be enabled using
 the respective options below.
 
 ``allowed``
     Whether subrepositories are allowed in the working directory.
 
     When false, commands involving subrepositories (like :hg:`update`)
     will fail for all subrepository types.
     (default: true)
 
 ``hg:allowed``
     Whether Mercurial subrepositories are allowed in the working
     directory. This option only has an effect if ``subrepos.allowed``
     is true.
     (default: true)
 
 ``git:allowed``
     Whether Git subrepositories are allowed in the working directory.
     This option only has an effect if ``subrepos.allowed`` is true.
 
     See the security note above before enabling Git subrepos.
     (default: false)
 
 ``svn:allowed``
     Whether Subversion subrepositories are allowed in the working
     directory. This option only has an effect if ``subrepos.allowed``
     is true.
 
     See the security note above before enabling Subversion subrepos.
     (default: false)
 
 ``templatealias``
 -----------------
 
 Alias definitions for templates. See :hg:`help templates` for details.
 
 ``templates``
 -------------
 
 Use the ``[templates]`` section to define template strings.
 See :hg:`help templates` for details.
 
 ``trusted``
 -----------
 
 Mercurial will not use the settings in the
 ``.hg/hgrc`` file from a repository if it doesn't belong to a trusted
 user or to a trusted group, as various hgrc features allow arbitrary
 commands to be run. This issue is often encountered when configuring
 hooks or extensions for shared repositories or servers. However,
 the web interface will use some safe settings from the ``[web]``
 section.
 
 This section specifies what users and groups are trusted. The
 current user is always trusted. To trust everybody, list a user or a
 group with name ``*``. These settings must be placed in an
 *already-trusted file* to take effect, such as ``$HOME/.hgrc`` of the
 user or service running Mercurial.
 
 ``users``
   Comma-separated list of trusted users.
 
 ``groups``
   Comma-separated list of trusted groups.
 
 
 ``ui``
 ------
 
 User interface controls.
 
 ``archivemeta``
     Whether to include the .hg_archival.txt file containing meta data
     (hashes for the repository base and for tip) in archives created
     by the :hg:`archive` command or downloaded via hgweb.
     (default: True)
 
 ``askusername``
     Whether to prompt for a username when committing. If True, and
     neither ``$HGUSER`` nor ``$EMAIL`` has been specified, then the user will
     be prompted to enter a username. If no username is entered, the
     default ``USER@HOST`` is used instead.
     (default: False)
 
 ``clonebundles``
     Whether the "clone bundles" feature is enabled.
 
     When enabled, :hg:`clone` may download and apply a server-advertised
     bundle file from a URL instead of using the normal exchange mechanism.
 
     This can likely result in faster and more reliable clones.
 
     (default: True)
 
 ``clonebundlefallback``
     Whether failure to apply an advertised "clone bundle" from a server
     should result in fallback to a regular clone.
 
     This is disabled by default because servers advertising "clone
     bundles" often do so to reduce server load. If advertised bundles
     start mass failing and clients automatically fall back to a regular
     clone, this would add significant and unexpected load to the server
     since the server is expecting clone operations to be offloaded to
     pre-generated bundles. Failing fast (the default behavior) ensures
     clients don't overwhelm the server when "clone bundle" application
     fails.
 
     (default: False)
 
 ``clonebundleprefers``
     Defines preferences for which "clone bundles" to use.
 
     Servers advertising "clone bundles" may advertise multiple available
     bundles. Each bundle may have different attributes, such as the bundle
     type and compression format. This option is used to prefer a particular
     bundle over another.
 
     The following keys are defined by Mercurial:
 
     BUNDLESPEC
        A bundle type specifier. These are strings passed to :hg:`bundle -t`.
        e.g. ``gzip-v2`` or ``bzip2-v1``.
 
     COMPRESSION
        The compression format of the bundle. e.g. ``gzip`` and ``bzip2``.
 
     Server operators may define custom keys.
 
     Example values: ``COMPRESSION=bzip2``,
     ``BUNDLESPEC=gzip-v2, COMPRESSION=gzip``.
 
     By default, the first bundle advertised by the server is used.
 
 ``color``
     When to colorize output. Possible value are Boolean ("yes" or "no"), or
     "debug", or "always". (default: "yes"). "yes" will use color whenever it
     seems possible. See :hg:`help color` for details.
 
 ``commitsubrepos``
     Whether to commit modified subrepositories when committing the
     parent repository. If False and one subrepository has uncommitted
     changes, abort the commit.
     (default: False)
 
 ``debug``
     Print debugging information. (default: False)
 
 ``editor``
     The editor to use during a commit. (default: ``$EDITOR`` or ``vi``)
 
 ``fallbackencoding``
     Encoding to try if it's not possible to decode the changelog using
     UTF-8. (default: ISO-8859-1)
 
 ``graphnodetemplate``
     The template used to print changeset nodes in an ASCII revision graph.
     (default: ``{graphnode}``)
 
 ``ignore``
     A file to read per-user ignore patterns from. This file should be
     in the same format as a repository-wide .hgignore file. Filenames
     are relative to the repository root. This option supports hook syntax,
     so if you want to specify multiple ignore files, you can do so by
     setting something like ``ignore.other = ~/.hgignore2``. For details
     of the ignore file format, see the ``hgignore(5)`` man page.
 
 ``interactive``
     Allow to prompt the user. (default: True)
 
 ``interface``
     Select the default interface for interactive features (default: text).
     Possible values are 'text' and 'curses'.
 
 ``interface.chunkselector``
     Select the interface for change recording (e.g. :hg:`commit -i`).
     Possible values are 'text' and 'curses'.
     This config overrides the interface specified by ui.interface.
 
 ``large-file-limit``
     Largest file size that gives no memory use warning.
     Possible values are integers or 0 to disable the check.
     (default: 10000000)
 
 ``logtemplate``
     Template string for commands that print changesets.
 
 ``merge``
     The conflict resolution program to use during a manual merge.
     For more information on merge tools see :hg:`help merge-tools`.
     For configuring merge tools see the ``[merge-tools]`` section.
 
 ``mergemarkers``
     Sets the merge conflict marker label styling. The ``detailed``
     style uses the ``mergemarkertemplate`` setting to style the labels.
     The ``basic`` style just uses 'local' and 'other' as the marker label.
     One of ``basic`` or ``detailed``.
     (default: ``basic``)
 
 ``mergemarkertemplate``
     The template used to print the commit description next to each conflict
     marker during merge conflicts. See :hg:`help templates` for the template
     format.
 
     Defaults to showing the hash, tags, branches, bookmarks, author, and
     the first line of the commit description.
 
     If you use non-ASCII characters in names for tags, branches, bookmarks,
     authors, and/or commit descriptions, you must pay attention to encodings of
     managed files. At template expansion, non-ASCII characters use the encoding
     specified by the ``--encoding`` global option, ``HGENCODING`` or other
     environment variables that govern your locale. If the encoding of the merge
     markers is different from the encoding of the merged files,
     serious problems may occur.
 
     Can be overridden per-merge-tool, see the ``[merge-tools]`` section.
 
 ``origbackuppath``
     The path to a directory used to store generated .orig files. If the path is
     not a directory, one will be created.  If set, files stored in this
     directory have the same name as the original file and do not have a .orig
     suffix.
 
 ``paginate``
   Control the pagination of command output (default: True). See :hg:`help pager`
   for details.
 
 ``patch``
     An optional external tool that ``hg import`` and some extensions
     will use for applying patches. By default Mercurial uses an
     internal patch utility. The external tool must work as the common
     Unix ``patch`` program. In particular, it must accept a ``-p``
     argument to strip patch headers, a ``-d`` argument to specify the
     current directory, a file name to patch, and a patch file to take
     from stdin.
 
     It is possible to specify a patch tool together with extra
     arguments. For example, setting this option to ``patch --merge``
     will use the ``patch`` program with its 2-way merge option.
 
 ``portablefilenames``
     Check for portable filenames. Can be ``warn``, ``ignore`` or ``abort``.
     (default: ``warn``)
 
     ``warn``
       Print a warning message on POSIX platforms, if a file with a non-portable
       filename is added (e.g. a file with a name that can't be created on
       Windows because it contains reserved parts like ``AUX``, reserved
       characters like ``:``, or would cause a case collision with an existing
       file).
 
     ``ignore``
       Don't print a warning.
 
     ``abort``
       The command is aborted.
 
     ``true``
       Alias for ``warn``.
 
     ``false``
       Alias for ``ignore``.
 
     .. container:: windows
 
       On Windows, this configuration option is ignored and the command aborted.
 
 ``quiet``
     Reduce the amount of output printed.
     (default: False)
 
 ``remotecmd``
     Remote command to use for clone/push/pull operations.
     (default: ``hg``)
 
 ``report_untrusted``
     Warn if a ``.hg/hgrc`` file is ignored due to not being owned by a
     trusted user or group.
     (default: True)
 
 ``slash``
     (Deprecated. Use ``slashpath`` template filter instead.)
 
     Display paths using a slash (``/``) as the path separator. This
     only makes a difference on systems where the default path
     separator is not the slash character (e.g. Windows uses the
     backslash character (``\``)).
     (default: False)
 
 ``statuscopies``
     Display copies in the status command.
 
 ``ssh``
     Command to use for SSH connections. (default: ``ssh``)
 
 ``ssherrorhint``
     A hint shown to the user in the case of SSH error (e.g.
     ``Please see http://company/internalwiki/ssh.html``)
 
 ``strict``
     Require exact command names, instead of allowing unambiguous
     abbreviations. (default: False)
 
 ``style``
     Name of style to use for command output.
 
 ``supportcontact``
     A URL where users should report a Mercurial traceback. Use this if you are a
     large organisation with its own Mercurial deployment process and crash
     reports should be addressed to your internal support.
 
 ``textwidth``
     Maximum width of help text. A longer line generated by ``hg help`` or
     ``hg subcommand --help`` will be broken after white space to get this
     width or the terminal width, whichever comes first.
     A non-positive value will disable this and the terminal width will be
     used. (default: 78)
 
 ``timeout``
     The timeout used when a lock is held (in seconds), a negative value
     means no timeout. (default: 600)
 
 ``timeout.warn``
     Time (in seconds) before a warning is printed about held lock. A negative
     value means no warning. (default: 0)
 
 ``traceback``
     Mercurial always prints a traceback when an unknown exception
     occurs. Setting this to True will make Mercurial print a traceback
     on all exceptions, even those recognized by Mercurial (such as
     IOError or MemoryError). (default: False)
 
 ``tweakdefaults``
 
     By default Mercurial's behavior changes very little from release
     to release, but over time the recommended config settings
     shift. Enable this config to opt in to get automatic tweaks to
     Mercurial's behavior over time. This config setting will have no
     effet if ``HGPLAIN` is set or ``HGPLAINEXCEPT`` is set and does
     not include ``tweakdefaults``. (default: False)
 
 ``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)
 
 ``verbose``
     Increase the amount of output printed. (default: False)
 
 
 ``web``
 -------
 
 Web interface configuration. The settings in this section apply to
 both the builtin webserver (started by :hg:`serve`) and the script you
 run through a webserver (``hgweb.cgi`` and the derivatives for FastCGI
 and WSGI).
 
 The Mercurial webserver does no authentication (it does not prompt for
 usernames and passwords to validate *who* users are), but it does do
 authorization (it grants or denies access for *authenticated users*
 based on settings in this section). You must either configure your
 webserver to do authentication for you, or disable the authorization
 checks.
 
 For a quick setup in a trusted environment, e.g., a private LAN, where
 you want it to accept pushes from anybody, you can use the following
 command line::
 
     $ hg --config web.allow-push=* --config web.push_ssl=False serve
 
 Note that this will allow anybody to push anything to the server and
 that this should not be used for public servers.
 
 The full set of options is:
 
 ``accesslog``
     Where to output the access log. (default: stdout)
 
 ``address``
     Interface address to bind to. (default: all)
 
 ``allow-archive``
     List of archive format (bz2, gz, zip) allowed for downloading.
     (default: empty)
 
 ``allowbz2``
     (DEPRECATED) Whether to allow .tar.bz2 downloading of repository
     revisions.
     (default: False)
 
 ``allowgz``
     (DEPRECATED) Whether to allow .tar.gz downloading of repository
     revisions.
     (default: False)
 
 ``allow-pull``
     Whether to allow pulling from the repository. (default: True)
 
 ``allow-push``
     Whether to allow pushing to the repository. If empty or not set,
     pushing is not allowed. If the special value ``*``, any remote
     user can push, including unauthenticated users. Otherwise, the
     remote user must have been authenticated, and the authenticated
     user name must be present in this list. The contents of the
     allow-push list are examined after the deny_push list.
 
 ``allow_read``
     If the user has not already been denied repository access due to
     the contents of deny_read, this list determines whether to grant
     repository access to the user. If this list is not empty, and the
     user is unauthenticated or not present in the list, then access is
     denied for the user. If the list is empty or not set, then access
     is permitted to all users by default. Setting allow_read to the
     special value ``*`` is equivalent to it not being set (i.e. access
     is permitted to all users). The contents of the allow_read list are
     examined after the deny_read list.
 
 ``allowzip``
     (DEPRECATED) Whether to allow .zip downloading of repository
     revisions. This feature creates temporary files.
     (default: False)
 
 ``archivesubrepos``
     Whether to recurse into subrepositories when archiving.
     (default: False)
 
 ``baseurl``
     Base URL to use when publishing URLs in other locations, so
     third-party tools like email notification hooks can construct
     URLs. Example: ``http://hgserver/repos/``.
 
 ``cacerts``
     Path to file containing a list of PEM encoded certificate
     authority certificates. Environment variables and ``~user``
     constructs are expanded in the filename. If specified on the
     client, then it will verify the identity of remote HTTPS servers
     with these certificates.
 
     To disable SSL verification temporarily, specify ``--insecure`` from
     command line.
 
     You can use OpenSSL's CA certificate file if your platform has
     one. On most Linux systems this will be
     ``/etc/ssl/certs/ca-certificates.crt``. Otherwise you will have to
     generate this file manually. The form must be as follows::
 
         -----BEGIN CERTIFICATE-----
         ... (certificate in base64 PEM encoding) ...
         -----END CERTIFICATE-----
         -----BEGIN CERTIFICATE-----
         ... (certificate in base64 PEM encoding) ...
         -----END CERTIFICATE-----
 
 ``cache``
     Whether to support caching in hgweb. (default: True)
 
 ``certificate``
     Certificate to use when running :hg:`serve`.
 
 ``collapse``
     With ``descend`` enabled, repositories in subdirectories are shown at
     a single level alongside repositories in the current path. With
     ``collapse`` also enabled, repositories residing at a deeper level than
     the current path are grouped behind navigable directory entries that
     lead to the locations of these repositories. In effect, this setting
     collapses each collection of repositories found within a subdirectory
     into a single entry for that subdirectory. (default: False)
 
 ``comparisoncontext``
     Number of lines of context to show in side-by-side file comparison. If
     negative or the value ``full``, whole files are shown. (default: 5)
 
     This setting can be overridden by a ``context`` request parameter to the
     ``comparison`` command, taking the same values.
 
 ``contact``
     Name or email address of the person in charge of the repository.
     (default: ui.username or ``$EMAIL`` or "unknown" if unset or empty)
 
 ``csp``
     Send a ``Content-Security-Policy`` HTTP header with this value.
 
     The value may contain a special string ``%nonce%``, which will be replaced
     by a randomly-generated one-time use value. If the value contains
     ``%nonce%``, ``web.cache`` will be disabled, as caching undermines the
     one-time property of the nonce. This nonce will also be inserted into
     ``<script>`` elements containing inline JavaScript.
 
     Note: lots of HTML content sent by the server is derived from repository
     data. Please consider the potential for malicious repository data to
     "inject" itself into generated HTML content as part of your security
     threat model.
 
 ``deny_push``
     Whether to deny pushing to the repository. If empty or not set,
     push is not denied. If the special value ``*``, all remote users are
     denied push. Otherwise, unauthenticated users are all denied, and
     any authenticated user name present in this list is also denied. The
     contents of the deny_push list are examined before the allow-push list.
 
 ``deny_read``
     Whether to deny reading/viewing of the repository. If this list is
     not empty, unauthenticated users are all denied, and any
     authenticated user name present in this list is also denied access to
     the repository. If set to the special value ``*``, all remote users
     are denied access (rarely needed ;). If deny_read is empty or not set,
     the determination of repository access depends on the presence and
     content of the allow_read list (see description). If both
     deny_read and allow_read are empty or not set, then access is
     permitted to all users by default. If the repository is being
     served via hgwebdir, denied users will not be able to see it in
     the list of repositories. The contents of the deny_read list have
     priority over (are examined before) the contents of the allow_read
     list.
 
 ``descend``
     hgwebdir indexes will not descend into subdirectories. Only repositories
     directly in the current path will be shown (other repositories are still
     available from the index corresponding to their containing path).
 
 ``description``
     Textual description of the repository's purpose or contents.
     (default: "unknown")
 
 ``encoding``
     Character encoding name. (default: the current locale charset)
     Example: "UTF-8".
 
 ``errorlog``
     Where to output the error log. (default: stderr)
 
 ``guessmime``
     Control MIME types for raw download of file content.
     Set to True to let hgweb guess the content type from the file
     extension. This will serve HTML files as ``text/html`` and might
     allow cross-site scripting attacks when serving untrusted
     repositories. (default: False)
 
 ``hidden``
     Whether to hide the repository in the hgwebdir index.
     (default: False)
 
 ``ipv6``
     Whether to use IPv6. (default: False)
 
 ``labels``
     List of string *labels* associated with the repository.
 
     Labels are exposed as a template keyword and can be used to customize
     output. e.g. the ``index`` template can group or filter repositories
     by labels and the ``summary`` template can display additional content
     if a specific label is present.
 
 ``logoimg``
     File name of the logo image that some templates display on each page.
     The file name is relative to ``staticurl``. That is, the full path to
     the logo image is "staticurl/logoimg".
     If unset, ``hglogo.png`` will be used.
 
 ``logourl``
     Base URL to use for logos. If unset, ``https://mercurial-scm.org/``
     will be used.
 
 ``maxchanges``
     Maximum number of changes to list on the changelog. (default: 10)
 
 ``maxfiles``
     Maximum number of files to list per changeset. (default: 10)
 
 ``maxshortchanges``
     Maximum number of changes to list on the shortlog, graph or filelog
     pages. (default: 60)
 
 ``name``
     Repository name to use in the web interface.
     (default: current working directory)
 
 ``port``
     Port to listen on. (default: 8000)
 
 ``prefix``
     Prefix path to serve from. (default: '' (server root))
 
 ``push_ssl``
     Whether to require that inbound pushes be transported over SSL to
     prevent password sniffing. (default: True)
 
 ``refreshinterval``
     How frequently directory listings re-scan the filesystem for new
     repositories, in seconds. This is relevant when wildcards are used
     to define paths. Depending on how much filesystem traversal is
     required, refreshing may negatively impact performance.
 
     Values less than or equal to 0 always refresh.
     (default: 20)
 
 ``server-header``
     Value for HTTP ``Server`` response header.
 
 ``staticurl``
     Base URL to use for static files. If unset, static files (e.g. the
     hgicon.png favicon) will be served by the CGI script itself. Use
     this setting to serve them directly with the HTTP server.
     Example: ``http://hgserver/static/``.
 
 ``stripes``
     How many lines a "zebra stripe" should span in multi-line output.
     Set to 0 to disable. (default: 1)
 
 ``style``
     Which template map style to use. The available options are the names of
     subdirectories in the HTML templates path. (default: ``paper``)
     Example: ``monoblue``.
 
 ``templates``
     Where to find the HTML templates. The default path to the HTML templates
     can be obtained from ``hg debuginstall``.
 
 ``websub``
 ----------
 
 Web substitution filter definition. You can use this section to
 define a set of regular expression substitution patterns which
 let you automatically modify the hgweb server output.
 
 The default hgweb templates only apply these substitution patterns
 on the revision description fields. You can apply them anywhere
 you want when you create your own templates by adding calls to the
 "websub" filter (usually after calling the "escape" filter).
 
 This can be used, for example, to convert issue references to links
 to your issue tracker, or to convert "markdown-like" syntax into
 HTML (see the examples below).
 
 Each entry in this section names a substitution filter.
 The value of each entry defines the substitution expression itself.
 The websub expressions follow the old interhg extension syntax,
 which in turn imitates the Unix sed replacement syntax::
 
     patternname = s/SEARCH_REGEX/REPLACE_EXPRESSION/[i]
 
 You can use any separator other than "/". The final "i" is optional
 and indicates that the search must be case insensitive.
 
 Examples::
 
     [websub]
     issues = s|issue(\d+)|<a href="http://bts.example.org/issue\1">issue\1</a>|i
     italic = s/\b_(\S+)_\b/<i>\1<\/i>/
     bold = s/\*\b(\S+)\b\*/<b>\1<\/b>/
 
 ``worker``
 ----------
 
 Parallel master/worker configuration. We currently perform working
 directory updates in parallel on Unix-like systems, which greatly
 helps performance.
 
 ``enabled``
     Whether to enable workers code to be used.
     (default: true)
 
 ``numcpus``
     Number of CPUs to use for parallel operations. A zero or
     negative value is treated as ``use the default``.
     (default: 4 or the number of CPUs on the system, whichever is larger)
 
 ``backgroundclose``
     Whether to enable closing file handles on background threads during certain
     operations. Some platforms aren't very efficient at closing file
     handles that have been written or appended to. By performing file closing
     on background threads, file write rate can increase substantially.
     (default: true on Windows, false elsewhere)
 
 ``backgroundcloseminfilecount``
     Minimum number of files required to trigger background file closing.
     Operations not writing this many files won't start background close
     threads.
     (default: 2048)
 
 ``backgroundclosemaxqueue``
     The maximum number of opened file handles waiting to be closed in the
     background. This option only has an effect if ``backgroundclose`` is
     enabled.
     (default: 384)
 
 ``backgroundclosethreadcount``
     Number of threads to process background file closes. Only relevant if
     ``backgroundclose`` is enabled.
     (default: 4)

tests/test-resolve.t

@@ -1,514 +1,514 b''
 test that a commit clears the merge state.
 
   $ hg init repo
   $ cd repo
 
   $ echo foo > file1
   $ echo foo > file2
   $ hg commit -Am 'add files'
   adding file1
   adding file2
 
   $ echo bar >> file1
   $ echo bar >> file2
   $ hg commit -Am 'append bar to files'
 
 create a second head with conflicting edits
 
   $ hg up -C 0
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo baz >> file1
   $ echo baz >> file2
   $ hg commit -Am 'append baz to files'
   created new head
 
 create a third head with no conflicting edits
   $ hg up -qC 0
   $ echo foo > file3
   $ hg commit -Am 'add non-conflicting file'
   adding file3
   created new head
 
 failing merge
 
   $ hg up -qC 2
   $ hg merge --tool=internal:fail 1
   0 files updated, 0 files merged, 0 files removed, 2 files unresolved
   use 'hg resolve' to retry unresolved file merges or 'hg merge --abort' to abandon
   [1]
 
 resolve -l should contain unresolved entries
 
   $ hg resolve -l
   U file1
   U file2
 
   $ hg resolve -l --no-status
   file1
   file2
 
 resolving an unknown path should emit a warning, but not for -l
 
   $ hg resolve -m does-not-exist
   arguments do not match paths that need resolving
   $ hg resolve -l does-not-exist
 
 tell users how they could have used resolve
 
   $ mkdir nested
   $ cd nested
   $ hg resolve -m file1
   arguments do not match paths that need resolving
   (try: hg resolve -m path:file1)
   $ hg resolve -m file1 filez
   arguments do not match paths that need resolving
   (try: hg resolve -m path:file1 path:filez)
   $ hg resolve -m path:file1 path:filez
   $ hg resolve -l
   R file1
   U file2
   $ hg resolve -m filez file2
   arguments do not match paths that need resolving
   (try: hg resolve -m path:filez path:file2)
   $ hg resolve -m path:filez path:file2
   (no more unresolved files)
   $ hg resolve -l
   R file1
   R file2
 
 cleanup
   $ hg resolve -u
   $ cd ..
   $ rmdir nested
 
 don't allow marking or unmarking driver-resolved files
 
   $ cat > $TESTTMP/markdriver.py << EOF
   > '''mark and unmark files as driver-resolved'''
   > from mercurial import (
   >    merge,
   >    pycompat,
   >    registrar,
   >    scmutil,
   > )
   > cmdtable = {}
   > command = registrar.command(cmdtable)
   > @command(b'markdriver',
   >   [(b'u', b'unmark', None, b'')],
   >   b'FILE...')
   > def markdriver(ui, repo, *pats, **opts):
   >     wlock = repo.wlock()
   >     opts = pycompat.byteskwargs(opts)
   >     try:
   >         ms = merge.mergestate.read(repo)
   >         m = scmutil.match(repo[None], pats, opts)
   >         for f in ms:
   >             if not m(f):
   >                 continue
   >             if not opts[b'unmark']:
   >                 ms.mark(f, b'd')
   >             else:
   >                 ms.mark(f, b'u')
   >         ms.commit()
   >     finally:
   >         wlock.release()
   > EOF
   $ hg --config extensions.markdriver=$TESTTMP/markdriver.py markdriver file1
   $ hg resolve --list
   D file1
   U file2
   $ hg resolve --mark file1
   not marking file1 as it is driver-resolved
 this should not print out file1
   $ hg resolve --mark --all
   (no more unresolved files -- run "hg resolve --all" to conclude)
   $ hg resolve --mark 'glob:file*'
   (no more unresolved files -- run "hg resolve --all" to conclude)
   $ hg resolve --list
   D file1
   R file2
   $ hg resolve --unmark file1
   not unmarking file1 as it is driver-resolved
   (no more unresolved files -- run "hg resolve --all" to conclude)
   $ hg resolve --unmark --all
   $ hg resolve --list
   D file1
   U file2
   $ hg --config extensions.markdriver=$TESTTMP/markdriver.py markdriver --unmark file1
   $ hg resolve --list
   U file1
   U file2
 
 resolve the failure
 
   $ echo resolved > file1
   $ hg resolve -m file1
 
 resolve -l should show resolved file as resolved
 
   $ hg resolve -l
   R file1
   U file2
 
   $ hg resolve -l -Tjson
   [
    {
     "path": "file1",
     "status": "R"
    },
    {
     "path": "file2",
     "status": "U"
    }
   ]
 
   $ hg resolve -l -T '{path} {status} {p1rev} {p2rev}\n'
   file1 R 2 1
   file2 U 2 1
 
 resolve -m without paths should mark all resolved
 
   $ hg resolve -m
   (no more unresolved files)
   $ hg commit -m 'resolved'
 
 resolve -l should be empty after commit
 
   $ hg resolve -l
 
   $ hg resolve -l -Tjson
   [
   ]
 
 resolve --all should abort when no merge in progress
 
   $ hg resolve --all
   abort: resolve command not applicable when not merging
   [255]
 
 resolve -m should abort when no merge in progress
 
   $ hg resolve -m
   abort: resolve command not applicable when not merging
   [255]
 
 can not update or merge when there are unresolved conflicts
 
   $ hg up -qC 0
   $ echo quux >> file1
   $ hg up 1
   merging file1
   warning: conflicts while merging file1! (edit, then use 'hg resolve --mark')
   1 files updated, 0 files merged, 0 files removed, 1 files unresolved
   use 'hg resolve' to retry unresolved file merges
   [1]
   $ hg up 0
   abort: outstanding merge conflicts
   [255]
   $ hg merge 2
   abort: outstanding merge conflicts
   [255]
   $ hg merge --force 2
   abort: outstanding merge conflicts
   [255]
 
 set up conflict-free merge
 
   $ hg up -qC 3
   $ hg merge 1
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
 
 resolve --all should do nothing in merge without conflicts
   $ hg resolve --all
   (no more unresolved files)
 
 resolve -m should do nothing in merge without conflicts
 
   $ hg resolve -m
   (no more unresolved files)
 
 get back to conflicting state
 
   $ hg up -qC 2
   $ hg merge --tool=internal:fail 1
   0 files updated, 0 files merged, 0 files removed, 2 files unresolved
   use 'hg resolve' to retry unresolved file merges or 'hg merge --abort' to abandon
   [1]
 
 resolve without arguments should suggest --all
   $ hg resolve
   abort: no files or directories specified
   (use --all to re-merge all unresolved files)
   [255]
 
 resolve --all should re-merge all unresolved files
   $ hg resolve --all
   merging file1
   merging file2
   warning: conflicts while merging file1! (edit, then use 'hg resolve --mark')
   warning: conflicts while merging file2! (edit, then use 'hg resolve --mark')
   [1]
   $ cat file1.orig
   foo
   baz
   $ cat file2.orig
   foo
   baz
 
 .orig files should exists where specified
   $ hg resolve --all --verbose --config 'ui.origbackuppath=.hg/origbackups'
   merging file1
   creating directory: $TESTTMP/repo/.hg/origbackups
   merging file2
   warning: conflicts while merging file1! (edit, then use 'hg resolve --mark')
   warning: conflicts while merging file2! (edit, then use 'hg resolve --mark')
   [1]
   $ ls .hg/origbackups
   file1
   file2
   $ grep '<<<' file1 > /dev/null
   $ grep '<<<' file2 > /dev/null
 
 resolve <file> should re-merge file
   $ echo resolved > file1
   $ hg resolve -q file1
   warning: conflicts while merging file1! (edit, then use 'hg resolve --mark')
   [1]
   $ grep '<<<' file1 > /dev/null
 
 test .orig behavior with resolve
 
   $ hg resolve -q file1 --tool "sh -c 'f --dump \"$TESTTMP/repo/file1.orig\"'"
   $TESTTMP/repo/file1.orig:
   >>>
   foo
   baz
   <<<
 
 resolve <file> should do nothing if 'file' was marked resolved
   $ echo resolved > file1
   $ hg resolve -m file1
   $ hg resolve -q file1
   $ cat file1
   resolved
 
 insert unsupported advisory merge record
 
   $ hg --config extensions.fakemergerecord=$TESTDIR/fakemergerecord.py fakemergerecord -x
   $ hg debugmergestate
   * version 2 records
   local: 57653b9f834a4493f7240b0681efcb9ae7cab745
   other: dc77451844e37f03f5c559e3b8529b2b48d381d1
   labels:
     local: working copy
     other: merge rev
   unrecognized entry: x	advisory record
   file extras: file1 (ancestorlinknode = 99726c03216e233810a2564cbc0adfe395007eac)
   file: file1 (record type "F", state "r", hash 60b27f004e454aca81b0480209cce5081ec52390)
     local path: file1 (flags "")
     ancestor path: file1 (node 2ed2a3912a0b24502043eae84ee4b279c18b90dd)
     other path: file1 (node 6f4310b00b9a147241b071a60c28a650827fb03d)
   file extras: file2 (ancestorlinknode = 99726c03216e233810a2564cbc0adfe395007eac)
   file: file2 (record type "F", state "u", hash cb99b709a1978bd205ab9dfd4c5aaa1fc91c7523)
     local path: file2 (flags "")
     ancestor path: file2 (node 2ed2a3912a0b24502043eae84ee4b279c18b90dd)
     other path: file2 (node 6f4310b00b9a147241b071a60c28a650827fb03d)
   $ hg resolve -l
   R file1
   U file2
 
 insert unsupported mandatory merge record
 
   $ hg --config extensions.fakemergerecord=$TESTDIR/fakemergerecord.py fakemergerecord -X
   $ hg debugmergestate
   * version 2 records
   local: 57653b9f834a4493f7240b0681efcb9ae7cab745
   other: dc77451844e37f03f5c559e3b8529b2b48d381d1
   labels:
     local: working copy
     other: merge rev
   file extras: file1 (ancestorlinknode = 99726c03216e233810a2564cbc0adfe395007eac)
   file: file1 (record type "F", state "r", hash 60b27f004e454aca81b0480209cce5081ec52390)
     local path: file1 (flags "")
     ancestor path: file1 (node 2ed2a3912a0b24502043eae84ee4b279c18b90dd)
     other path: file1 (node 6f4310b00b9a147241b071a60c28a650827fb03d)
   file extras: file2 (ancestorlinknode = 99726c03216e233810a2564cbc0adfe395007eac)
   file: file2 (record type "F", state "u", hash cb99b709a1978bd205ab9dfd4c5aaa1fc91c7523)
     local path: file2 (flags "")
     ancestor path: file2 (node 2ed2a3912a0b24502043eae84ee4b279c18b90dd)
     other path: file2 (node 6f4310b00b9a147241b071a60c28a650827fb03d)
   unrecognized entry: X	mandatory record
   $ hg resolve -l
   abort: unsupported merge state records: X
   (see https://mercurial-scm.org/wiki/MergeStateRecords for more information)
   [255]
   $ hg resolve -ma
   abort: unsupported merge state records: X
   (see https://mercurial-scm.org/wiki/MergeStateRecords for more information)
   [255]
   $ hg summary
   warning: merge state has unsupported record types: X
   parent: 2:57653b9f834a 
    append baz to files
   parent: 1:dc77451844e3 
    append bar to files
   branch: default
   commit: 2 modified, 2 unknown (merge)
   update: 2 new changesets (update)
   phases: 5 draft
 
 update --clean shouldn't abort on unsupported records
 
   $ hg up -qC 1
   $ hg debugmergestate
   no merge state found
 
 test crashed merge with empty mergestate
 
   $ mkdir .hg/merge
   $ touch .hg/merge/state
 
 resolve -l should be empty
 
   $ hg resolve -l
 
 resolve -m can be configured to look for remaining conflict markers
   $ hg up -qC 2
   $ hg merge -q --tool=internal:merge 1
   warning: conflicts while merging file1! (edit, then use 'hg resolve --mark')
   warning: conflicts while merging file2! (edit, then use 'hg resolve --mark')
   [1]
   $ hg resolve -l
   U file1
   U file2
   $ echo 'remove markers' > file1
-  $ hg --config experimental.resolve.mark-check=abort resolve -m
+  $ hg --config commands.resolve.mark-check=abort resolve -m
   warning: the following files still have conflict markers:
     file2
   abort: conflict markers detected
   (use --all to mark anyway)
   [255]
   $ hg resolve -l
   U file1
   U file2
 Try with --all from the hint
-  $ hg --config experimental.resolve.mark-check=abort resolve -m --all
+  $ hg --config commands.resolve.mark-check=abort resolve -m --all
   warning: the following files still have conflict markers:
     file2
   (no more unresolved files)
   $ hg resolve -l
   R file1
   R file2
   $ hg resolve --unmark
   $ hg resolve -l
   U file1
   U file2
-  $ hg --config experimental.resolve.mark-check=warn resolve -m
+  $ hg --config commands.resolve.mark-check=warn resolve -m
   warning: the following files still have conflict markers:
     file2
   (no more unresolved files)
   $ hg resolve -l
   R file1
   R file2
 If the file is already marked as resolved, we don't warn about it
   $ hg resolve --unmark file1
   $ hg resolve -l
   U file1
   R file2
-  $ hg --config experimental.resolve.mark-check=warn resolve -m
+  $ hg --config commands.resolve.mark-check=warn resolve -m
   (no more unresolved files)
   $ hg resolve -l
   R file1
   R file2
 
   $ cd ..
 
 ======================================================
 Test 'hg resolve' confirm config option functionality |
 ======================================================
   $ cat >> $HGRCPATH << EOF
   > [extensions]
   > rebase=
   > EOF
 
   $ hg init repo2
   $ cd repo2
 
   $ echo boss > boss
   $ hg ci -Am "add boss"
   adding boss
 
   $ for emp in emp1 emp2 emp3; do echo work > $emp; done;
   $ hg ci -Aqm "added emp1 emp2 emp3"
 
   $ hg up 0
   0 files updated, 0 files merged, 3 files removed, 0 files unresolved
 
   $ for emp in emp1 emp2 emp3; do echo nowork > $emp; done;
   $ hg ci -Aqm "added lazy emp1 emp2 emp3"
 
   $ hg log -GT "{rev} {node|short} {firstline(desc)}\n"
   @  2 0acfd4a49af0 added lazy emp1 emp2 emp3
   |
   | o  1 f30f98a8181f added emp1 emp2 emp3
   |/
   o  0 88660038d466 add boss
   
   $ hg rebase -s 1 -d 2
   rebasing 1:f30f98a8181f "added emp1 emp2 emp3"
   merging emp1
   merging emp2
   merging emp3
   warning: conflicts while merging emp1! (edit, then use 'hg resolve --mark')
   warning: conflicts while merging emp2! (edit, then use 'hg resolve --mark')
   warning: conflicts while merging emp3! (edit, then use 'hg resolve --mark')
   unresolved conflicts (see hg resolve, then hg rebase --continue)
   [1]
 
 Test when commands.resolve.confirm config option is not set:
 ===========================================================
   $ hg resolve --all
   merging emp1
   merging emp2
   merging emp3
   warning: conflicts while merging emp1! (edit, then use 'hg resolve --mark')
   warning: conflicts while merging emp2! (edit, then use 'hg resolve --mark')
   warning: conflicts while merging emp3! (edit, then use 'hg resolve --mark')
   [1]
 
 Test when config option is set:
 ==============================
   $ cat >> $HGRCPATH << EOF
   > [ui]
   > interactive = True
   > [commands]
   > resolve.confirm = True
   > EOF
 
   $ hg resolve
   abort: no files or directories specified
   (use --all to re-merge all unresolved files)
   [255]
   $ hg resolve --all << EOF
   > n
   > EOF
   re-merge all unresolved files (yn)? n
   abort: user quit
   [255]
 
   $ hg resolve --all << EOF
   > y
   > EOF
   re-merge all unresolved files (yn)? y
   merging emp1
   merging emp2
   merging emp3
   warning: conflicts while merging emp1! (edit, then use 'hg resolve --mark')
   warning: conflicts while merging emp2! (edit, then use 'hg resolve --mark')
   warning: conflicts while merging emp3! (edit, then use 'hg resolve --mark')
   [1]
 
   $ hg rebase --abort
   rebase aborted
   $ cd ..