errors: remove trailing "!" in messages about bad top-level args

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

mercurial/dispatch.py

@@ -1,1324 +1,1324 b''
 # dispatch.py - command dispatching 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, print_function
 
 import errno
 import getopt
 import io
 import os
 import pdb
 import re
 import signal
 import sys
 import traceback
 
 
 from .i18n import _
 from .pycompat import getattr
 
 from hgdemandimport import tracing
 
 from . import (
     cmdutil,
     color,
     commands,
     demandimport,
     encoding,
     error,
     extensions,
     fancyopts,
     help,
     hg,
     hook,
     localrepo,
     profiling,
     pycompat,
     rcutil,
     registrar,
     requirements as requirementsmod,
     scmutil,
     ui as uimod,
     util,
     vfs,
 )
 
 from .utils import (
     procutil,
     stringutil,
 )
 
 
 class request(object):
     def __init__(
         self,
         args,
         ui=None,
         repo=None,
         fin=None,
         fout=None,
         ferr=None,
         fmsg=None,
         prereposetups=None,
     ):
         self.args = args
         self.ui = ui
         self.repo = repo
 
         # input/output/error streams
         self.fin = fin
         self.fout = fout
         self.ferr = ferr
         # separate stream for status/error messages
         self.fmsg = fmsg
 
         # remember options pre-parsed by _earlyparseopts()
         self.earlyoptions = {}
 
         # reposetups which run before extensions, useful for chg to pre-fill
         # low-level repo state (for example, changelog) before extensions.
         self.prereposetups = prereposetups or []
 
         # store the parsed and canonical command
         self.canonical_command = None
 
     def _runexithandlers(self):
         exc = None
         handlers = self.ui._exithandlers
         try:
             while handlers:
                 func, args, kwargs = handlers.pop()
                 try:
                     func(*args, **kwargs)
                 except:  # re-raises below
                     if exc is None:
                         exc = sys.exc_info()[1]
                     self.ui.warnnoi18n(b'error in exit handlers:\n')
                     self.ui.traceback(force=True)
         finally:
             if exc is not None:
                 raise exc
 
 
 def run():
     """run the command in sys.argv"""
     try:
         initstdio()
         with tracing.log('parse args into request'):
             req = request(pycompat.sysargv[1:])
         err = None
         try:
             status = dispatch(req)
         except error.StdioError as e:
             err = e
             status = -1
 
         # In all cases we try to flush stdio streams.
         if util.safehasattr(req.ui, b'fout'):
             assert req.ui is not None  # help pytype
             assert req.ui.fout is not None  # help pytype
             try:
                 req.ui.fout.flush()
             except IOError as e:
                 err = e
                 status = -1
 
         if util.safehasattr(req.ui, b'ferr'):
             assert req.ui is not None  # help pytype
             assert req.ui.ferr is not None  # help pytype
             try:
                 if err is not None and err.errno != errno.EPIPE:
                     req.ui.ferr.write(
                         b'abort: %s\n' % encoding.strtolocal(err.strerror)
                     )
                 req.ui.ferr.flush()
             # There's not much we can do about an I/O error here. So (possibly)
             # change the status code and move on.
             except IOError:
                 status = -1
 
         _silencestdio()
     except KeyboardInterrupt:
         # Catch early/late KeyboardInterrupt as last ditch. Here nothing will
         # be printed to console to avoid another IOError/KeyboardInterrupt.
         status = -1
     sys.exit(status & 255)
 
 
 if pycompat.ispy3:
 
     def initstdio():
         # stdio streams on Python 3 are io.TextIOWrapper instances proxying another
         # buffer. These streams will normalize \n to \r\n by default. Mercurial's
         # preferred mechanism for writing output (ui.write()) uses io.BufferedWriter
         # instances, which write to the underlying stdio file descriptor in binary
         # mode. ui.write() uses \n for line endings and no line ending normalization
         # is attempted through this interface. This "just works," even if the system
         # preferred line ending is not \n.
         #
         # But some parts of Mercurial (e.g. hooks) can still send data to sys.stdout
         # and sys.stderr. They will inherit the line ending normalization settings,
         # potentially causing e.g. \r\n to be emitted. Since emitting \n should
         # "just work," here we change the sys.* streams to disable line ending
         # normalization, ensuring compatibility with our ui type.
 
         # write_through is new in Python 3.7.
         kwargs = {
             "newline": "\n",
             "line_buffering": sys.stdout.line_buffering,
         }
         if util.safehasattr(sys.stdout, "write_through"):
             kwargs["write_through"] = sys.stdout.write_through
         sys.stdout = io.TextIOWrapper(
             sys.stdout.buffer, sys.stdout.encoding, sys.stdout.errors, **kwargs
         )
 
         kwargs = {
             "newline": "\n",
             "line_buffering": sys.stderr.line_buffering,
         }
         if util.safehasattr(sys.stderr, "write_through"):
             kwargs["write_through"] = sys.stderr.write_through
         sys.stderr = io.TextIOWrapper(
             sys.stderr.buffer, sys.stderr.encoding, sys.stderr.errors, **kwargs
         )
 
         # No write_through on read-only stream.
         sys.stdin = io.TextIOWrapper(
             sys.stdin.buffer,
             sys.stdin.encoding,
             sys.stdin.errors,
             # None is universal newlines mode.
             newline=None,
             line_buffering=sys.stdin.line_buffering,
         )
 
     def _silencestdio():
         for fp in (sys.stdout, sys.stderr):
             # Check if the file is okay
             try:
                 fp.flush()
                 continue
             except IOError:
                 pass
             # Otherwise mark it as closed to silence "Exception ignored in"
             # message emitted by the interpreter finalizer. Be careful to
             # not close procutil.stdout, which may be a fdopen-ed file object
             # and its close() actually closes the underlying file descriptor.
             try:
                 fp.close()
             except IOError:
                 pass
 
 
 else:
 
     def initstdio():
         for fp in (sys.stdin, sys.stdout, sys.stderr):
             procutil.setbinary(fp)
 
     def _silencestdio():
         pass
 
 
 def _formatargs(args):
     return b' '.join(procutil.shellquote(a) for a in args)
 
 
 def dispatch(req):
     """run the command specified in req.args; returns an integer status code"""
     with tracing.log('dispatch.dispatch'):
         if req.ferr:
             ferr = req.ferr
         elif req.ui:
             ferr = req.ui.ferr
         else:
             ferr = procutil.stderr
 
         try:
             if not req.ui:
                 req.ui = uimod.ui.load()
             req.earlyoptions.update(_earlyparseopts(req.ui, req.args))
             if req.earlyoptions[b'traceback']:
                 req.ui.setconfig(b'ui', b'traceback', b'on', b'--traceback')
 
             # set ui streams from the request
             if req.fin:
                 req.ui.fin = req.fin
             if req.fout:
                 req.ui.fout = req.fout
             if req.ferr:
                 req.ui.ferr = req.ferr
             if req.fmsg:
                 req.ui.fmsg = req.fmsg
         except error.Abort as inst:
             ferr.write(inst.format())
             return -1
 
         msg = _formatargs(req.args)
         starttime = util.timer()
         ret = 1  # default of Python exit code on unhandled exception
         try:
             ret = _runcatch(req) or 0
         except error.ProgrammingError as inst:
             req.ui.error(_(b'** ProgrammingError: %s\n') % inst)
             if inst.hint:
                 req.ui.error(_(b'** (%s)\n') % inst.hint)
             raise
         except KeyboardInterrupt as inst:
             try:
                 if isinstance(inst, error.SignalInterrupt):
                     msg = _(b"killed!\n")
                 else:
                     msg = _(b"interrupted!\n")
                 req.ui.error(msg)
             except error.SignalInterrupt:
                 # maybe pager would quit without consuming all the output, and
                 # SIGPIPE was raised. we cannot print anything in this case.
                 pass
             except IOError as inst:
                 if inst.errno != errno.EPIPE:
                     raise
             ret = -1
         finally:
             duration = util.timer() - starttime
             req.ui.flush()  # record blocked times
             if req.ui.logblockedtimes:
                 req.ui._blockedtimes[b'command_duration'] = duration * 1000
                 req.ui.log(
                     b'uiblocked',
                     b'ui blocked ms\n',
                     **pycompat.strkwargs(req.ui._blockedtimes)
                 )
             return_code = ret & 255
             req.ui.log(
                 b"commandfinish",
                 b"%s exited %d after %0.2f seconds\n",
                 msg,
                 return_code,
                 duration,
                 return_code=return_code,
                 duration=duration,
                 canonical_command=req.canonical_command,
             )
             try:
                 req._runexithandlers()
             except:  # exiting, so no re-raises
                 ret = ret or -1
             # do flush again since ui.log() and exit handlers may write to ui
             req.ui.flush()
         return ret
 
 
 def _runcatch(req):
     with tracing.log('dispatch._runcatch'):
 
         def catchterm(*args):
             raise error.SignalInterrupt
 
         ui = req.ui
         try:
             for name in b'SIGBREAK', b'SIGHUP', b'SIGTERM':
                 num = getattr(signal, name, None)
                 if num:
                     signal.signal(num, catchterm)
         except ValueError:
             pass  # happens if called in a thread
 
         def _runcatchfunc():
             realcmd = None
             try:
                 cmdargs = fancyopts.fancyopts(
                     req.args[:], commands.globalopts, {}
                 )
                 cmd = cmdargs[0]
                 aliases, entry = cmdutil.findcmd(cmd, commands.table, False)
                 realcmd = aliases[0]
             except (
                 error.UnknownCommand,
                 error.AmbiguousCommand,
                 IndexError,
                 getopt.GetoptError,
             ):
                 # Don't handle this here. We know the command is
                 # invalid, but all we're worried about for now is that
                 # it's not a command that server operators expect to
                 # be safe to offer to users in a sandbox.
                 pass
             if realcmd == b'serve' and b'--stdio' in cmdargs:
                 # We want to constrain 'hg serve --stdio' instances pretty
                 # closely, as many shared-ssh access tools want to grant
                 # access to run *only* 'hg -R $repo serve --stdio'. We
                 # restrict to exactly that set of arguments, and prohibit
                 # any repo name that starts with '--' to prevent
                 # shenanigans wherein a user does something like pass
                 # --debugger or --config=ui.debugger=1 as a repo
                 # name. This used to actually run the debugger.
                 if (
                     len(req.args) != 4
                     or req.args[0] != b'-R'
                     or req.args[1].startswith(b'--')
                     or req.args[2] != b'serve'
                     or req.args[3] != b'--stdio'
                 ):
                     raise error.Abort(
                         _(b'potentially unsafe serve --stdio invocation: %s')
                         % (stringutil.pprint(req.args),)
                     )
 
             try:
                 debugger = b'pdb'
                 debugtrace = {b'pdb': pdb.set_trace}
                 debugmortem = {b'pdb': pdb.post_mortem}
 
                 # read --config before doing anything else
                 # (e.g. to change trust settings for reading .hg/hgrc)
                 cfgs = _parseconfig(req.ui, req.earlyoptions[b'config'])
 
                 if req.repo:
                     # copy configs that were passed on the cmdline (--config) to
                     # the repo ui
                     for sec, name, val in cfgs:
                         req.repo.ui.setconfig(
                             sec, name, val, source=b'--config'
                         )
 
                 # developer config: ui.debugger
                 debugger = ui.config(b"ui", b"debugger")
                 debugmod = pdb
                 if not debugger or ui.plain():
                     # if we are in HGPLAIN mode, then disable custom debugging
                     debugger = b'pdb'
                 elif req.earlyoptions[b'debugger']:
                     # This import can be slow for fancy debuggers, so only
                     # do it when absolutely necessary, i.e. when actual
                     # debugging has been requested
                     with demandimport.deactivated():
                         try:
                             debugmod = __import__(debugger)
                         except ImportError:
                             pass  # Leave debugmod = pdb
 
                 debugtrace[debugger] = debugmod.set_trace
                 debugmortem[debugger] = debugmod.post_mortem
 
                 # enter the debugger before command execution
                 if req.earlyoptions[b'debugger']:
                     ui.warn(
                         _(
                             b"entering debugger - "
                             b"type c to continue starting hg or h for help\n"
                         )
                     )
 
                     if (
                         debugger != b'pdb'
                         and debugtrace[debugger] == debugtrace[b'pdb']
                     ):
                         ui.warn(
                             _(
                                 b"%s debugger specified "
                                 b"but its module was not found\n"
                             )
                             % debugger
                         )
                     with demandimport.deactivated():
                         debugtrace[debugger]()
                 try:
                     return _dispatch(req)
                 finally:
                     ui.flush()
             except:  # re-raises
                 # enter the debugger when we hit an exception
                 if req.earlyoptions[b'debugger']:
                     traceback.print_exc()
                     debugmortem[debugger](sys.exc_info()[2])
                 raise
 
         return _callcatch(ui, _runcatchfunc)
 
 
 def _callcatch(ui, func):
     """like scmutil.callcatch but handles more high-level exceptions about
     config parsing and commands. besides, use handlecommandexception to handle
     uncaught exceptions.
     """
     try:
         return scmutil.callcatch(ui, func)
     except error.AmbiguousCommand as inst:
         ui.warn(
             _(b"hg: command '%s' is ambiguous:\n    %s\n")
             % (inst.prefix, b" ".join(inst.matches))
         )
     except error.CommandError as inst:
         if inst.command:
             ui.pager(b'help')
             msgbytes = pycompat.bytestr(inst.message)
             ui.warn(_(b"hg %s: %s\n") % (inst.command, msgbytes))
             commands.help_(ui, inst.command, full=False, command=True)
         else:
             ui.warn(_(b"hg: %s\n") % inst.message)
             ui.warn(_(b"(use 'hg help -v' for a list of global options)\n"))
     except error.UnknownCommand as inst:
         nocmdmsg = _(b"hg: unknown command '%s'\n") % inst.command
         try:
             # check if the command is in a disabled extension
             # (but don't check for extensions themselves)
             formatted = help.formattedhelp(
                 ui, commands, inst.command, unknowncmd=True
             )
             ui.warn(nocmdmsg)
             ui.write(formatted)
         except (error.UnknownCommand, error.Abort):
             suggested = False
             if inst.all_commands:
                 sim = error.getsimilar(inst.all_commands, inst.command)
                 if sim:
                     ui.warn(nocmdmsg)
                     ui.warn(b"(%s)\n" % error.similarity_hint(sim))
                     suggested = True
             if not suggested:
                 ui.warn(nocmdmsg)
                 ui.warn(_(b"(use 'hg help' for a list of commands)\n"))
     except IOError:
         raise
     except KeyboardInterrupt:
         raise
     except:  # probably re-raises
         if not handlecommandexception(ui):
             raise
 
     return -1
 
 
 def aliasargs(fn, givenargs):
     args = []
     # only care about alias 'args', ignore 'args' set by extensions.wrapfunction
     if not util.safehasattr(fn, b'_origfunc'):
         args = getattr(fn, 'args', args)
     if args:
         cmd = b' '.join(map(procutil.shellquote, args))
 
         nums = []
 
         def replacer(m):
             num = int(m.group(1)) - 1
             nums.append(num)
             if num < len(givenargs):
                 return givenargs[num]
             raise error.Abort(_(b'too few arguments for command alias'))
 
         cmd = re.sub(br'\$(\d+|\$)', replacer, cmd)
         givenargs = [x for i, x in enumerate(givenargs) if i not in nums]
         args = pycompat.shlexsplit(cmd)
     return args + givenargs
 
 
 def aliasinterpolate(name, args, cmd):
     '''interpolate args into cmd for shell aliases
 
     This also handles $0, $@ and "$@".
     '''
     # util.interpolate can't deal with "$@" (with quotes) because it's only
     # built to match prefix + patterns.
     replacemap = {b'$%d' % (i + 1): arg for i, arg in enumerate(args)}
     replacemap[b'$0'] = name
     replacemap[b'$$'] = b'$'
     replacemap[b'$@'] = b' '.join(args)
     # Typical Unix shells interpolate "$@" (with quotes) as all the positional
     # parameters, separated out into words. Emulate the same behavior here by
     # quoting the arguments individually. POSIX shells will then typically
     # tokenize each argument into exactly one word.
     replacemap[b'"$@"'] = b' '.join(procutil.shellquote(arg) for arg in args)
     # escape '\$' for regex
     regex = b'|'.join(replacemap.keys()).replace(b'$', br'\$')
     r = re.compile(regex)
     return r.sub(lambda x: replacemap[x.group()], cmd)
 
 
 class cmdalias(object):
     def __init__(self, ui, name, definition, cmdtable, source):
         self.name = self.cmd = name
         self.cmdname = b''
         self.definition = definition
         self.fn = None
         self.givenargs = []
         self.opts = []
         self.help = b''
         self.badalias = None
         self.unknowncmd = False
         self.source = source
 
         try:
             aliases, entry = cmdutil.findcmd(self.name, cmdtable)
             for alias, e in pycompat.iteritems(cmdtable):
                 if e is entry:
                     self.cmd = alias
                     break
             self.shadows = True
         except error.UnknownCommand:
             self.shadows = False
 
         if not self.definition:
             self.badalias = _(b"no definition for alias '%s'") % self.name
             return
 
         if self.definition.startswith(b'!'):
             shdef = self.definition[1:]
             self.shell = True
 
             def fn(ui, *args):
                 env = {b'HG_ARGS': b' '.join((self.name,) + args)}
 
                 def _checkvar(m):
                     if m.groups()[0] == b'$':
                         return m.group()
                     elif int(m.groups()[0]) <= len(args):
                         return m.group()
                     else:
                         ui.debug(
                             b"No argument found for substitution "
                             b"of %i variable in alias '%s' definition.\n"
                             % (int(m.groups()[0]), self.name)
                         )
                         return b''
 
                 cmd = re.sub(br'\$(\d+|\$)', _checkvar, shdef)
                 cmd = aliasinterpolate(self.name, args, cmd)
                 return ui.system(
                     cmd, environ=env, blockedtag=b'alias_%s' % self.name
                 )
 
             self.fn = fn
             self.alias = True
             self._populatehelp(ui, name, shdef, self.fn)
             return
 
         try:
             args = pycompat.shlexsplit(self.definition)
         except ValueError as inst:
             self.badalias = _(b"error in definition for alias '%s': %s") % (
                 self.name,
                 stringutil.forcebytestr(inst),
             )
             return
         earlyopts, args = _earlysplitopts(args)
         if earlyopts:
             self.badalias = _(
                 b"error in definition for alias '%s': %s may "
                 b"only be given on the command line"
             ) % (self.name, b'/'.join(pycompat.ziplist(*earlyopts)[0]))
             return
         self.cmdname = cmd = args.pop(0)
         self.givenargs = args
 
         try:
             tableentry = cmdutil.findcmd(cmd, cmdtable, False)[1]
             if len(tableentry) > 2:
                 self.fn, self.opts, cmdhelp = tableentry
             else:
                 self.fn, self.opts = tableentry
                 cmdhelp = None
 
             self.alias = True
             self._populatehelp(ui, name, cmd, self.fn, cmdhelp)
 
         except error.UnknownCommand:
             self.badalias = _(
                 b"alias '%s' resolves to unknown command '%s'"
             ) % (self.name, cmd,)
             self.unknowncmd = True
         except error.AmbiguousCommand:
             self.badalias = _(
                 b"alias '%s' resolves to ambiguous command '%s'"
             ) % (self.name, cmd,)
 
     def _populatehelp(self, ui, name, cmd, fn, defaulthelp=None):
         # confine strings to be passed to i18n.gettext()
         cfg = {}
         for k in (b'doc', b'help', b'category'):
             v = ui.config(b'alias', b'%s:%s' % (name, k), None)
             if v is None:
                 continue
             if not encoding.isasciistr(v):
                 self.badalias = _(
                     b"non-ASCII character in alias definition '%s:%s'"
                 ) % (name, k)
                 return
             cfg[k] = v
 
         self.help = cfg.get(b'help', defaulthelp or b'')
         if self.help and self.help.startswith(b"hg " + cmd):
             # drop prefix in old-style help lines so hg shows the alias
             self.help = self.help[4 + len(cmd) :]
 
         self.owndoc = b'doc' in cfg
         doc = cfg.get(b'doc', pycompat.getdoc(fn))
         if doc is not None:
             doc = pycompat.sysstr(doc)
         self.__doc__ = doc
 
         self.helpcategory = cfg.get(
             b'category', registrar.command.CATEGORY_NONE
         )
 
     @property
     def args(self):
         args = pycompat.maplist(util.expandpath, self.givenargs)
         return aliasargs(self.fn, args)
 
     def __getattr__(self, name):
         adefaults = {
             'norepo': True,
             'intents': set(),
             'optionalrepo': False,
             'inferrepo': False,
         }
         if name not in adefaults:
             raise AttributeError(name)
         if self.badalias or util.safehasattr(self, b'shell'):
             return adefaults[name]
         return getattr(self.fn, name)
 
     def __call__(self, ui, *args, **opts):
         if self.badalias:
             hint = None
             if self.unknowncmd:
                 try:
                     # check if the command is in a disabled extension
                     cmd, ext = extensions.disabledcmd(ui, self.cmdname)[:2]
                     hint = _(b"'%s' is provided by '%s' extension") % (cmd, ext)
                 except error.UnknownCommand:
                     pass
             raise error.Abort(self.badalias, hint=hint)
         if self.shadows:
             ui.debug(
                 b"alias '%s' shadows command '%s'\n" % (self.name, self.cmdname)
             )
 
         ui.log(
             b'commandalias',
             b"alias '%s' expands to '%s'\n",
             self.name,
             self.definition,
         )
         if util.safehasattr(self, b'shell'):
             return self.fn(ui, *args, **opts)
         else:
             try:
                 return util.checksignature(self.fn)(ui, *args, **opts)
             except error.SignatureError:
                 args = b' '.join([self.cmdname] + self.args)
                 ui.debug(b"alias '%s' expands to '%s'\n" % (self.name, args))
                 raise
 
 
 class lazyaliasentry(object):
     """like a typical command entry (func, opts, help), but is lazy"""
 
     def __init__(self, ui, name, definition, cmdtable, source):
         self.ui = ui
         self.name = name
         self.definition = definition
         self.cmdtable = cmdtable.copy()
         self.source = source
         self.alias = True
 
     @util.propertycache
     def _aliasdef(self):
         return cmdalias(
             self.ui, self.name, self.definition, self.cmdtable, self.source
         )
 
     def __getitem__(self, n):
         aliasdef = self._aliasdef
         if n == 0:
             return aliasdef
         elif n == 1:
             return aliasdef.opts
         elif n == 2:
             return aliasdef.help
         else:
             raise IndexError
 
     def __iter__(self):
         for i in range(3):
             yield self[i]
 
     def __len__(self):
         return 3
 
 
 def addaliases(ui, cmdtable):
     # aliases are processed after extensions have been loaded, so they
     # may use extension commands. Aliases can also use other alias definitions,
     # but only if they have been defined prior to the current definition.
     for alias, definition in ui.configitems(b'alias', ignoresub=True):
         try:
             if cmdtable[alias].definition == definition:
                 continue
         except (KeyError, AttributeError):
             # definition might not exist or it might not be a cmdalias
             pass
 
         source = ui.configsource(b'alias', alias)
         entry = lazyaliasentry(ui, alias, definition, cmdtable, source)
         cmdtable[alias] = entry
 
 
 def _parse(ui, args):
     options = {}
     cmdoptions = {}
 
     try:
         args = fancyopts.fancyopts(args, commands.globalopts, options)
     except getopt.GetoptError as inst:
         raise error.CommandError(None, stringutil.forcebytestr(inst))
 
     if args:
         cmd, args = args[0], args[1:]
         aliases, entry = cmdutil.findcmd(
             cmd, commands.table, ui.configbool(b"ui", b"strict")
         )
         cmd = aliases[0]
         args = aliasargs(entry[0], args)
         defaults = ui.config(b"defaults", cmd)
         if defaults:
             args = (
                 pycompat.maplist(util.expandpath, pycompat.shlexsplit(defaults))
                 + args
             )
         c = list(entry[1])
     else:
         cmd = None
         c = []
 
     # combine global options into local
     for o in commands.globalopts:
         c.append((o[0], o[1], options[o[1]], o[3]))
 
     try:
         args = fancyopts.fancyopts(args, c, cmdoptions, gnu=True)
     except getopt.GetoptError as inst:
         raise error.CommandError(cmd, stringutil.forcebytestr(inst))
 
     # separate global options back out
     for o in commands.globalopts:
         n = o[1]
         options[n] = cmdoptions[n]
         del cmdoptions[n]
 
     return (cmd, cmd and entry[0] or None, args, options, cmdoptions)
 
 
 def _parseconfig(ui, config):
     """parse the --config options from the command line"""
     configs = []
 
     for cfg in config:
         try:
             name, value = [cfgelem.strip() for cfgelem in cfg.split(b'=', 1)]
             section, name = name.split(b'.', 1)
             if not section or not name:
                 raise IndexError
             ui.setconfig(section, name, value, b'--config')
             configs.append((section, name, value))
         except (IndexError, ValueError):
             raise error.Abort(
                 _(
                     b'malformed --config option: %r '
                     b'(use --config section.name=value)'
                 )
                 % pycompat.bytestr(cfg)
             )
 
     return configs
 
 
 def _earlyparseopts(ui, args):
     options = {}
     fancyopts.fancyopts(
         args,
         commands.globalopts,
         options,
         gnu=not ui.plain(b'strictflags'),
         early=True,
         optaliases={b'repository': [b'repo']},
     )
     return options
 
 
 def _earlysplitopts(args):
     """Split args into a list of possible early options and remainder args"""
     shortoptions = b'R:'
     # TODO: perhaps 'debugger' should be included
     longoptions = [b'cwd=', b'repository=', b'repo=', b'config=']
     return fancyopts.earlygetopt(
         args, shortoptions, longoptions, gnu=True, keepsep=True
     )
 
 
 def runcommand(lui, repo, cmd, fullargs, ui, options, d, cmdpats, cmdoptions):
     # run pre-hook, and abort if it fails
     hook.hook(
         lui,
         repo,
         b"pre-%s" % cmd,
         True,
         args=b" ".join(fullargs),
         pats=cmdpats,
         opts=cmdoptions,
     )
     try:
         ret = _runcommand(ui, options, cmd, d)
         # run post-hook, passing command result
         hook.hook(
             lui,
             repo,
             b"post-%s" % cmd,
             False,
             args=b" ".join(fullargs),
             result=ret,
             pats=cmdpats,
             opts=cmdoptions,
         )
     except Exception:
         # run failure hook and re-raise
         hook.hook(
             lui,
             repo,
             b"fail-%s" % cmd,
             False,
             args=b" ".join(fullargs),
             pats=cmdpats,
             opts=cmdoptions,
         )
         raise
     return ret
 
 
 def _readsharedsourceconfig(ui, path):
     """if the current repository is shared one, this tries to read
     .hg/hgrc of shared source if we are in share-safe mode
 
     Config read is loaded into the ui object passed
 
     This should be called before reading .hg/hgrc or the main repo
     as that overrides config set in shared source"""
     try:
         with open(os.path.join(path, b".hg", b"requires"), "rb") as fp:
             requirements = set(fp.read().splitlines())
             if not (
                 requirementsmod.SHARESAFE_REQUIREMENT in requirements
                 and requirementsmod.SHARED_REQUIREMENT in requirements
             ):
                 return
             hgvfs = vfs.vfs(os.path.join(path, b".hg"))
             sharedvfs = localrepo._getsharedvfs(hgvfs, requirements)
             ui.readconfig(sharedvfs.join(b"hgrc"), path)
     except IOError:
         pass
 
 
 def _getlocal(ui, rpath, wd=None):
     """Return (path, local ui object) for the given target path.
 
     Takes paths in [cwd]/.hg/hgrc into account."
     """
     if wd is None:
         try:
             wd = encoding.getcwd()
         except OSError as e:
             raise error.Abort(
                 _(b"error getting current working directory: %s")
                 % encoding.strtolocal(e.strerror)
             )
 
     path = cmdutil.findrepo(wd) or b""
     if not path:
         lui = ui
     else:
         lui = ui.copy()
         if rcutil.use_repo_hgrc():
             _readsharedsourceconfig(lui, path)
             lui.readconfig(os.path.join(path, b".hg", b"hgrc"), path)
             lui.readconfig(os.path.join(path, b".hg", b"hgrc-not-shared"), path)
 
     if rpath:
         path = lui.expandpath(rpath)
         lui = ui.copy()
         if rcutil.use_repo_hgrc():
             _readsharedsourceconfig(lui, path)
             lui.readconfig(os.path.join(path, b".hg", b"hgrc"), path)
             lui.readconfig(os.path.join(path, b".hg", b"hgrc-not-shared"), path)
 
     return path, lui
 
 
 def _checkshellalias(lui, ui, args):
     """Return the function to run the shell alias, if it is required"""
     options = {}
 
     try:
         args = fancyopts.fancyopts(args, commands.globalopts, options)
     except getopt.GetoptError:
         return
 
     if not args:
         return
 
     cmdtable = commands.table
 
     cmd = args[0]
     try:
         strict = ui.configbool(b"ui", b"strict")
         aliases, entry = cmdutil.findcmd(cmd, cmdtable, strict)
     except (error.AmbiguousCommand, error.UnknownCommand):
         return
 
     cmd = aliases[0]
     fn = entry[0]
 
     if cmd and util.safehasattr(fn, b'shell'):
         # shell alias shouldn't receive early options which are consumed by hg
         _earlyopts, args = _earlysplitopts(args)
         d = lambda: fn(ui, *args[1:])
         return lambda: runcommand(
             lui, None, cmd, args[:1], ui, options, d, [], {}
         )
 
 
 def _dispatch(req):
     args = req.args
     ui = req.ui
 
     # check for cwd
     cwd = req.earlyoptions[b'cwd']
     if cwd:
         os.chdir(cwd)
 
     rpath = req.earlyoptions[b'repository']
     path, lui = _getlocal(ui, rpath)
 
     uis = {ui, lui}
 
     if req.repo:
         uis.add(req.repo.ui)
 
     if (
         req.earlyoptions[b'verbose']
         or req.earlyoptions[b'debug']
         or req.earlyoptions[b'quiet']
     ):
         for opt in (b'verbose', b'debug', b'quiet'):
             val = pycompat.bytestr(bool(req.earlyoptions[opt]))
             for ui_ in uis:
                 ui_.setconfig(b'ui', opt, val, b'--' + opt)
 
     if req.earlyoptions[b'profile']:
         for ui_ in uis:
             ui_.setconfig(b'profiling', b'enabled', b'true', b'--profile')
 
     profile = lui.configbool(b'profiling', b'enabled')
     with profiling.profile(lui, enabled=profile) as profiler:
         # Configure extensions in phases: uisetup, extsetup, cmdtable, and
         # reposetup
         extensions.loadall(lui)
         # Propagate any changes to lui.__class__ by extensions
         ui.__class__ = lui.__class__
 
         # (uisetup and extsetup are handled in extensions.loadall)
 
         # (reposetup is handled in hg.repository)
 
         addaliases(lui, commands.table)
 
         # All aliases and commands are completely defined, now.
         # Check abbreviation/ambiguity of shell alias.
         shellaliasfn = _checkshellalias(lui, ui, args)
         if shellaliasfn:
             # no additional configs will be set, set up the ui instances
             for ui_ in uis:
                 extensions.populateui(ui_)
             return shellaliasfn()
 
         # check for fallback encoding
         fallback = lui.config(b'ui', b'fallbackencoding')
         if fallback:
             encoding.fallbackencoding = fallback
 
         fullargs = args
         cmd, func, args, options, cmdoptions = _parse(lui, args)
 
         # store the canonical command name in request object for later access
         req.canonical_command = cmd
 
         if options[b"config"] != req.earlyoptions[b"config"]:
-            raise error.Abort(_(b"option --config may not be abbreviated!"))
+            raise error.Abort(_(b"option --config may not be abbreviated"))
         if options[b"cwd"] != req.earlyoptions[b"cwd"]:
-            raise error.Abort(_(b"option --cwd may not be abbreviated!"))
+            raise error.Abort(_(b"option --cwd may not be abbreviated"))
         if options[b"repository"] != req.earlyoptions[b"repository"]:
             raise error.Abort(
                 _(
                     b"option -R has to be separated from other options (e.g. not "
-                    b"-qR) and --repository may only be abbreviated as --repo!"
+                    b"-qR) and --repository may only be abbreviated as --repo"
                 )
             )
         if options[b"debugger"] != req.earlyoptions[b"debugger"]:
-            raise error.Abort(_(b"option --debugger may not be abbreviated!"))
+            raise error.Abort(_(b"option --debugger may not be abbreviated"))
         # don't validate --profile/--traceback, which can be enabled from now
 
         if options[b"encoding"]:
             encoding.encoding = options[b"encoding"]
         if options[b"encodingmode"]:
             encoding.encodingmode = options[b"encodingmode"]
         if options[b"time"]:
 
             def get_times():
                 t = os.times()
                 if t[4] == 0.0:
                     # Windows leaves this as zero, so use time.perf_counter()
                     t = (t[0], t[1], t[2], t[3], util.timer())
                 return t
 
             s = get_times()
 
             def print_time():
                 t = get_times()
                 ui.warn(
                     _(b"time: real %.3f secs (user %.3f+%.3f sys %.3f+%.3f)\n")
                     % (
                         t[4] - s[4],
                         t[0] - s[0],
                         t[2] - s[2],
                         t[1] - s[1],
                         t[3] - s[3],
                     )
                 )
 
             ui.atexit(print_time)
         if options[b"profile"]:
             profiler.start()
 
         # if abbreviated version of this were used, take them in account, now
         if options[b'verbose'] or options[b'debug'] or options[b'quiet']:
             for opt in (b'verbose', b'debug', b'quiet'):
                 if options[opt] == req.earlyoptions[opt]:
                     continue
                 val = pycompat.bytestr(bool(options[opt]))
                 for ui_ in uis:
                     ui_.setconfig(b'ui', opt, val, b'--' + opt)
 
         if options[b'traceback']:
             for ui_ in uis:
                 ui_.setconfig(b'ui', b'traceback', b'on', b'--traceback')
 
         if options[b'noninteractive']:
             for ui_ in uis:
                 ui_.setconfig(b'ui', b'interactive', b'off', b'-y')
 
         if cmdoptions.get(b'insecure', False):
             for ui_ in uis:
                 ui_.insecureconnections = True
 
         # setup color handling before pager, because setting up pager
         # might cause incorrect console information
         coloropt = options[b'color']
         for ui_ in uis:
             if coloropt:
                 ui_.setconfig(b'ui', b'color', coloropt, b'--color')
             color.setup(ui_)
 
         if stringutil.parsebool(options[b'pager']):
             # ui.pager() expects 'internal-always-' prefix in this case
             ui.pager(b'internal-always-' + cmd)
         elif options[b'pager'] != b'auto':
             for ui_ in uis:
                 ui_.disablepager()
 
         # configs are fully loaded, set up the ui instances
         for ui_ in uis:
             extensions.populateui(ui_)
 
         if options[b'version']:
             return commands.version_(ui)
         if options[b'help']:
             return commands.help_(ui, cmd, command=cmd is not None)
         elif not cmd:
             return commands.help_(ui, b'shortlist')
 
         repo = None
         cmdpats = args[:]
         assert func is not None  # help out pytype
         if not func.norepo:
             # use the repo from the request only if we don't have -R
             if not rpath and not cwd:
                 repo = req.repo
 
             if repo:
                 # set the descriptors of the repo ui to those of ui
                 repo.ui.fin = ui.fin
                 repo.ui.fout = ui.fout
                 repo.ui.ferr = ui.ferr
                 repo.ui.fmsg = ui.fmsg
             else:
                 try:
                     repo = hg.repository(
                         ui,
                         path=path,
                         presetupfuncs=req.prereposetups,
                         intents=func.intents,
                     )
                     if not repo.local():
                         raise error.Abort(
                             _(b"repository '%s' is not local") % path
                         )
                     repo.ui.setconfig(
                         b"bundle", b"mainreporoot", repo.root, b'repo'
                     )
                 except error.RequirementError:
                     raise
                 except error.RepoError:
                     if rpath:  # invalid -R path
                         raise
                     if not func.optionalrepo:
                         if func.inferrepo and args and not path:
                             # try to infer -R from command args
                             repos = pycompat.maplist(cmdutil.findrepo, args)
                             guess = repos[0]
                             if guess and repos.count(guess) == len(repos):
                                 req.args = [b'--repository', guess] + fullargs
                                 req.earlyoptions[b'repository'] = guess
                                 return _dispatch(req)
                         if not path:
                             raise error.RepoError(
                                 _(
                                     b"no repository found in"
                                     b" '%s' (.hg not found)"
                                 )
                                 % encoding.getcwd()
                             )
                         raise
             if repo:
                 ui = repo.ui
                 if options[b'hidden']:
                     repo = repo.unfiltered()
             args.insert(0, repo)
         elif rpath:
             ui.warn(_(b"warning: --repository ignored\n"))
 
         msg = _formatargs(fullargs)
         ui.log(b"command", b'%s\n', msg)
         strcmdopt = pycompat.strkwargs(cmdoptions)
         d = lambda: util.checksignature(func)(ui, *args, **strcmdopt)
         try:
             return runcommand(
                 lui, repo, cmd, fullargs, ui, options, d, cmdpats, cmdoptions
             )
         finally:
             if repo and repo != req.repo:
                 repo.close()
 
 
 def _runcommand(ui, options, cmd, cmdfunc):
     """Run a command function, possibly with profiling enabled."""
     try:
         with tracing.log("Running %s command" % cmd):
             return cmdfunc()
     except error.SignatureError:
         raise error.CommandError(cmd, _(b'invalid arguments'))
 
 
 def _exceptionwarning(ui):
     """Produce a warning message for the current active exception"""
 
     # For compatibility checking, we discard the portion of the hg
     # version after the + on the assumption that if a "normal
     # user" is running a build with a + in it the packager
     # probably built from fairly close to a tag and anyone with a
     # 'make local' copy of hg (where the version number can be out
     # of date) will be clueful enough to notice the implausible
     # version number and try updating.
     ct = util.versiontuple(n=2)
     worst = None, ct, b''
     if ui.config(b'ui', b'supportcontact') is None:
         for name, mod in extensions.extensions():
             # 'testedwith' should be bytes, but not all extensions are ported
             # to py3 and we don't want UnicodeException because of that.
             testedwith = stringutil.forcebytestr(
                 getattr(mod, 'testedwith', b'')
             )
             report = getattr(mod, 'buglink', _(b'the extension author.'))
             if not testedwith.strip():
                 # We found an untested extension. It's likely the culprit.
                 worst = name, b'unknown', report
                 break
 
             # Never blame on extensions bundled with Mercurial.
             if extensions.ismoduleinternal(mod):
                 continue
 
             tested = [util.versiontuple(t, 2) for t in testedwith.split()]
             if ct in tested:
                 continue
 
             lower = [t for t in tested if t < ct]
             nearest = max(lower or tested)
             if worst[0] is None or nearest < worst[1]:
                 worst = name, nearest, report
     if worst[0] is not None:
         name, testedwith, report = worst
         if not isinstance(testedwith, (bytes, str)):
             testedwith = b'.'.join(
                 [stringutil.forcebytestr(c) for c in testedwith]
             )
         warning = _(
             b'** Unknown exception encountered with '
             b'possibly-broken third-party extension %s\n'
             b'** which supports versions %s of Mercurial.\n'
             b'** Please disable %s and try your action again.\n'
             b'** If that fixes the bug please report it to %s\n'
         ) % (name, testedwith, name, stringutil.forcebytestr(report))
     else:
         bugtracker = ui.config(b'ui', b'supportcontact')
         if bugtracker is None:
             bugtracker = _(b"https://mercurial-scm.org/wiki/BugTracker")
         warning = (
             _(
                 b"** unknown exception encountered, "
                 b"please report by visiting\n** "
             )
             + bugtracker
             + b'\n'
         )
     sysversion = pycompat.sysbytes(sys.version).replace(b'\n', b'')
     warning += (
         (_(b"** Python %s\n") % sysversion)
         + (_(b"** Mercurial Distributed SCM (version %s)\n") % util.version())
         + (
             _(b"** Extensions loaded: %s\n")
             % b", ".join([x[0] for x in extensions.extensions()])
         )
     )
     return warning
 
 
 def handlecommandexception(ui):
     """Produce a warning message for broken commands
 
     Called when handling an exception; the exception is reraised if
     this function returns False, ignored otherwise.
     """
     warning = _exceptionwarning(ui)
     ui.log(
         b"commandexception",
         b"%s\n%s\n",
         warning,
         pycompat.sysbytes(traceback.format_exc()),
     )
     ui.warn(warning)
     return False  # re-raise the exception

tests/test-dispatch.t

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

tests/test-globalopts.t

@@ -1,562 +1,562 b''
   $ hg init a
   $ cd a
   $ echo a > a
   $ hg ci -A -d'1 0' -m a
   adding a
 
   $ cd ..
 
   $ hg init b
   $ cd b
   $ echo b > b
   $ hg ci -A -d'1 0' -m b
   adding b
 
   $ cd ..
 
   $ hg clone a c
   updating to branch default
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd c
   $ cat >> .hg/hgrc <<EOF
   > [paths]
   > relative = ../a
   > EOF
   $ hg pull -f ../b
   pulling from ../b
   searching for changes
   warning: repository is unrelated
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files (+1 heads)
   new changesets b6c483daf290
   (run 'hg heads' to see heads, 'hg merge' to merge)
   $ hg merge
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
 
   $ cd ..
 
 Testing -R/--repository:
 
   $ hg -R a tip
   changeset:   0:8580ff50825a
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:01 1970 +0000
   summary:     a
   
   $ hg --repository b tip
   changeset:   0:b6c483daf290
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:01 1970 +0000
   summary:     b
   
 
 -R with a URL:
 
   $ hg -R file:a identify
   8580ff50825a tip
   $ hg -R file://localhost/`pwd`/a/ identify
   8580ff50825a tip
 
 -R with path aliases:
 
   $ cd c
   $ hg -R default identify
   8580ff50825a tip
   $ hg -R relative identify
   8580ff50825a tip
   $ echo '[paths]' >> $HGRCPATH
   $ echo 'relativetohome = a' >> $HGRCPATH
   $ HOME=`pwd`/../ hg -R relativetohome identify
   8580ff50825a tip
   $ cd ..
 
 #if no-outer-repo
 
 Implicit -R:
 
   $ hg ann a/a
   0: a
   $ hg ann a/a a/a
   0: a
   $ hg ann a/a b/b
   abort: no repository found in '$TESTTMP' (.hg not found)
   [255]
   $ hg -R b ann a/a
   abort: a/a not under root '$TESTTMP/b'
   (consider using '--cwd b')
   [255]
   $ hg log
   abort: no repository found in '$TESTTMP' (.hg not found)
   [255]
 
 #endif
 
 Abbreviation of long option:
 
   $ hg --repo c tip
   changeset:   1:b6c483daf290
   tag:         tip
   parent:      -1:000000000000
   user:        test
   date:        Thu Jan 01 00:00:01 1970 +0000
   summary:     b
   
 
 earlygetopt with duplicate options (36d23de02da1):
 
   $ hg --cwd a --cwd b --cwd c tip
   changeset:   1:b6c483daf290
   tag:         tip
   parent:      -1:000000000000
   user:        test
   date:        Thu Jan 01 00:00:01 1970 +0000
   summary:     b
   
   $ hg --repo c --repository b -R a tip
   changeset:   0:8580ff50825a
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:01 1970 +0000
   summary:     a
   
 
 earlygetopt short option without following space:
 
   $ hg -q -Rb tip
   0:b6c483daf290
 
 earlygetopt with illegal abbreviations:
 
   $ hg --confi "foo.bar=baz"
-  abort: option --config may not be abbreviated!
+  abort: option --config may not be abbreviated
   [255]
   $ hg --cw a tip
-  abort: option --cwd may not be abbreviated!
+  abort: option --cwd may not be abbreviated
   [255]
   $ hg --rep a tip
-  abort: option -R has to be separated from other options (e.g. not -qR) and --repository may only be abbreviated as --repo!
+  abort: option -R has to be separated from other options (e.g. not -qR) and --repository may only be abbreviated as --repo
   [255]
   $ hg --repositor a tip
-  abort: option -R has to be separated from other options (e.g. not -qR) and --repository may only be abbreviated as --repo!
+  abort: option -R has to be separated from other options (e.g. not -qR) and --repository may only be abbreviated as --repo
   [255]
   $ hg -qR a tip
-  abort: option -R has to be separated from other options (e.g. not -qR) and --repository may only be abbreviated as --repo!
+  abort: option -R has to be separated from other options (e.g. not -qR) and --repository may only be abbreviated as --repo
   [255]
   $ hg -qRa tip
-  abort: option -R has to be separated from other options (e.g. not -qR) and --repository may only be abbreviated as --repo!
+  abort: option -R has to be separated from other options (e.g. not -qR) and --repository may only be abbreviated as --repo
   [255]
 
 Testing --cwd:
 
   $ hg --cwd a parents
   changeset:   0:8580ff50825a
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:01 1970 +0000
   summary:     a
   
 
 Testing -y/--noninteractive - just be sure it is parsed:
 
   $ hg --cwd a tip -q --noninteractive
   0:8580ff50825a
   $ hg --cwd a tip -q -y
   0:8580ff50825a
 
 Testing -q/--quiet:
 
   $ hg -R a -q tip
   0:8580ff50825a
   $ hg -R b -q tip
   0:b6c483daf290
   $ hg -R c --quiet parents
   0:8580ff50825a
   1:b6c483daf290
 
 Testing -v/--verbose:
 
   $ hg --cwd c head -v
   changeset:   1:b6c483daf290
   tag:         tip
   parent:      -1:000000000000
   user:        test
   date:        Thu Jan 01 00:00:01 1970 +0000
   files:       b
   description:
   b
   
   
   changeset:   0:8580ff50825a
   user:        test
   date:        Thu Jan 01 00:00:01 1970 +0000
   files:       a
   description:
   a
   
   
   $ hg --cwd b tip --verbose
   changeset:   0:b6c483daf290
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:01 1970 +0000
   files:       b
   description:
   b
   
   
 
 Testing --config:
 
   $ hg --cwd c --config paths.quuxfoo=bar paths | grep quuxfoo > /dev/null && echo quuxfoo
   quuxfoo
   $ hg --cwd c --config '' tip -q
   abort: malformed --config option: '' (use --config section.name=value)
   [255]
   $ hg --cwd c --config a.b tip -q
   abort: malformed --config option: 'a.b' (use --config section.name=value)
   [255]
   $ hg --cwd c --config a tip -q
   abort: malformed --config option: 'a' (use --config section.name=value)
   [255]
   $ hg --cwd c --config a.= tip -q
   abort: malformed --config option: 'a.=' (use --config section.name=value)
   [255]
   $ hg --cwd c --config .b= tip -q
   abort: malformed --config option: '.b=' (use --config section.name=value)
   [255]
 
 Testing --debug:
 
   $ hg --cwd c log --debug
   changeset:   1:b6c483daf2907ce5825c0bb50f5716226281cc1a
   tag:         tip
   phase:       public
   parent:      -1:0000000000000000000000000000000000000000
   parent:      -1:0000000000000000000000000000000000000000
   manifest:    1:23226e7a252cacdc2d99e4fbdc3653441056de49
   user:        test
   date:        Thu Jan 01 00:00:01 1970 +0000
   files+:      b
   extra:       branch=default
   description:
   b
   
   
   changeset:   0:8580ff50825a50c8f716709acdf8de0deddcd6ab
   phase:       public
   parent:      -1:0000000000000000000000000000000000000000
   parent:      -1:0000000000000000000000000000000000000000
   manifest:    0:a0c8bcbbb45c63b90b70ad007bf38961f64f2af0
   user:        test
   date:        Thu Jan 01 00:00:01 1970 +0000
   files+:      a
   extra:       branch=default
   description:
   a
   
   
 
 Testing --traceback:
 
 #if no-chg
   $ hg --cwd c --config x --traceback id 2>&1 | grep -i 'traceback'
   Traceback (most recent call last):
   Traceback (most recent call last): (py3 !)
 #else
 Traceback for '--config' errors not supported with chg.
   $ hg --cwd c --config x --traceback id 2>&1 | grep -i 'traceback'
   [1]
 #endif
 
 Testing --time:
 
   $ hg --cwd a --time id
   8580ff50825a tip
   time: real * (glob)
 
 Testing --version:
 
   $ hg --version -q
   Mercurial Distributed SCM * (glob)
 
 hide outer repo
   $ hg init
 
 Testing -h/--help:
 
 #if no-extraextensions
 
   $ hg -h
   Mercurial Distributed SCM
   
   list of commands:
   
   Repository creation:
   
    clone         make a copy of an existing repository
    init          create a new repository in the given directory
   
   Remote repository management:
   
    incoming      show new changesets found in source
    outgoing      show changesets not found in the destination
    paths         show aliases for remote repositories
    pull          pull changes from the specified source
    push          push changes to the specified destination
    serve         start stand-alone webserver
   
   Change creation:
   
    commit        commit the specified files or all outstanding changes
   
   Change manipulation:
   
    backout       reverse effect of earlier changeset
    graft         copy changes from other branches onto the current branch
    merge         merge another revision into working directory
   
   Change organization:
   
    bookmarks     create a new bookmark or list existing bookmarks
    branch        set or show the current branch name
    branches      list repository named branches
    phase         set or show the current phase name
    tag           add one or more tags for the current or given revision
    tags          list repository tags
   
   File content management:
   
    annotate      show changeset information by line for each file
    cat           output the current or given revision of files
    copy          mark files as copied for the next commit
    diff          diff repository (or selected files)
    grep          search for a pattern in specified files
   
   Change navigation:
   
    bisect        subdivision search of changesets
    heads         show branch heads
    identify      identify the working directory or specified revision
    log           show revision history of entire repository or files
   
   Working directory management:
   
    add           add the specified files on the next commit
    addremove     add all new files, delete all missing files
    files         list tracked files
    forget        forget the specified files on the next commit
    remove        remove the specified files on the next commit
    rename        rename files; equivalent of copy + remove
    resolve       redo merges or set/view the merge status of files
    revert        restore files to their checkout state
    root          print the root (top) of the current working directory
    shelve        save and set aside changes from the working directory
    status        show changed files in the working directory
    summary       summarize working directory state
    unshelve      restore a shelved change to the working directory
    update        update working directory (or switch revisions)
   
   Change import/export:
   
    archive       create an unversioned archive of a repository revision
    bundle        create a bundle file
    export        dump the header and diffs for one or more changesets
    import        import an ordered set of patches
    unbundle      apply one or more bundle files
   
   Repository maintenance:
   
    manifest      output the current or given revision of the project manifest
    recover       roll back an interrupted transaction
    verify        verify the integrity of the repository
   
   Help:
   
    config        show combined config settings from all hgrc files
    help          show help for a given topic or a help overview
    version       output version and copyright information
   
   additional help topics:
   
   Mercurial identifiers:
   
    filesets      Specifying File Sets
    hgignore      Syntax for Mercurial Ignore Files
    patterns      File Name Patterns
    revisions     Specifying Revisions
    urls          URL Paths
   
   Mercurial output:
   
    color         Colorizing Outputs
    dates         Date Formats
    diffs         Diff Formats
    templating    Template Usage
   
   Mercurial configuration:
   
    config        Configuration Files
    environment   Environment Variables
    extensions    Using Additional Features
    flags         Command-line flags
    hgweb         Configuring hgweb
    merge-tools   Merge Tools
    pager         Pager Support
   
   Concepts:
   
    bundlespec    Bundle File Formats
    glossary      Glossary
    phases        Working with Phases
    subrepos      Subrepositories
   
   Miscellaneous:
   
    deprecated    Deprecated Features
    internals     Technical implementation topics
    scripting     Using Mercurial from scripts and automation
   
   (use 'hg help -v' to show built-in aliases and global options)
 
   $ hg --help
   Mercurial Distributed SCM
   
   list of commands:
   
   Repository creation:
   
    clone         make a copy of an existing repository
    init          create a new repository in the given directory
   
   Remote repository management:
   
    incoming      show new changesets found in source
    outgoing      show changesets not found in the destination
    paths         show aliases for remote repositories
    pull          pull changes from the specified source
    push          push changes to the specified destination
    serve         start stand-alone webserver
   
   Change creation:
   
    commit        commit the specified files or all outstanding changes
   
   Change manipulation:
   
    backout       reverse effect of earlier changeset
    graft         copy changes from other branches onto the current branch
    merge         merge another revision into working directory
   
   Change organization:
   
    bookmarks     create a new bookmark or list existing bookmarks
    branch        set or show the current branch name
    branches      list repository named branches
    phase         set or show the current phase name
    tag           add one or more tags for the current or given revision
    tags          list repository tags
   
   File content management:
   
    annotate      show changeset information by line for each file
    cat           output the current or given revision of files
    copy          mark files as copied for the next commit
    diff          diff repository (or selected files)
    grep          search for a pattern in specified files
   
   Change navigation:
   
    bisect        subdivision search of changesets
    heads         show branch heads
    identify      identify the working directory or specified revision
    log           show revision history of entire repository or files
   
   Working directory management:
   
    add           add the specified files on the next commit
    addremove     add all new files, delete all missing files
    files         list tracked files
    forget        forget the specified files on the next commit
    remove        remove the specified files on the next commit
    rename        rename files; equivalent of copy + remove
    resolve       redo merges or set/view the merge status of files
    revert        restore files to their checkout state
    root          print the root (top) of the current working directory
    shelve        save and set aside changes from the working directory
    status        show changed files in the working directory
    summary       summarize working directory state
    unshelve      restore a shelved change to the working directory
    update        update working directory (or switch revisions)
   
   Change import/export:
   
    archive       create an unversioned archive of a repository revision
    bundle        create a bundle file
    export        dump the header and diffs for one or more changesets
    import        import an ordered set of patches
    unbundle      apply one or more bundle files
   
   Repository maintenance:
   
    manifest      output the current or given revision of the project manifest
    recover       roll back an interrupted transaction
    verify        verify the integrity of the repository
   
   Help:
   
    config        show combined config settings from all hgrc files
    help          show help for a given topic or a help overview
    version       output version and copyright information
   
   additional help topics:
   
   Mercurial identifiers:
   
    filesets      Specifying File Sets
    hgignore      Syntax for Mercurial Ignore Files
    patterns      File Name Patterns
    revisions     Specifying Revisions
    urls          URL Paths
   
   Mercurial output:
   
    color         Colorizing Outputs
    dates         Date Formats
    diffs         Diff Formats
    templating    Template Usage
   
   Mercurial configuration:
   
    config        Configuration Files
    environment   Environment Variables
    extensions    Using Additional Features
    flags         Command-line flags
    hgweb         Configuring hgweb
    merge-tools   Merge Tools
    pager         Pager Support
   
   Concepts:
   
    bundlespec    Bundle File Formats
    glossary      Glossary
    phases        Working with Phases
    subrepos      Subrepositories
   
   Miscellaneous:
   
    deprecated    Deprecated Features
    internals     Technical implementation topics
    scripting     Using Mercurial from scripts and automation
   
   (use 'hg help -v' to show built-in aliases and global options)
 
 #endif
 
 Not tested: --debugger