Move alias into core

doc/hgrc.5.txt

@@ -100,6 +100,29 b' This section describes the different sec'
 Mercurial "hgrc" file, the purpose of each section, its possible
 keys, and their possible values.
 
+[[alias]]
+alias::
+ Defines command aliases.
+  Aliases allow you to define your own commands in terms of other
+  commands (or aliases), optionally including arguments.
++
+Alias definitions consist of lines of the form:
++
+    <alias> = <command> [<argument]...
++
+For example, this definition:
++
+    latest = log --limit 5
++
+creates a new command `latest` that shows only the five most recent
+changesets. You can define subsequent aliases using earlier ones:
++
+    stable5 = latest -b stable
++
+*Note*: It is possible to create aliases with the same names as
+existing commands, which will then override the original
+definitions. This is almost always a bad idea!
+
 [[auth]]
 auth::
   Authentication credentials for HTTP authentication.

mercurial/dispatch.py

@@ -161,6 +161,74 b' def _findrepo(p):'
 
     return p
 
+def aliasargs(fn):
+    if hasattr(fn, 'args'):
+        return fn.args
+    return []
+
+class cmdalias(object):
+    def __init__(self, name, definition, cmdtable):
+        self.name = name
+        self.definition = definition
+        self.args = []
+        self.opts = []
+        self.help = ''
+        self.norepo = True
+
+        try:
+            cmdutil.findcmd(self.name, cmdtable, True)
+            self.shadows = True
+        except error.UnknownCommand:
+            self.shadows = False
+
+        if not self.definition:
+            def fn(ui, *args):
+                ui.warn(_("no definition for alias '%s'\n") % self.name)
+                return 1
+            self.fn = fn
+
+            return
+
+        args = shlex.split(self.definition)
+        cmd = args.pop(0)
+        opts = []
+        help = ''
+
+        try:
+            self.fn, self.opts, self.help = cmdutil.findcmd(cmd, cmdtable, False)[1]
+            self.args = aliasargs(self.fn) + args
+            if cmd not in commands.norepo.split(' '):
+                self.norepo = False
+        except error.UnknownCommand:
+            def fn(ui, *args):
+                ui.warn(_("alias '%s' resolves to unknown command '%s'\n") \
+                            % (self.name, cmd))
+                return 1
+            self.fn = fn
+        except error.AmbiguousCommand:
+            def fn(ui, *args):
+                ui.warn(_("alias '%s' resolves to ambiguous command '%s'\n") \
+                            % (self.name, cmd))
+                return 1
+            self.fn = fn
+
+    def __call__(self, ui, *args, **opts):
+        if self.shadows:
+            ui.debug(_("alias '%s' shadows command\n") % self.name)
+
+        return self.fn(ui, *args, **opts)
+
+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('alias'):
+        aliasdef = cmdalias(alias, definition, cmdtable)
+        
+        cmdtable[alias] = (aliasdef, aliasdef.opts, aliasdef.help)
+        if aliasdef.norepo:
+            commands.norepo += ' %s' % alias
+
 def _parse(ui, args):
     options = {}
     cmdoptions = {}
@@ -175,6 +243,7 b' def _parse(ui, args):'
         aliases, i = cmdutil.findcmd(cmd, commands.table,
                                      ui.config("ui", "strict"))
         cmd = aliases[0]
+        args = aliasargs(i[0]) + args
         defaults = ui.config("defaults", cmd)
         if defaults:
             args = shlex.split(defaults) + args
@@ -301,6 +370,9 b' def _dispatch(ui, args):'
                     % (name, " ".join(overrides)))
         commands.table.update(cmdtable)
         _loaded.add(name)
+
+    addaliases(lui, commands.table)
+
     # check for fallback encoding
     fallback = lui.config('ui', 'fallbackencoding')
     if fallback:

tests/test-alias

@@ -1,18 +1,17 b''
 #!/bin/sh
 
 cat >> $HGRCPATH <<EOF
-[extensions]
-alias=
-
 [alias]
 myinit = init
 cleanstatus = status -c
 unknown = bargle
 ambiguous = s
 recursive = recursive
+nodefinition =
 mylog = log
 lognull = log -r null
 shortlog = log --template '{rev} {node|short} | {date|isodate}\n'
+dln = lognull --debug
 
 [defaults]
 mylog = -q
@@ -32,6 +31,9 b' hg ambiguous'
 echo '% recursive'
 hg recursive
 
+echo '% no definition'
+hg nodef
+
 cd alias
 echo foo > foo
 hg ci -Amfoo
@@ -45,3 +47,6 b' hg shortlog'
 echo '% interaction with defaults'
 hg mylog
 hg lognull
+
+echo '% properly recursive'
+hg dln

tests/test-alias.out

@@ -1,10 +1,12 b''
 % basic
 % unknown
-*** [alias] unknown: command bargle is unknown
+alias 'unknown' resolves to unknown command 'bargle'
 % ambiguous
-*** [alias] ambiguous: command s is ambiguous
+alias 'ambiguous' resolves to ambiguous command 's'
 % recursive
-*** [alias] recursive: circular dependency on recursive
+alias 'recursive' resolves to unknown command 'recursive'
+% no definition
+no definition for alias 'nodefinition'
 adding foo
 % with opts
 C foo
@@ -13,3 +15,12 b' 0 e63c23eaa88a | 1970-01-01 00:00 +0000'
 % interaction with defaults
 0:e63c23eaa88a
 -1:000000000000
+% properly recursive
+changeset:   -1:0000000000000000000000000000000000000000
+parent:      -1:0000000000000000000000000000000000000000
+parent:      -1:0000000000000000000000000000000000000000
+manifest:    -1:0000000000000000000000000000000000000000
+user:        
+date:        Thu Jan 01 00:00:00 1970 +0000
+extra:       branch=default
+