errors: raise ConfigError on bad alias definition

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

mercurial/dispatch.py

@@ -1,1324 +1,1324
 # 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)
+            raise error.ConfigError(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"))
         if options[b"cwd"] != req.earlyoptions[b"cwd"]:
             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"
                 )
             )
         if options[b"debugger"] != req.earlyoptions[b"debugger"]:
             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.InputError(
                             _(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.InputError(
                                 _(
                                     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-alias.t

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