registrar: add templatefunc to mark a function as template function (API)

This patch also adds loadfunction() to templater, because this
combination helps to figure out how they cooperate with each other.

Listing up loadfunction() in dispatch.extraloaders causes implicit
loading template function at loading (3rd party) extension.

This patch explicitly tests whether templatefunc decorator works as
expected, because there is no bundled extension, which defines
template function.

This change requires that "templatefunc" attribute of (3rd party)
extension is registrar.templatefunc or so.

mercurial/dispatch.py

@@ -1,1066 +1,1068 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 atexit
 import difflib
 import errno
 import os
 import pdb
 import re
 import shlex
 import signal
 import socket
 import sys
 import time
 import traceback
 
 
 from .i18n import _
 
 from . import (
     cmdutil,
     commands,
     demandimport,
     encoding,
     error,
     extensions,
     fancyopts,
     fileset,
     hg,
     hook,
     revset,
     templatefilters,
     templatekw,
+    templater,
     ui as uimod,
     util,
 )
 
 class request(object):
     def __init__(self, args, ui=None, repo=None, fin=None, fout=None,
                  ferr=None):
         self.args = args
         self.ui = ui
         self.repo = repo
 
         # input/output/error streams
         self.fin = fin
         self.fout = fout
         self.ferr = ferr
 
 def run():
     "run the command in sys.argv"
     sys.exit((dispatch(request(sys.argv[1:])) or 0) & 255)
 
 def _getsimilar(symbols, value):
     sim = lambda x: difflib.SequenceMatcher(None, value, x).ratio()
     # The cutoff for similarity here is pretty arbitrary. It should
     # probably be investigated and tweaked.
     return [s for s in symbols if sim(s) > 0.6]
 
 def _reportsimilar(write, similar):
     if len(similar) == 1:
         write(_("(did you mean %s?)\n") % similar[0])
     elif similar:
         ss = ", ".join(sorted(similar))
         write(_("(did you mean one of %s?)\n") % ss)
 
 def _formatparse(write, inst):
     similar = []
     if isinstance(inst, error.UnknownIdentifier):
         # make sure to check fileset first, as revset can invoke fileset
         similar = _getsimilar(inst.symbols, inst.function)
     if len(inst.args) > 1:
         write(_("hg: parse error at %s: %s\n") %
                          (inst.args[1], inst.args[0]))
         if (inst.args[0][0] == ' '):
             write(_("unexpected leading whitespace\n"))
     else:
         write(_("hg: parse error: %s\n") % inst.args[0])
         _reportsimilar(write, similar)
     if inst.hint:
         write(_("(%s)\n") % inst.hint)
 
 def dispatch(req):
     "run the command specified in req.args"
     if req.ferr:
         ferr = req.ferr
     elif req.ui:
         ferr = req.ui.ferr
     else:
         ferr = sys.stderr
 
     try:
         if not req.ui:
             req.ui = uimod.ui()
         if '--traceback' in req.args:
             req.ui.setconfig('ui', 'traceback', 'on', '--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
     except error.Abort as inst:
         ferr.write(_("abort: %s\n") % inst)
         if inst.hint:
             ferr.write(_("(%s)\n") % inst.hint)
         return -1
     except error.ParseError as inst:
         _formatparse(ferr.write, inst)
         return -1
 
     msg = ' '.join(' ' in a and repr(a) or a for a in req.args)
     starttime = time.time()
     ret = None
     try:
         ret = _runcatch(req)
     except KeyboardInterrupt:
         try:
             req.ui.warn(_("interrupted!\n"))
         except IOError as inst:
             if inst.errno != errno.EPIPE:
                 raise
         ret = -1
     finally:
         duration = time.time() - starttime
         req.ui.flush()
         req.ui.log("commandfinish", "%s exited %s after %0.2f seconds\n",
                    msg, ret or 0, duration)
     return ret
 
 def _runcatch(req):
     def catchterm(*args):
         raise error.SignalInterrupt
 
     ui = req.ui
     try:
         for name in 'SIGBREAK', 'SIGHUP', 'SIGTERM':
             num = getattr(signal, name, None)
             if num:
                 signal.signal(num, catchterm)
     except ValueError:
         pass # happens if called in a thread
 
     try:
         try:
             debugger = 'pdb'
             debugtrace = {
                 'pdb' : pdb.set_trace
             }
             debugmortem = {
                 'pdb' : pdb.post_mortem
             }
 
             # read --config before doing anything else
             # (e.g. to change trust settings for reading .hg/hgrc)
             cfgs = _parseconfig(req.ui, _earlygetopt(['--config'], req.args))
 
             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='--config')
 
             # developer config: ui.debugger
             debugger = ui.config("ui", "debugger")
             debugmod = pdb
             if not debugger or ui.plain():
                 # if we are in HGPLAIN mode, then disable custom debugging
                 debugger = 'pdb'
             elif '--debugger' in req.args:
                 # 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 '--debugger' in req.args:
                 ui.warn(_("entering debugger - "
                         "type c to continue starting hg or h for help\n"))
 
                 if (debugger != 'pdb' and
                     debugtrace[debugger] == debugtrace['pdb']):
                     ui.warn(_("%s debugger specified "
                               "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 '--debugger' in req.args:
                 traceback.print_exc()
                 debugmortem[debugger](sys.exc_info()[2])
             ui.traceback()
             raise
 
     # Global exception handling, alphabetically
     # Mercurial-specific first, followed by built-in and library exceptions
     except error.AmbiguousCommand as inst:
         ui.warn(_("hg: command '%s' is ambiguous:\n    %s\n") %
                 (inst.args[0], " ".join(inst.args[1])))
     except error.ParseError as inst:
         _formatparse(ui.warn, inst)
         return -1
     except error.LockHeld as inst:
         if inst.errno == errno.ETIMEDOUT:
             reason = _('timed out waiting for lock held by %s') % inst.locker
         else:
             reason = _('lock held by %s') % inst.locker
         ui.warn(_("abort: %s: %s\n") % (inst.desc or inst.filename, reason))
     except error.LockUnavailable as inst:
         ui.warn(_("abort: could not lock %s: %s\n") %
                (inst.desc or inst.filename, inst.strerror))
     except error.CommandError as inst:
         if inst.args[0]:
             ui.warn(_("hg %s: %s\n") % (inst.args[0], inst.args[1]))
             commands.help_(ui, inst.args[0], full=False, command=True)
         else:
             ui.warn(_("hg: %s\n") % inst.args[1])
             commands.help_(ui, 'shortlist')
     except error.OutOfBandError as inst:
         if inst.args:
             msg = _("abort: remote error:\n")
         else:
             msg = _("abort: remote error\n")
         ui.warn(msg)
         if inst.args:
             ui.warn(''.join(inst.args))
         if inst.hint:
             ui.warn('(%s)\n' % inst.hint)
     except error.RepoError as inst:
         ui.warn(_("abort: %s!\n") % inst)
         if inst.hint:
             ui.warn(_("(%s)\n") % inst.hint)
     except error.ResponseError as inst:
         ui.warn(_("abort: %s") % inst.args[0])
         if not isinstance(inst.args[1], basestring):
             ui.warn(" %r\n" % (inst.args[1],))
         elif not inst.args[1]:
             ui.warn(_(" empty string\n"))
         else:
             ui.warn("\n%r\n" % util.ellipsis(inst.args[1]))
     except error.CensoredNodeError as inst:
         ui.warn(_("abort: file censored %s!\n") % inst)
     except error.RevlogError as inst:
         ui.warn(_("abort: %s!\n") % inst)
     except error.SignalInterrupt:
         ui.warn(_("killed!\n"))
     except error.UnknownCommand as inst:
         ui.warn(_("hg: unknown command '%s'\n") % inst.args[0])
         try:
             # check if the command is in a disabled extension
             # (but don't check for extensions themselves)
             commands.help_(ui, inst.args[0], unknowncmd=True)
         except (error.UnknownCommand, error.Abort):
             suggested = False
             if len(inst.args) == 2:
                 sim = _getsimilar(inst.args[1], inst.args[0])
                 if sim:
                     _reportsimilar(ui.warn, sim)
                     suggested = True
             if not suggested:
                 commands.help_(ui, 'shortlist')
     except error.InterventionRequired as inst:
         ui.warn("%s\n" % inst)
         if inst.hint:
             ui.warn(_("(%s)\n") % inst.hint)
         return 1
     except error.Abort as inst:
         ui.warn(_("abort: %s\n") % inst)
         if inst.hint:
             ui.warn(_("(%s)\n") % inst.hint)
     except ImportError as inst:
         ui.warn(_("abort: %s!\n") % inst)
         m = str(inst).split()[-1]
         if m in "mpatch bdiff".split():
             ui.warn(_("(did you forget to compile extensions?)\n"))
         elif m in "zlib".split():
             ui.warn(_("(is your Python install correct?)\n"))
     except IOError as inst:
         if util.safehasattr(inst, "code"):
             ui.warn(_("abort: %s\n") % inst)
         elif util.safehasattr(inst, "reason"):
             try: # usually it is in the form (errno, strerror)
                 reason = inst.reason.args[1]
             except (AttributeError, IndexError):
                 # it might be anything, for example a string
                 reason = inst.reason
             if isinstance(reason, unicode):
                 # SSLError of Python 2.7.9 contains a unicode
                 reason = reason.encode(encoding.encoding, 'replace')
             ui.warn(_("abort: error: %s\n") % reason)
         elif (util.safehasattr(inst, "args")
               and inst.args and inst.args[0] == errno.EPIPE):
             pass
         elif getattr(inst, "strerror", None):
             if getattr(inst, "filename", None):
                 ui.warn(_("abort: %s: %s\n") % (inst.strerror, inst.filename))
             else:
                 ui.warn(_("abort: %s\n") % inst.strerror)
         else:
             raise
     except OSError as inst:
         if getattr(inst, "filename", None) is not None:
             ui.warn(_("abort: %s: '%s'\n") % (inst.strerror, inst.filename))
         else:
             ui.warn(_("abort: %s\n") % inst.strerror)
     except KeyboardInterrupt:
         raise
     except MemoryError:
         ui.warn(_("abort: out of memory\n"))
     except SystemExit as inst:
         # Commands shouldn't sys.exit directly, but give a return code.
         # Just in case catch this and and pass exit code to caller.
         return inst.code
     except socket.error as inst:
         ui.warn(_("abort: %s\n") % inst.args[-1])
     except: # re-raises
         # 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, ''
         if ui.config('ui', 'supportcontact', None) is None:
             for name, mod in extensions.extensions():
                 testedwith = getattr(mod, 'testedwith', '')
                 report = getattr(mod, 'buglink', _('the extension author.'))
                 if not testedwith.strip():
                     # We found an untested extension. It's likely the culprit.
                     worst = name, 'unknown', report
                     break
 
                 # Never blame on extensions bundled with Mercurial.
                 if testedwith == 'internal':
                     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, str):
                 testedwith = '.'.join([str(c) for c in testedwith])
             warning = (_('** Unknown exception encountered with '
                          'possibly-broken third-party extension %s\n'
                          '** which supports versions %s of Mercurial.\n'
                          '** Please disable %s and try your action again.\n'
                          '** If that fixes the bug please report it to %s\n')
                        % (name, testedwith, name, report))
         else:
             bugtracker = ui.config('ui', 'supportcontact', None)
             if bugtracker is None:
                 bugtracker = _("https://mercurial-scm.org/wiki/BugTracker")
             warning = (_("** unknown exception encountered, "
                          "please report by visiting\n** ") + bugtracker + '\n')
         warning += ((_("** Python %s\n") % sys.version.replace('\n', '')) +
                     (_("** Mercurial Distributed SCM (version %s)\n") %
                      util.version()) +
                     (_("** Extensions loaded: %s\n") %
                      ", ".join([x[0] for x in extensions.extensions()])))
         ui.log("commandexception", "%s\n%s\n", warning, traceback.format_exc())
         ui.warn(warning)
         raise
 
     return -1
 
 def aliasargs(fn, givenargs):
     args = getattr(fn, 'args', [])
     if args:
         cmd = ' '.join(map(util.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(_('too few arguments for command alias'))
         cmd = re.sub(r'\$(\d+|\$)', replacer, cmd)
         givenargs = [x for i, x in enumerate(givenargs)
                      if i not in nums]
         args = shlex.split(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 = dict(('$%d' % (i + 1), arg) for i, arg in enumerate(args))
     replacemap['$0'] = name
     replacemap['$$'] = '$'
     replacemap['$@'] = ' '.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['"$@"'] = ' '.join(util.shellquote(arg) for arg in args)
     # escape '\$' for regex
     regex = '|'.join(replacemap.keys()).replace('$', r'\$')
     r = re.compile(regex)
     return r.sub(lambda x: replacemap[x.group()], cmd)
 
 class cmdalias(object):
     def __init__(self, name, definition, cmdtable):
         self.name = self.cmd = name
         self.cmdname = ''
         self.definition = definition
         self.fn = None
         self.args = []
         self.opts = []
         self.help = ''
         self.badalias = None
         self.unknowncmd = False
 
         try:
             aliases, entry = cmdutil.findcmd(self.name, cmdtable)
             for alias, e in cmdtable.iteritems():
                 if e is entry:
                     self.cmd = alias
                     break
             self.shadows = True
         except error.UnknownCommand:
             self.shadows = False
 
         if not self.definition:
             self.badalias = _("no definition for alias '%s'") % self.name
             return
 
         if self.definition.startswith('!'):
             self.shell = True
             def fn(ui, *args):
                 env = {'HG_ARGS': ' '.join((self.name,) + args)}
                 def _checkvar(m):
                     if m.groups()[0] == '$':
                         return m.group()
                     elif int(m.groups()[0]) <= len(args):
                         return m.group()
                     else:
                         ui.debug("No argument found for substitution "
                                  "of %i variable in alias '%s' definition."
                                  % (int(m.groups()[0]), self.name))
                         return ''
                 cmd = re.sub(r'\$(\d+|\$)', _checkvar, self.definition[1:])
                 cmd = aliasinterpolate(self.name, args, cmd)
                 return ui.system(cmd, environ=env)
             self.fn = fn
             return
 
         try:
             args = shlex.split(self.definition)
         except ValueError as inst:
             self.badalias = (_("error in definition for alias '%s': %s")
                              % (self.name, inst))
             return
         self.cmdname = cmd = args.pop(0)
         args = map(util.expandpath, args)
 
         for invalidarg in ("--cwd", "-R", "--repository", "--repo", "--config"):
             if _earlygetopt([invalidarg], args):
                 self.badalias = (_("error in definition for alias '%s': %s may "
                                    "only be given on the command line")
                                  % (self.name, invalidarg))
                 return
 
         try:
             tableentry = cmdutil.findcmd(cmd, cmdtable, False)[1]
             if len(tableentry) > 2:
                 self.fn, self.opts, self.help = tableentry
             else:
                 self.fn, self.opts = tableentry
 
             self.args = aliasargs(self.fn, args)
             if self.help.startswith("hg " + cmd):
                 # drop prefix in old-style help lines so hg shows the alias
                 self.help = self.help[4 + len(cmd):]
             self.__doc__ = self.fn.__doc__
 
         except error.UnknownCommand:
             self.badalias = (_("alias '%s' resolves to unknown command '%s'")
                              % (self.name, cmd))
             self.unknowncmd = True
         except error.AmbiguousCommand:
             self.badalias = (_("alias '%s' resolves to ambiguous command '%s'")
                              % (self.name, cmd))
 
     def __getattr__(self, name):
         adefaults = {'norepo': True, 'optionalrepo': False, 'inferrepo': False}
         if name not in adefaults:
             raise AttributeError(name)
         if self.badalias or util.safehasattr(self, '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 = _("'%s' is provided by '%s' extension") % (cmd, ext)
                 except error.UnknownCommand:
                     pass
             raise error.Abort(self.badalias, hint=hint)
         if self.shadows:
             ui.debug("alias '%s' shadows command '%s'\n" %
                      (self.name, self.cmdname))
 
         if util.safehasattr(self, 'shell'):
             return self.fn(ui, *args, **opts)
         else:
             try:
                 return util.checksignature(self.fn)(ui, *args, **opts)
             except error.SignatureError:
                 args = ' '.join([self.cmdname] + self.args)
                 ui.debug("alias '%s' expands to '%s'\n" % (self.name, args))
                 raise
 
 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)
 
         try:
             olddef = cmdtable[aliasdef.cmd][0]
             if olddef.definition == aliasdef.definition:
                 continue
         except (KeyError, AttributeError):
             # definition might not exist or it might not be a cmdalias
             pass
 
         cmdtable[aliasdef.name] = (aliasdef, aliasdef.opts, aliasdef.help)
 
 def _parse(ui, args):
     options = {}
     cmdoptions = {}
 
     try:
         args = fancyopts.fancyopts(args, commands.globalopts, options)
     except fancyopts.getopt.GetoptError as inst:
         raise error.CommandError(None, inst)
 
     if args:
         cmd, args = args[0], args[1:]
         aliases, entry = cmdutil.findcmd(cmd, commands.table,
                                          ui.configbool("ui", "strict"))
         cmd = aliases[0]
         args = aliasargs(entry[0], args)
         defaults = ui.config("defaults", cmd)
         if defaults:
             args = map(util.expandpath, shlex.split(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, True)
     except fancyopts.getopt.GetoptError as inst:
         raise error.CommandError(cmd, 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('=', 1)]
             section, name = name.split('.', 1)
             if not section or not name:
                 raise IndexError
             ui.setconfig(section, name, value, '--config')
             configs.append((section, name, value))
         except (IndexError, ValueError):
             raise error.Abort(_('malformed --config option: %r '
                                '(use --config section.name=value)') % cfg)
 
     return configs
 
 def _earlygetopt(aliases, args):
     """Return list of values for an option (or aliases).
 
     The values are listed in the order they appear in args.
     The options and values are removed from args.
 
     >>> args = ['x', '--cwd', 'foo', 'y']
     >>> _earlygetopt(['--cwd'], args), args
     (['foo'], ['x', 'y'])
 
     >>> args = ['x', '--cwd=bar', 'y']
     >>> _earlygetopt(['--cwd'], args), args
     (['bar'], ['x', 'y'])
 
     >>> args = ['x', '-R', 'foo', 'y']
     >>> _earlygetopt(['-R'], args), args
     (['foo'], ['x', 'y'])
 
     >>> args = ['x', '-Rbar', 'y']
     >>> _earlygetopt(['-R'], args), args
     (['bar'], ['x', 'y'])
     """
     try:
         argcount = args.index("--")
     except ValueError:
         argcount = len(args)
     shortopts = [opt for opt in aliases if len(opt) == 2]
     values = []
     pos = 0
     while pos < argcount:
         fullarg = arg = args[pos]
         equals = arg.find('=')
         if equals > -1:
             arg = arg[:equals]
         if arg in aliases:
             del args[pos]
             if equals > -1:
                 values.append(fullarg[equals + 1:])
                 argcount -= 1
             else:
                 if pos + 1 >= argcount:
                     # ignore and let getopt report an error if there is no value
                     break
                 values.append(args.pop(pos))
                 argcount -= 2
         elif arg[:2] in shortopts:
             # short option can have no following space, e.g. hg log -Rfoo
             values.append(args.pop(pos)[2:])
             argcount -= 1
         else:
             pos += 1
     return values
 
 def runcommand(lui, repo, cmd, fullargs, ui, options, d, cmdpats, cmdoptions):
     # run pre-hook, and abort if it fails
     hook.hook(lui, repo, "pre-%s" % cmd, True, args=" ".join(fullargs),
               pats=cmdpats, opts=cmdoptions)
     ret = _runcommand(ui, options, cmd, d)
     # run post-hook, passing command result
     hook.hook(lui, repo, "post-%s" % cmd, False, args=" ".join(fullargs),
               result=ret, pats=cmdpats, opts=cmdoptions)
     return ret
 
 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 = os.getcwd()
         except OSError as e:
             raise error.Abort(_("error getting current working directory: %s") %
                               e.strerror)
     path = cmdutil.findrepo(wd) or ""
     if not path:
         lui = ui
     else:
         lui = ui.copy()
         lui.readconfig(os.path.join(path, ".hg", "hgrc"), path)
 
     if rpath and rpath[-1]:
         path = lui.expandpath(rpath[-1])
         lui = ui.copy()
         lui.readconfig(os.path.join(path, ".hg", "hgrc"), path)
 
     return path, lui
 
 def _checkshellalias(lui, ui, args, precheck=True):
     """Return the function to run the shell alias, if it is required
 
     'precheck' is whether this function is invoked before adding
     aliases or not.
     """
     options = {}
 
     try:
         args = fancyopts.fancyopts(args, commands.globalopts, options)
     except fancyopts.getopt.GetoptError:
         return
 
     if not args:
         return
 
     if precheck:
         strict = True
         cmdtable = commands.table.copy()
         addaliases(lui, cmdtable)
     else:
         strict = False
         cmdtable = commands.table
 
     cmd = args[0]
     try:
         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, 'shell'):
         d = lambda: fn(ui, *args[1:])
         return lambda: runcommand(lui, None, cmd, args[:1], ui, options, d,
                                   [], {})
 
 def _cmdattr(ui, cmd, func, attr):
     try:
         return getattr(func, attr)
     except AttributeError:
         ui.deprecwarn("missing attribute '%s', use @command decorator "
                       "to register '%s'" % (attr, cmd), '3.8')
         return False
 
 _loaded = set()
 
 # list of (objname, loadermod, loadername) tuple:
 # - objname is the name of an object in extension module, from which
 #   extra information is loaded
 # - loadermod is the module where loader is placed
 # - loadername is the name of the function, which takes (ui, extensionname,
 #   extraobj) arguments
 extraloaders = [
     ('cmdtable', commands, 'loadcmdtable'),
     ('filesetpredicate', fileset, 'loadpredicate'),
     ('revsetpredicate', revset, 'loadpredicate'),
     ('templatefilter', templatefilters, 'loadfilter'),
+    ('templatefunc', templater, 'loadfunction'),
     ('templatekeyword', templatekw, 'loadkeyword'),
 ]
 
 def _dispatch(req):
     args = req.args
     ui = req.ui
 
     # check for cwd
     cwd = _earlygetopt(['--cwd'], args)
     if cwd:
         os.chdir(cwd[-1])
 
     rpath = _earlygetopt(["-R", "--repository", "--repo"], args)
     path, lui = _getlocal(ui, rpath)
 
     # Now that we're operating in the right directory/repository with
     # the right config settings, check for shell aliases
     shellaliasfn = _checkshellalias(lui, ui, args)
     if shellaliasfn:
         return shellaliasfn()
 
     # Configure extensions in phases: uisetup, extsetup, cmdtable, and
     # reposetup. Programs like TortoiseHg will call _dispatch several
     # times so we keep track of configured extensions in _loaded.
     extensions.loadall(lui)
     exts = [ext for ext in extensions.extensions() if ext[0] not in _loaded]
     # Propagate any changes to lui.__class__ by extensions
     ui.__class__ = lui.__class__
 
     # (uisetup and extsetup are handled in extensions.loadall)
 
     for name, module in exts:
         for objname, loadermod, loadername in extraloaders:
             extraobj = getattr(module, objname, None)
             if extraobj is not None:
                 getattr(loadermod, loadername)(ui, name, extraobj)
         _loaded.add(name)
 
     # (reposetup is handled in hg.repository)
 
     addaliases(lui, commands.table)
 
     if not lui.configbool("ui", "strict"):
         # All aliases and commands are completely defined, now.
         # Check abbreviation/ambiguity of shell alias again, because shell
         # alias may cause failure of "_parse" (see issue4355)
         shellaliasfn = _checkshellalias(lui, ui, args, precheck=False)
         if shellaliasfn:
             return shellaliasfn()
 
     # check for fallback encoding
     fallback = lui.config('ui', 'fallbackencoding')
     if fallback:
         encoding.fallbackencoding = fallback
 
     fullargs = args
     cmd, func, args, options, cmdoptions = _parse(lui, args)
 
     if options["config"]:
         raise error.Abort(_("option --config may not be abbreviated!"))
     if options["cwd"]:
         raise error.Abort(_("option --cwd may not be abbreviated!"))
     if options["repository"]:
         raise error.Abort(_(
             "option -R has to be separated from other options (e.g. not -qR) "
             "and --repository may only be abbreviated as --repo!"))
 
     if options["encoding"]:
         encoding.encoding = options["encoding"]
     if options["encodingmode"]:
         encoding.encodingmode = options["encodingmode"]
     if options["time"]:
         def get_times():
             t = os.times()
             if t[4] == 0.0: # Windows leaves this as zero, so use time.clock()
                 t = (t[0], t[1], t[2], t[3], time.clock())
             return t
         s = get_times()
         def print_time():
             t = get_times()
             ui.warn(_("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]))
         atexit.register(print_time)
 
     uis = set([ui, lui])
 
     if req.repo:
         uis.add(req.repo.ui)
 
     if options['verbose'] or options['debug'] or options['quiet']:
         for opt in ('verbose', 'debug', 'quiet'):
             val = str(bool(options[opt]))
             for ui_ in uis:
                 ui_.setconfig('ui', opt, val, '--' + opt)
 
     if options['traceback']:
         for ui_ in uis:
             ui_.setconfig('ui', 'traceback', 'on', '--traceback')
 
     if options['noninteractive']:
         for ui_ in uis:
             ui_.setconfig('ui', 'interactive', 'off', '-y')
 
     if cmdoptions.get('insecure', False):
         for ui_ in uis:
             ui_.setconfig('web', 'cacerts', '!', '--insecure')
 
     if options['version']:
         return commands.version_(ui)
     if options['help']:
         return commands.help_(ui, cmd, command=cmd is not None)
     elif not cmd:
         return commands.help_(ui, 'shortlist')
 
     repo = None
     cmdpats = args[:]
     if not _cmdattr(ui, cmd, 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
         else:
             try:
                 repo = hg.repository(ui, path=path)
                 if not repo.local():
                     raise error.Abort(_("repository '%s' is not local") % path)
                 repo.ui.setconfig("bundle", "mainreporoot", repo.root, 'repo')
             except error.RequirementError:
                 raise
             except error.RepoError:
                 if rpath and rpath[-1]: # invalid -R path
                     raise
                 if not _cmdattr(ui, cmd, func, 'optionalrepo'):
                     if (_cmdattr(ui, cmd, func, 'inferrepo') and
                         args and not path):
                         # try to infer -R from command args
                         repos = map(cmdutil.findrepo, args)
                         guess = repos[0]
                         if guess and repos.count(guess) == len(repos):
                             req.args = ['--repository', guess] + fullargs
                             return _dispatch(req)
                     if not path:
                         raise error.RepoError(_("no repository found in '%s'"
                                                 " (.hg not found)")
                                               % os.getcwd())
                     raise
         if repo:
             ui = repo.ui
             if options['hidden']:
                 repo = repo.unfiltered()
         args.insert(0, repo)
     elif rpath:
         ui.warn(_("warning: --repository ignored\n"))
 
     msg = ' '.join(' ' in a and repr(a) or a for a in fullargs)
     ui.log("command", '%s\n', msg)
     d = lambda: util.checksignature(func)(ui, *args, **cmdoptions)
     try:
         return runcommand(lui, repo, cmd, fullargs, ui, options, d,
                           cmdpats, cmdoptions)
     finally:
         if repo and repo != req.repo:
             repo.close()
 
 def lsprofile(ui, func, fp):
     format = ui.config('profiling', 'format', default='text')
     field = ui.config('profiling', 'sort', default='inlinetime')
     limit = ui.configint('profiling', 'limit', default=30)
     climit = ui.configint('profiling', 'nested', default=0)
 
     if format not in ['text', 'kcachegrind']:
         ui.warn(_("unrecognized profiling format '%s'"
                     " - Ignored\n") % format)
         format = 'text'
 
     try:
         from . import lsprof
     except ImportError:
         raise error.Abort(_(
             'lsprof not available - install from '
             'http://codespeak.net/svn/user/arigo/hack/misc/lsprof/'))
     p = lsprof.Profiler()
     p.enable(subcalls=True)
     try:
         return func()
     finally:
         p.disable()
 
         if format == 'kcachegrind':
             from . import lsprofcalltree
             calltree = lsprofcalltree.KCacheGrind(p)
             calltree.output(fp)
         else:
             # format == 'text'
             stats = lsprof.Stats(p.getstats())
             stats.sort(field)
             stats.pprint(limit=limit, file=fp, climit=climit)
 
 def flameprofile(ui, func, fp):
     try:
         from flamegraph import flamegraph
     except ImportError:
         raise error.Abort(_(
             'flamegraph not available - install from '
             'https://github.com/evanhempel/python-flamegraph'))
     # developer config: profiling.freq
     freq = ui.configint('profiling', 'freq', default=1000)
     filter_ = None
     collapse_recursion = True
     thread = flamegraph.ProfileThread(fp, 1.0 / freq,
                                       filter_, collapse_recursion)
     start_time = time.clock()
     try:
         thread.start()
         func()
     finally:
         thread.stop()
         thread.join()
         print('Collected %d stack frames (%d unique) in %2.2f seconds.' % (
             time.clock() - start_time, thread.num_frames(),
             thread.num_frames(unique=True)))
 
 
 def statprofile(ui, func, fp):
     try:
         import statprof
     except ImportError:
         raise error.Abort(_(
             'statprof not available - install using "easy_install statprof"'))
 
     freq = ui.configint('profiling', 'freq', default=1000)
     if freq > 0:
         statprof.reset(freq)
     else:
         ui.warn(_("invalid sampling frequency '%s' - ignoring\n") % freq)
 
     statprof.start()
     try:
         return func()
     finally:
         statprof.stop()
         statprof.display(fp)
 
 def _runcommand(ui, options, cmd, cmdfunc):
     """Enables the profiler if applicable.
 
     ``profiling.enabled`` - boolean config that enables or disables profiling
     """
     def checkargs():
         try:
             return cmdfunc()
         except error.SignatureError:
             raise error.CommandError(cmd, _("invalid arguments"))
 
     if options['profile'] or ui.configbool('profiling', 'enabled'):
         profiler = os.getenv('HGPROF')
         if profiler is None:
             profiler = ui.config('profiling', 'type', default='ls')
         if profiler not in ('ls', 'stat', 'flame'):
             ui.warn(_("unrecognized profiler '%s' - ignored\n") % profiler)
             profiler = 'ls'
 
         output = ui.config('profiling', 'output')
 
         if output == 'blackbox':
             import StringIO
             fp = StringIO.StringIO()
         elif output:
             path = ui.expandpath(output)
             fp = open(path, 'wb')
         else:
             fp = sys.stderr
 
         try:
             if profiler == 'ls':
                 return lsprofile(ui, checkargs, fp)
             elif profiler == 'flame':
                 return flameprofile(ui, checkargs, fp)
             else:
                 return statprofile(ui, checkargs, fp)
         finally:
             if output:
                 if output == 'blackbox':
                     val = "Profile:\n%s" % fp.getvalue()
                     # ui.log treats the input as a format string,
                     # so we need to escape any % signs.
                     val = val.replace('%', '%%')
                     ui.log('profile', val)
                 fp.close()
     else:
         return checkargs()

mercurial/registrar.py

@@ -1,218 +1,244 b''
 # registrar.py - utilities to register function for specific purpose
 #
 #  Copyright FUJIWARA Katsunori <[e-mail]> and others
 #
 # 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
 
 from . import (
     util,
 )
 
 class _funcregistrarbase(object):
     """Base of decorator to register a fuction for specific purpose
 
     This decorator stores decorated functions into own dict 'table'.
 
     The least derived class can be defined by overriding 'formatdoc',
     for example::
 
         class keyword(_funcregistrarbase):
             _docformat = ":%s: %s"
 
     This should be used as below:
 
         keyword = registrar.keyword()
 
         @keyword('bar')
         def barfunc(*args, **kwargs):
             '''Explanation of bar keyword ....
             '''
             pass
 
     In this case:
 
     - 'barfunc' is stored as 'bar' in '_table' of an instance 'keyword' above
     - 'barfunc.__doc__' becomes ":bar: Explanation of bar keyword"
     """
     def __init__(self, table=None):
         if table is None:
             self._table = {}
         else:
             self._table = table
 
     def __call__(self, decl, *args, **kwargs):
         return lambda func: self._doregister(func, decl, *args, **kwargs)
 
     def _doregister(self, func, decl, *args, **kwargs):
         name = self._getname(decl)
 
         if func.__doc__ and not util.safehasattr(func, '_origdoc'):
             doc = func.__doc__.strip()
             func._origdoc = doc
             func.__doc__ = self._formatdoc(decl, doc)
 
         self._table[name] = func
         self._extrasetup(name, func, *args, **kwargs)
 
         return func
 
     def _parsefuncdecl(self, decl):
         """Parse function declaration and return the name of function in it
         """
         i = decl.find('(')
         if i >= 0:
             return decl[:i]
         else:
             return decl
 
     def _getname(self, decl):
         """Return the name of the registered function from decl
 
         Derived class should override this, if it allows more
         descriptive 'decl' string than just a name.
         """
         return decl
 
     _docformat = None
 
     def _formatdoc(self, decl, doc):
         """Return formatted document of the registered function for help
 
         'doc' is '__doc__.strip()' of the registered function.
         """
         return self._docformat % (decl, doc)
 
     def _extrasetup(self, name, func):
         """Execute exra setup for registered function, if needed
         """
         pass
 
 class revsetpredicate(_funcregistrarbase):
     """Decorator to register revset predicate
 
     Usage::
 
         revsetpredicate = registrar.revsetpredicate()
 
         @revsetpredicate('mypredicate(arg1, arg2[, arg3])')
         def mypredicatefunc(repo, subset, x):
             '''Explanation of this revset predicate ....
             '''
             pass
 
     The first string argument is used also in online help.
 
     Optional argument 'safe' indicates whether a predicate is safe for
     DoS attack (False by default).
 
     'revsetpredicate' instance in example above can be used to
     decorate multiple functions.
 
     Decorated functions are registered automatically at loading
     extension, if an instance named as 'revsetpredicate' is used for
     decorating in extension.
 
     Otherwise, explicit 'revset.loadpredicate()' is needed.
     """
     _getname = _funcregistrarbase._parsefuncdecl
     _docformat = "``%s``\n    %s"
 
     def _extrasetup(self, name, func, safe=False):
         func._safe = safe
 
 class filesetpredicate(_funcregistrarbase):
     """Decorator to register fileset predicate
 
     Usage::
 
         filesetpredicate = registrar.filesetpredicate()
 
         @filesetpredicate('mypredicate()')
         def mypredicatefunc(mctx, x):
             '''Explanation of this fileset predicate ....
             '''
             pass
 
     The first string argument is used also in online help.
 
     Optional argument 'callstatus' indicates whether a predicate
      implies 'matchctx.status()' at runtime or not (False, by
      default).
 
     Optional argument 'callexisting' indicates whether a predicate
     implies 'matchctx.existing()' at runtime or not (False, by
     default).
 
     'filesetpredicate' instance in example above can be used to
     decorate multiple functions.
 
     Decorated functions are registered automatically at loading
     extension, if an instance named as 'filesetpredicate' is used for
     decorating in extension.
 
     Otherwise, explicit 'fileset.loadpredicate()' is needed.
     """
     _getname = _funcregistrarbase._parsefuncdecl
     _docformat = "``%s``\n    %s"
 
     def _extrasetup(self, name, func, callstatus=False, callexisting=False):
         func._callstatus = callstatus
         func._callexisting = callexisting
 
 class _templateregistrarbase(_funcregistrarbase):
     """Base of decorator to register functions as template specific one
     """
     _docformat = ":%s: %s"
 
 class templatekeyword(_templateregistrarbase):
     """Decorator to register template keyword
 
     Usage::
 
         templaetkeyword = registrar.templatekeyword()
 
         @templatekeyword('mykeyword')
         def mykeywordfunc(repo, ctx, templ, cache, revcache, **args):
             '''Explanation of this template keyword ....
             '''
             pass
 
     The first string argument is used also in online help.
 
     'templatekeyword' instance in example above can be used to
     decorate multiple functions.
 
     Decorated functions are registered automatically at loading
     extension, if an instance named as 'templatekeyword' is used for
     decorating in extension.
 
     Otherwise, explicit 'templatekw.loadkeyword()' is needed.
     """
 
 class templatefilter(_templateregistrarbase):
     """Decorator to register template filer
 
     Usage::
 
         templatefilter = registrar.templatefilter()
 
         @templatefilter('myfilter')
         def myfilterfunc(text):
             '''Explanation of this template filter ....
             '''
             pass
 
     The first string argument is used also in online help.
 
     'templatefilter' instance in example above can be used to
     decorate multiple functions.
 
     Decorated functions are registered automatically at loading
     extension, if an instance named as 'templatefilter' is used for
     decorating in extension.
 
     Otherwise, explicit 'templatefilters.loadkeyword()' is needed.
     """
+
+class templatefunc(_templateregistrarbase):
+    """Decorator to register template function
+
+    Usage::
+
+        templatefunc = registrar.templatefunc()
+
+        @templatefunc('myfunc(arg1, arg2[, arg3])')
+        def myfuncfunc(context, mapping, args):
+            '''Explanation of this template function ....
+            '''
+            pass
+
+    The first string argument is used also in online help.
+
+    'templatefunc' instance in example above can be used to
+    decorate multiple functions.
+
+    Decorated functions are registered automatically at loading
+    extension, if an instance named as 'templatefunc' is used for
+    decorating in extension.
+
+    Otherwise, explicit 'templater.loadfunction()' is needed.
+    """
+    _getname = _funcregistrarbase._parsefuncdecl

mercurial/templater.py

@@ -1,1073 +1,1079 b''
 # templater.py - template expansion for output
 #
 # Copyright 2005, 2006 Matt Mackall <[e-mail]>
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 from __future__ import absolute_import
 
 import os
 import re
 import types
 
 from .i18n import _
 from . import (
     config,
     error,
     minirst,
     parser,
     revset as revsetmod,
     templatefilters,
     templatekw,
     util,
 )
 
 # template parsing
 
 elements = {
     # token-type: binding-strength, primary, prefix, infix, suffix
     "(": (20, None, ("group", 1, ")"), ("func", 1, ")"), None),
     ",": (2, None, None, ("list", 2), None),
     "|": (5, None, None, ("|", 5), None),
     "%": (6, None, None, ("%", 6), None),
     ")": (0, None, None, None, None),
     "integer": (0, "integer", None, None, None),
     "symbol": (0, "symbol", None, None, None),
     "string": (0, "string", None, None, None),
     "template": (0, "template", None, None, None),
     "end": (0, None, None, None, None),
 }
 
 def tokenize(program, start, end):
     pos = start
     while pos < end:
         c = program[pos]
         if c.isspace(): # skip inter-token whitespace
             pass
         elif c in "(,)%|": # handle simple operators
             yield (c, None, pos)
         elif c in '"\'': # handle quoted templates
             s = pos + 1
             data, pos = _parsetemplate(program, s, end, c)
             yield ('template', data, s)
             pos -= 1
         elif c == 'r' and program[pos:pos + 2] in ("r'", 'r"'):
             # handle quoted strings
             c = program[pos + 1]
             s = pos = pos + 2
             while pos < end: # find closing quote
                 d = program[pos]
                 if d == '\\': # skip over escaped characters
                     pos += 2
                     continue
                 if d == c:
                     yield ('string', program[s:pos], s)
                     break
                 pos += 1
             else:
                 raise error.ParseError(_("unterminated string"), s)
         elif c.isdigit() or c == '-':
             s = pos
             if c == '-': # simply take negate operator as part of integer
                 pos += 1
             if pos >= end or not program[pos].isdigit():
                 raise error.ParseError(_("integer literal without digits"), s)
             pos += 1
             while pos < end:
                 d = program[pos]
                 if not d.isdigit():
                     break
                 pos += 1
             yield ('integer', program[s:pos], s)
             pos -= 1
         elif (c == '\\' and program[pos:pos + 2] in (r"\'", r'\"')
               or c == 'r' and program[pos:pos + 3] in (r"r\'", r'r\"')):
             # handle escaped quoted strings for compatibility with 2.9.2-3.4,
             # where some of nested templates were preprocessed as strings and
             # then compiled. therefore, \"...\" was allowed. (issue4733)
             #
             # processing flow of _evalifliteral() at 5ab28a2e9962:
             # outer template string    -> stringify()  -> compiletemplate()
             # ------------------------    ------------    ------------------
             # {f("\\\\ {g(\"\\\"\")}"}    \\ {g("\"")}    [r'\\', {g("\"")}]
             #             ~~~~~~~~
             #             escaped quoted string
             if c == 'r':
                 pos += 1
                 token = 'string'
             else:
                 token = 'template'
             quote = program[pos:pos + 2]
             s = pos = pos + 2
             while pos < end: # find closing escaped quote
                 if program.startswith('\\\\\\', pos, end):
                     pos += 4 # skip over double escaped characters
                     continue
                 if program.startswith(quote, pos, end):
                     # interpret as if it were a part of an outer string
                     data = parser.unescapestr(program[s:pos])
                     if token == 'template':
                         data = _parsetemplate(data, 0, len(data))[0]
                     yield (token, data, s)
                     pos += 1
                     break
                 pos += 1
             else:
                 raise error.ParseError(_("unterminated string"), s)
         elif c.isalnum() or c in '_':
             s = pos
             pos += 1
             while pos < end: # find end of symbol
                 d = program[pos]
                 if not (d.isalnum() or d == "_"):
                     break
                 pos += 1
             sym = program[s:pos]
             yield ('symbol', sym, s)
             pos -= 1
         elif c == '}':
             yield ('end', None, pos + 1)
             return
         else:
             raise error.ParseError(_("syntax error"), pos)
         pos += 1
     raise error.ParseError(_("unterminated template expansion"), start)
 
 def _parsetemplate(tmpl, start, stop, quote=''):
     r"""
     >>> _parsetemplate('foo{bar}"baz', 0, 12)
     ([('string', 'foo'), ('symbol', 'bar'), ('string', '"baz')], 12)
     >>> _parsetemplate('foo{bar}"baz', 0, 12, quote='"')
     ([('string', 'foo'), ('symbol', 'bar')], 9)
     >>> _parsetemplate('foo"{bar}', 0, 9, quote='"')
     ([('string', 'foo')], 4)
     >>> _parsetemplate(r'foo\"bar"baz', 0, 12, quote='"')
     ([('string', 'foo"'), ('string', 'bar')], 9)
     >>> _parsetemplate(r'foo\\"bar', 0, 10, quote='"')
     ([('string', 'foo\\')], 6)
     """
     parsed = []
     sepchars = '{' + quote
     pos = start
     p = parser.parser(elements)
     while pos < stop:
         n = min((tmpl.find(c, pos, stop) for c in sepchars),
                 key=lambda n: (n < 0, n))
         if n < 0:
             parsed.append(('string', parser.unescapestr(tmpl[pos:stop])))
             pos = stop
             break
         c = tmpl[n]
         bs = (n - pos) - len(tmpl[pos:n].rstrip('\\'))
         if bs % 2 == 1:
             # escaped (e.g. '\{', '\\\{', but not '\\{')
             parsed.append(('string', parser.unescapestr(tmpl[pos:n - 1]) + c))
             pos = n + 1
             continue
         if n > pos:
             parsed.append(('string', parser.unescapestr(tmpl[pos:n])))
         if c == quote:
             return parsed, n + 1
 
         parseres, pos = p.parse(tokenize(tmpl, n + 1, stop))
         parsed.append(parseres)
 
     if quote:
         raise error.ParseError(_("unterminated string"), start)
     return parsed, pos
 
 def _unnesttemplatelist(tree):
     """Expand list of templates to node tuple
 
     >>> def f(tree):
     ...     print prettyformat(_unnesttemplatelist(tree))
     >>> f(('template', []))
     ('string', '')
     >>> f(('template', [('string', 'foo')]))
     ('string', 'foo')
     >>> f(('template', [('string', 'foo'), ('symbol', 'rev')]))
     (template
       ('string', 'foo')
       ('symbol', 'rev'))
     >>> f(('template', [('symbol', 'rev')]))  # template(rev) -> str
     (template
       ('symbol', 'rev'))
     >>> f(('template', [('template', [('string', 'foo')])]))
     ('string', 'foo')
     """
     if not isinstance(tree, tuple):
         return tree
     op = tree[0]
     if op != 'template':
         return (op,) + tuple(_unnesttemplatelist(x) for x in tree[1:])
 
     assert len(tree) == 2
     xs = tuple(_unnesttemplatelist(x) for x in tree[1])
     if not xs:
         return ('string', '')  # empty template ""
     elif len(xs) == 1 and xs[0][0] == 'string':
         return xs[0]  # fast path for string with no template fragment "x"
     else:
         return (op,) + xs
 
 def parse(tmpl):
     """Parse template string into tree"""
     parsed, pos = _parsetemplate(tmpl, 0, len(tmpl))
     assert pos == len(tmpl), 'unquoted template should be consumed'
     return _unnesttemplatelist(('template', parsed))
 
 def prettyformat(tree):
     return parser.prettyformat(tree, ('integer', 'string', 'symbol'))
 
 def compiletemplate(tmpl, context):
     """Parse and compile template string to (func, data) pair"""
     return compileexp(parse(tmpl), context, methods)
 
 def compileexp(exp, context, curmethods):
     t = exp[0]
     if t in curmethods:
         return curmethods[t](exp, context)
     raise error.ParseError(_("unknown method '%s'") % t)
 
 # template evaluation
 
 def getsymbol(exp):
     if exp[0] == 'symbol':
         return exp[1]
     raise error.ParseError(_("expected a symbol, got '%s'") % exp[0])
 
 def getlist(x):
     if not x:
         return []
     if x[0] == 'list':
         return getlist(x[1]) + [x[2]]
     return [x]
 
 def gettemplate(exp, context):
     """Compile given template tree or load named template from map file;
     returns (func, data) pair"""
     if exp[0] in ('template', 'string'):
         return compileexp(exp, context, methods)
     if exp[0] == 'symbol':
         # unlike runsymbol(), here 'symbol' is always taken as template name
         # even if it exists in mapping. this allows us to override mapping
         # by web templates, e.g. 'changelogtag' is redefined in map file.
         return context._load(exp[1])
     raise error.ParseError(_("expected template specifier"))
 
 def evalfuncarg(context, mapping, arg):
     func, data = arg
     # func() may return string, generator of strings or arbitrary object such
     # as date tuple, but filter does not want generator.
     thing = func(context, mapping, data)
     if isinstance(thing, types.GeneratorType):
         thing = stringify(thing)
     return thing
 
 def evalinteger(context, mapping, arg, err):
     v = evalfuncarg(context, mapping, arg)
     try:
         return int(v)
     except (TypeError, ValueError):
         raise error.ParseError(err)
 
 def evalstring(context, mapping, arg):
     func, data = arg
     return stringify(func(context, mapping, data))
 
 def evalstringliteral(context, mapping, arg):
     """Evaluate given argument as string template, but returns symbol name
     if it is unknown"""
     func, data = arg
     if func is runsymbol:
         thing = func(context, mapping, data, default=data)
     else:
         thing = func(context, mapping, data)
     return stringify(thing)
 
 def runinteger(context, mapping, data):
     return int(data)
 
 def runstring(context, mapping, data):
     return data
 
 def _recursivesymbolblocker(key):
     def showrecursion(**args):
         raise error.Abort(_("recursive reference '%s' in template") % key)
     return showrecursion
 
 def _runrecursivesymbol(context, mapping, key):
     raise error.Abort(_("recursive reference '%s' in template") % key)
 
 def runsymbol(context, mapping, key, default=''):
     v = mapping.get(key)
     if v is None:
         v = context._defaults.get(key)
     if v is None:
         # put poison to cut recursion. we can't move this to parsing phase
         # because "x = {x}" is allowed if "x" is a keyword. (issue4758)
         safemapping = mapping.copy()
         safemapping[key] = _recursivesymbolblocker(key)
         try:
             v = context.process(key, safemapping)
         except TemplateNotFound:
             v = default
     if callable(v):
         return v(**mapping)
     return v
 
 def buildtemplate(exp, context):
     ctmpl = [compileexp(e, context, methods) for e in exp[1:]]
     return (runtemplate, ctmpl)
 
 def runtemplate(context, mapping, template):
     for func, data in template:
         yield func(context, mapping, data)
 
 def buildfilter(exp, context):
     arg = compileexp(exp[1], context, methods)
     n = getsymbol(exp[2])
     if n in context._filters:
         filt = context._filters[n]
         return (runfilter, (arg, filt))
     if n in funcs:
         f = funcs[n]
         return (f, [arg])
     raise error.ParseError(_("unknown function '%s'") % n)
 
 def runfilter(context, mapping, data):
     arg, filt = data
     thing = evalfuncarg(context, mapping, arg)
     try:
         return filt(thing)
     except (ValueError, AttributeError, TypeError):
         if isinstance(arg[1], tuple):
             dt = arg[1][1]
         else:
             dt = arg[1]
         raise error.Abort(_("template filter '%s' is not compatible with "
                            "keyword '%s'") % (filt.func_name, dt))
 
 def buildmap(exp, context):
     func, data = compileexp(exp[1], context, methods)
     tfunc, tdata = gettemplate(exp[2], context)
     return (runmap, (func, data, tfunc, tdata))
 
 def runmap(context, mapping, data):
     func, data, tfunc, tdata = data
     d = func(context, mapping, data)
     if util.safehasattr(d, 'itermaps'):
         diter = d.itermaps()
     else:
         try:
             diter = iter(d)
         except TypeError:
             if func is runsymbol:
                 raise error.ParseError(_("keyword '%s' is not iterable") % data)
             else:
                 raise error.ParseError(_("%r is not iterable") % d)
 
     for i in diter:
         lm = mapping.copy()
         if isinstance(i, dict):
             lm.update(i)
             lm['originalnode'] = mapping.get('node')
             yield tfunc(context, lm, tdata)
         else:
             # v is not an iterable of dicts, this happen when 'key'
             # has been fully expanded already and format is useless.
             # If so, return the expanded value.
             yield i
 
 def buildfunc(exp, context):
     n = getsymbol(exp[1])
     args = [compileexp(x, context, exprmethods) for x in getlist(exp[2])]
     if n in funcs:
         f = funcs[n]
         return (f, args)
     if n in context._filters:
         if len(args) != 1:
             raise error.ParseError(_("filter %s expects one argument") % n)
         f = context._filters[n]
         return (runfilter, (args[0], f))
     raise error.ParseError(_("unknown function '%s'") % n)
 
 def date(context, mapping, args):
     """:date(date[, fmt]): Format a date. See :hg:`help dates` for formatting
     strings. The default is a Unix date format, including the timezone:
     "Mon Sep 04 15:13:13 2006 0700"."""
     if not (1 <= len(args) <= 2):
         # i18n: "date" is a keyword
         raise error.ParseError(_("date expects one or two arguments"))
 
     date = evalfuncarg(context, mapping, args[0])
     fmt = None
     if len(args) == 2:
         fmt = evalstring(context, mapping, args[1])
     try:
         if fmt is None:
             return util.datestr(date)
         else:
             return util.datestr(date, fmt)
     except (TypeError, ValueError):
         # i18n: "date" is a keyword
         raise error.ParseError(_("date expects a date information"))
 
 def diff(context, mapping, args):
     """:diff([includepattern [, excludepattern]]): Show a diff, optionally
     specifying files to include or exclude."""
     if len(args) > 2:
         # i18n: "diff" is a keyword
         raise error.ParseError(_("diff expects zero, one, or two arguments"))
 
     def getpatterns(i):
         if i < len(args):
             s = evalstring(context, mapping, args[i]).strip()
             if s:
                 return [s]
         return []
 
     ctx = mapping['ctx']
     chunks = ctx.diff(match=ctx.match([], getpatterns(0), getpatterns(1)))
 
     return ''.join(chunks)
 
 def fill(context, mapping, args):
     """:fill(text[, width[, initialident[, hangindent]]]): Fill many
     paragraphs with optional indentation. See the "fill" filter."""
     if not (1 <= len(args) <= 4):
         # i18n: "fill" is a keyword
         raise error.ParseError(_("fill expects one to four arguments"))
 
     text = evalstring(context, mapping, args[0])
     width = 76
     initindent = ''
     hangindent = ''
     if 2 <= len(args) <= 4:
         width = evalinteger(context, mapping, args[1],
                             # i18n: "fill" is a keyword
                             _("fill expects an integer width"))
         try:
             initindent = evalstring(context, mapping, args[2])
             hangindent = evalstring(context, mapping, args[3])
         except IndexError:
             pass
 
     return templatefilters.fill(text, width, initindent, hangindent)
 
 def pad(context, mapping, args):
     """:pad(text, width[, fillchar=' '[, right=False]]): Pad text with a
     fill character."""
     if not (2 <= len(args) <= 4):
         # i18n: "pad" is a keyword
         raise error.ParseError(_("pad() expects two to four arguments"))
 
     width = evalinteger(context, mapping, args[1],
                         # i18n: "pad" is a keyword
                         _("pad() expects an integer width"))
 
     text = evalstring(context, mapping, args[0])
 
     right = False
     fillchar = ' '
     if len(args) > 2:
         fillchar = evalstring(context, mapping, args[2])
     if len(args) > 3:
         right = util.parsebool(args[3][1])
 
     if right:
         return text.rjust(width, fillchar)
     else:
         return text.ljust(width, fillchar)
 
 def indent(context, mapping, args):
     """:indent(text, indentchars[, firstline]): Indents all non-empty lines
     with the characters given in the indentchars string. An optional
     third parameter will override the indent for the first line only
     if present."""
     if not (2 <= len(args) <= 3):
         # i18n: "indent" is a keyword
         raise error.ParseError(_("indent() expects two or three arguments"))
 
     text = evalstring(context, mapping, args[0])
     indent = evalstring(context, mapping, args[1])
 
     if len(args) == 3:
         firstline = evalstring(context, mapping, args[2])
     else:
         firstline = indent
 
     # the indent function doesn't indent the first line, so we do it here
     return templatefilters.indent(firstline + text, indent)
 
 def get(context, mapping, args):
     """:get(dict, key): Get an attribute/key from an object. Some keywords
     are complex types. This function allows you to obtain the value of an
     attribute on these types."""
     if len(args) != 2:
         # i18n: "get" is a keyword
         raise error.ParseError(_("get() expects two arguments"))
 
     dictarg = evalfuncarg(context, mapping, args[0])
     if not util.safehasattr(dictarg, 'get'):
         # i18n: "get" is a keyword
         raise error.ParseError(_("get() expects a dict as first argument"))
 
     key = evalfuncarg(context, mapping, args[1])
     return dictarg.get(key)
 
 def if_(context, mapping, args):
     """:if(expr, then[, else]): Conditionally execute based on the result of
     an expression."""
     if not (2 <= len(args) <= 3):
         # i18n: "if" is a keyword
         raise error.ParseError(_("if expects two or three arguments"))
 
     test = evalstring(context, mapping, args[0])
     if test:
         yield args[1][0](context, mapping, args[1][1])
     elif len(args) == 3:
         yield args[2][0](context, mapping, args[2][1])
 
 def ifcontains(context, mapping, args):
     """:ifcontains(search, thing, then[, else]): Conditionally execute based
     on whether the item "search" is in "thing"."""
     if not (3 <= len(args) <= 4):
         # i18n: "ifcontains" is a keyword
         raise error.ParseError(_("ifcontains expects three or four arguments"))
 
     item = evalstring(context, mapping, args[0])
     items = evalfuncarg(context, mapping, args[1])
 
     if item in items:
         yield args[2][0](context, mapping, args[2][1])
     elif len(args) == 4:
         yield args[3][0](context, mapping, args[3][1])
 
 def ifeq(context, mapping, args):
     """:ifeq(expr1, expr2, then[, else]): Conditionally execute based on
     whether 2 items are equivalent."""
     if not (3 <= len(args) <= 4):
         # i18n: "ifeq" is a keyword
         raise error.ParseError(_("ifeq expects three or four arguments"))
 
     test = evalstring(context, mapping, args[0])
     match = evalstring(context, mapping, args[1])
     if test == match:
         yield args[2][0](context, mapping, args[2][1])
     elif len(args) == 4:
         yield args[3][0](context, mapping, args[3][1])
 
 def join(context, mapping, args):
     """:join(list, sep): Join items in a list with a delimiter."""
     if not (1 <= len(args) <= 2):
         # i18n: "join" is a keyword
         raise error.ParseError(_("join expects one or two arguments"))
 
     joinset = args[0][0](context, mapping, args[0][1])
     if util.safehasattr(joinset, 'itermaps'):
         jf = joinset.joinfmt
         joinset = [jf(x) for x in joinset.itermaps()]
 
     joiner = " "
     if len(args) > 1:
         joiner = evalstring(context, mapping, args[1])
 
     first = True
     for x in joinset:
         if first:
             first = False
         else:
             yield joiner
         yield x
 
 def label(context, mapping, args):
     """:label(label, expr): Apply a label to generated content. Content with
     a label applied can result in additional post-processing, such as
     automatic colorization."""
     if len(args) != 2:
         # i18n: "label" is a keyword
         raise error.ParseError(_("label expects two arguments"))
 
     ui = mapping['ui']
     thing = evalstring(context, mapping, args[1])
     # preserve unknown symbol as literal so effects like 'red', 'bold',
     # etc. don't need to be quoted
     label = evalstringliteral(context, mapping, args[0])
 
     return ui.label(thing, label)
 
 def latesttag(context, mapping, args):
     """:latesttag([pattern]): The global tags matching the given pattern on the
     most recent globally tagged ancestor of this changeset."""
     if len(args) > 1:
         # i18n: "latesttag" is a keyword
         raise error.ParseError(_("latesttag expects at most one argument"))
 
     pattern = None
     if len(args) == 1:
         pattern = evalstring(context, mapping, args[0])
 
     return templatekw.showlatesttags(pattern, **mapping)
 
 def localdate(context, mapping, args):
     """:localdate(date[, tz]): Converts a date to the specified timezone.
     The default is local date."""
     if not (1 <= len(args) <= 2):
         # i18n: "localdate" is a keyword
         raise error.ParseError(_("localdate expects one or two arguments"))
 
     date = evalfuncarg(context, mapping, args[0])
     try:
         date = util.parsedate(date)
     except AttributeError:  # not str nor date tuple
         # i18n: "localdate" is a keyword
         raise error.ParseError(_("localdate expects a date information"))
     if len(args) >= 2:
         tzoffset = None
         tz = evalfuncarg(context, mapping, args[1])
         if isinstance(tz, str):
             tzoffset = util.parsetimezone(tz)
         if tzoffset is None:
             try:
                 tzoffset = int(tz)
             except (TypeError, ValueError):
                 # i18n: "localdate" is a keyword
                 raise error.ParseError(_("localdate expects a timezone"))
     else:
         tzoffset = util.makedate()[1]
     return (date[0], tzoffset)
 
 def revset(context, mapping, args):
     """:revset(query[, formatargs...]): Execute a revision set query. See
     :hg:`help revset`."""
     if not len(args) > 0:
         # i18n: "revset" is a keyword
         raise error.ParseError(_("revset expects one or more arguments"))
 
     raw = evalstring(context, mapping, args[0])
     ctx = mapping['ctx']
     repo = ctx.repo()
 
     def query(expr):
         m = revsetmod.match(repo.ui, expr)
         return m(repo)
 
     if len(args) > 1:
         formatargs = [evalfuncarg(context, mapping, a) for a in args[1:]]
         revs = query(revsetmod.formatspec(raw, *formatargs))
         revs = list(revs)
     else:
         revsetcache = mapping['cache'].setdefault("revsetcache", {})
         if raw in revsetcache:
             revs = revsetcache[raw]
         else:
             revs = query(raw)
             revs = list(revs)
             revsetcache[raw] = revs
 
     return templatekw.showrevslist("revision", revs, **mapping)
 
 def rstdoc(context, mapping, args):
     """:rstdoc(text, style): Format ReStructuredText."""
     if len(args) != 2:
         # i18n: "rstdoc" is a keyword
         raise error.ParseError(_("rstdoc expects two arguments"))
 
     text = evalstring(context, mapping, args[0])
     style = evalstring(context, mapping, args[1])
 
     return minirst.format(text, style=style, keep=['verbose'])
 
 def shortest(context, mapping, args):
     """:shortest(node, minlength=4): Obtain the shortest representation of
     a node."""
     if not (1 <= len(args) <= 2):
         # i18n: "shortest" is a keyword
         raise error.ParseError(_("shortest() expects one or two arguments"))
 
     node = evalstring(context, mapping, args[0])
 
     minlength = 4
     if len(args) > 1:
         minlength = evalinteger(context, mapping, args[1],
                                 # i18n: "shortest" is a keyword
                                 _("shortest() expects an integer minlength"))
 
     cl = mapping['ctx']._repo.changelog
     def isvalid(test):
         try:
             try:
                 cl.index.partialmatch(test)
             except AttributeError:
                 # Pure mercurial doesn't support partialmatch on the index.
                 # Fallback to the slow way.
                 if cl._partialmatch(test) is None:
                     return False
 
             try:
                 i = int(test)
                 # if we are a pure int, then starting with zero will not be
                 # confused as a rev; or, obviously, if the int is larger than
                 # the value of the tip rev
                 if test[0] == '0' or i > len(cl):
                     return True
                 return False
             except ValueError:
                 return True
         except error.RevlogError:
             return False
 
     shortest = node
     startlength = max(6, minlength)
     length = startlength
     while True:
         test = node[:length]
         if isvalid(test):
             shortest = test
             if length == minlength or length > startlength:
                 return shortest
             length -= 1
         else:
             length += 1
             if len(shortest) <= length:
                 return shortest
 
 def strip(context, mapping, args):
     """:strip(text[, chars]): Strip characters from a string. By default,
     strips all leading and trailing whitespace."""
     if not (1 <= len(args) <= 2):
         # i18n: "strip" is a keyword
         raise error.ParseError(_("strip expects one or two arguments"))
 
     text = evalstring(context, mapping, args[0])
     if len(args) == 2:
         chars = evalstring(context, mapping, args[1])
         return text.strip(chars)
     return text.strip()
 
 def sub(context, mapping, args):
     """:sub(pattern, replacement, expression): Perform text substitution
     using regular expressions."""
     if len(args) != 3:
         # i18n: "sub" is a keyword
         raise error.ParseError(_("sub expects three arguments"))
 
     pat = evalstring(context, mapping, args[0])
     rpl = evalstring(context, mapping, args[1])
     src = evalstring(context, mapping, args[2])
     try:
         patre = re.compile(pat)
     except re.error:
         # i18n: "sub" is a keyword
         raise error.ParseError(_("sub got an invalid pattern: %s") % pat)
     try:
         yield patre.sub(rpl, src)
     except re.error:
         # i18n: "sub" is a keyword
         raise error.ParseError(_("sub got an invalid replacement: %s") % rpl)
 
 def startswith(context, mapping, args):
     """:startswith(pattern, text): Returns the value from the "text" argument
     if it begins with the content from the "pattern" argument."""
     if len(args) != 2:
         # i18n: "startswith" is a keyword
         raise error.ParseError(_("startswith expects two arguments"))
 
     patn = evalstring(context, mapping, args[0])
     text = evalstring(context, mapping, args[1])
     if text.startswith(patn):
         return text
     return ''
 
 
 def word(context, mapping, args):
     """:word(number, text[, separator]): Return the nth word from a string."""
     if not (2 <= len(args) <= 3):
         # i18n: "word" is a keyword
         raise error.ParseError(_("word expects two or three arguments, got %d")
                                % len(args))
 
     num = evalinteger(context, mapping, args[0],
                       # i18n: "word" is a keyword
                       _("word expects an integer index"))
     text = evalstring(context, mapping, args[1])
     if len(args) == 3:
         splitter = evalstring(context, mapping, args[2])
     else:
         splitter = None
 
     tokens = text.split(splitter)
     if num >= len(tokens) or num < -len(tokens):
         return ''
     else:
         return tokens[num]
 
 # methods to interpret function arguments or inner expressions (e.g. {_(x)})
 exprmethods = {
     "integer": lambda e, c: (runinteger, e[1]),
     "string": lambda e, c: (runstring, e[1]),
     "symbol": lambda e, c: (runsymbol, e[1]),
     "template": buildtemplate,
     "group": lambda e, c: compileexp(e[1], c, exprmethods),
 #    ".": buildmember,
     "|": buildfilter,
     "%": buildmap,
     "func": buildfunc,
     }
 
 # methods to interpret top-level template (e.g. {x}, {x|_}, {x % "y"})
 methods = exprmethods.copy()
 methods["integer"] = exprmethods["symbol"]  # '{1}' as variable
 
 funcs = {
     "date": date,
     "diff": diff,
     "fill": fill,
     "get": get,
     "if": if_,
     "ifcontains": ifcontains,
     "ifeq": ifeq,
     "indent": indent,
     "join": join,
     "label": label,
     "latesttag": latesttag,
     "localdate": localdate,
     "pad": pad,
     "revset": revset,
     "rstdoc": rstdoc,
     "shortest": shortest,
     "startswith": startswith,
     "strip": strip,
     "sub": sub,
     "word": word,
 }
 
 # template engine
 
 stringify = templatefilters.stringify
 
 def _flatten(thing):
     '''yield a single stream from a possibly nested set of iterators'''
     if isinstance(thing, str):
         yield thing
     elif not util.safehasattr(thing, '__iter__'):
         if thing is not None:
             yield str(thing)
     else:
         for i in thing:
             if isinstance(i, str):
                 yield i
             elif not util.safehasattr(i, '__iter__'):
                 if i is not None:
                     yield str(i)
             elif i is not None:
                 for j in _flatten(i):
                     yield j
 
 def unquotestring(s):
     '''unwrap quotes if any; otherwise returns unmodified string'''
     if len(s) < 2 or s[0] not in "'\"" or s[0] != s[-1]:
         return s
     return s[1:-1]
 
 class engine(object):
     '''template expansion engine.
 
     template expansion works like this. a map file contains key=value
     pairs. if value is quoted, it is treated as string. otherwise, it
     is treated as name of template file.
 
     templater is asked to expand a key in map. it looks up key, and
     looks for strings like this: {foo}. it expands {foo} by looking up
     foo in map, and substituting it. expansion is recursive: it stops
     when there is no more {foo} to replace.
 
     expansion also allows formatting and filtering.
 
     format uses key to expand each item in list. syntax is
     {key%format}.
 
     filter uses function to transform value. syntax is
     {key|filter1|filter2|...}.'''
 
     def __init__(self, loader, filters=None, defaults=None):
         self._loader = loader
         if filters is None:
             filters = {}
         self._filters = filters
         if defaults is None:
             defaults = {}
         self._defaults = defaults
         self._cache = {}  # key: (func, data)
 
     def _load(self, t):
         '''load, parse, and cache a template'''
         if t not in self._cache:
             # put poison to cut recursion while compiling 't'
             self._cache[t] = (_runrecursivesymbol, t)
             try:
                 self._cache[t] = compiletemplate(self._loader(t), self)
             except: # re-raises
                 del self._cache[t]
                 raise
         return self._cache[t]
 
     def process(self, t, mapping):
         '''Perform expansion. t is name of map element to expand.
         mapping contains added elements for use during expansion. Is a
         generator.'''
         func, data = self._load(t)
         return _flatten(func(self, mapping, data))
 
 engines = {'default': engine}
 
 def stylelist():
     paths = templatepaths()
     if not paths:
         return _('no templates found, try `hg debuginstall` for more info')
     dirlist = os.listdir(paths[0])
     stylelist = []
     for file in dirlist:
         split = file.split(".")
         if split[-1] in ('orig', 'rej'):
             continue
         if split[0] == "map-cmdline":
             stylelist.append(split[1])
     return ", ".join(sorted(stylelist))
 
 class TemplateNotFound(error.Abort):
     pass
 
 class templater(object):
 
     def __init__(self, mapfile, filters=None, defaults=None, cache=None,
                  minchunk=1024, maxchunk=65536):
         '''set up template engine.
         mapfile is name of file to read map definitions from.
         filters is dict of functions. each transforms a value into another.
         defaults is dict of default map definitions.'''
         if filters is None:
             filters = {}
         if defaults is None:
             defaults = {}
         if cache is None:
             cache = {}
         self.mapfile = mapfile or 'template'
         self.cache = cache.copy()
         self.map = {}
         if mapfile:
             self.base = os.path.dirname(mapfile)
         else:
             self.base = ''
         self.filters = templatefilters.filters.copy()
         self.filters.update(filters)
         self.defaults = defaults
         self.minchunk, self.maxchunk = minchunk, maxchunk
         self.ecache = {}
 
         if not mapfile:
             return
         if not os.path.exists(mapfile):
             raise error.Abort(_("style '%s' not found") % mapfile,
                              hint=_("available styles: %s") % stylelist())
 
         conf = config.config(includepaths=templatepaths())
         conf.read(mapfile)
 
         for key, val in conf[''].items():
             if not val:
                 raise error.ParseError(_('missing value'), conf.source('', key))
             if val[0] in "'\"":
                 if val[0] != val[-1]:
                     raise error.ParseError(_('unmatched quotes'),
                                            conf.source('', key))
                 self.cache[key] = unquotestring(val)
             else:
                 val = 'default', val
                 if ':' in val[1]:
                     val = val[1].split(':', 1)
                 self.map[key] = val[0], os.path.join(self.base, val[1])
 
     def __contains__(self, key):
         return key in self.cache or key in self.map
 
     def load(self, t):
         '''Get the template for the given template name. Use a local cache.'''
         if t not in self.cache:
             try:
                 self.cache[t] = util.readfile(self.map[t][1])
             except KeyError as inst:
                 raise TemplateNotFound(_('"%s" not in template map') %
                                        inst.args[0])
             except IOError as inst:
                 raise IOError(inst.args[0], _('template file %s: %s') %
                               (self.map[t][1], inst.args[1]))
         return self.cache[t]
 
     def __call__(self, t, **mapping):
         ttype = t in self.map and self.map[t][0] or 'default'
         if ttype not in self.ecache:
             self.ecache[ttype] = engines[ttype](self.load,
                                                  self.filters, self.defaults)
         proc = self.ecache[ttype]
 
         stream = proc.process(t, mapping)
         if self.minchunk:
             stream = util.increasingchunks(stream, min=self.minchunk,
                                            max=self.maxchunk)
         return stream
 
 def templatepaths():
     '''return locations used for template files.'''
     pathsrel = ['templates']
     paths = [os.path.normpath(os.path.join(util.datapath, f))
              for f in pathsrel]
     return [p for p in paths if os.path.isdir(p)]
 
 def templatepath(name):
     '''return location of template file. returns None if not found.'''
     for p in templatepaths():
         f = os.path.join(p, name)
         if os.path.exists(f):
             return f
     return None
 
 def stylemap(styles, paths=None):
     """Return path to mapfile for a given style.
 
     Searches mapfile in the following locations:
     1. templatepath/style/map
     2. templatepath/map-style
     3. templatepath/map
     """
 
     if paths is None:
         paths = templatepaths()
     elif isinstance(paths, str):
         paths = [paths]
 
     if isinstance(styles, str):
         styles = [styles]
 
     for style in styles:
         # only plain name is allowed to honor template paths
         if (not style
             or style in (os.curdir, os.pardir)
             or os.sep in style
             or os.altsep and os.altsep in style):
             continue
         locations = [os.path.join(style, 'map'), 'map-' + style]
         locations.append('map')
 
         for path in paths:
             for location in locations:
                 mapfile = os.path.join(path, location)
                 if os.path.isfile(mapfile):
                     return style, mapfile
 
     raise RuntimeError("No hgweb templates found in %r" % paths)
 
+def loadfunction(ui, extname, registrarobj):
+    """Load template function from specified registrarobj
+    """
+    for name, func in registrarobj._table.iteritems():
+        funcs[name] = func
+
 # tell hggettext to extract docstrings from these functions:
 i18nfunctions = funcs.values()

tests/test-command-template.t

@@ -1,3695 +1,3718 b''
   $ hg init a
   $ cd a
   $ echo a > a
   $ hg add a
   $ echo line 1 > b
   $ echo line 2 >> b
   $ hg commit -l b -d '1000000 0' -u 'User Name <user@hostname>'
 
   $ hg add b
   $ echo other 1 > c
   $ echo other 2 >> c
   $ echo >> c
   $ echo other 3 >> c
   $ hg commit -l c -d '1100000 0' -u 'A. N. Other <other@place>'
 
   $ hg add c
   $ hg commit -m 'no person' -d '1200000 0' -u 'other@place'
   $ echo c >> c
   $ hg commit -m 'no user, no domain' -d '1300000 0' -u 'person'
 
   $ echo foo > .hg/branch
   $ hg commit -m 'new branch' -d '1400000 0' -u 'person'
 
   $ hg co -q 3
   $ echo other 4 >> d
   $ hg add d
   $ hg commit -m 'new head' -d '1500000 0' -u 'person'
 
   $ hg merge -q foo
   $ hg commit -m 'merge' -d '1500001 0' -u 'person'
 
 Second branch starting at nullrev:
 
   $ hg update null
   0 files updated, 0 files merged, 4 files removed, 0 files unresolved
   $ echo second > second
   $ hg add second
   $ hg commit -m second -d '1000000 0' -u 'User Name <user@hostname>'
   created new head
 
   $ echo third > third
   $ hg add third
   $ hg mv second fourth
   $ hg commit -m third -d "2020-01-01 10:01"
 
   $ hg log --template '{join(file_copies, ",\n")}\n' -r .
   fourth (second)
   $ hg log -T '{file_copies % "{source} -> {name}\n"}' -r .
   second -> fourth
   $ hg log -T '{rev} {ifcontains("fourth", file_copies, "t", "f")}\n' -r .:7
   8 t
   7 f
 
 Working-directory revision has special identifiers, though they are still
 experimental:
 
   $ hg log -r 'wdir()' -T '{rev}:{node}\n'
   2147483647:ffffffffffffffffffffffffffffffffffffffff
 
 Some keywords are invalid for working-directory revision, but they should
 never cause crash:
 
   $ hg log -r 'wdir()' -T '{manifest}\n'
   
 
 Quoting for ui.logtemplate
 
   $ hg tip --config "ui.logtemplate={rev}\n"
   8
   $ hg tip --config "ui.logtemplate='{rev}\n'"
   8
   $ hg tip --config 'ui.logtemplate="{rev}\n"'
   8
   $ hg tip --config 'ui.logtemplate=n{rev}\n'
   n8
 
 Make sure user/global hgrc does not affect tests
 
   $ echo '[ui]' > .hg/hgrc
   $ echo 'logtemplate =' >> .hg/hgrc
   $ echo 'style =' >> .hg/hgrc
 
 Add some simple styles to settings
 
   $ echo '[templates]' >> .hg/hgrc
   $ printf 'simple = "{rev}\\n"\n' >> .hg/hgrc
   $ printf 'simple2 = {rev}\\n\n' >> .hg/hgrc
 
   $ hg log -l1 -Tsimple
   8
   $ hg log -l1 -Tsimple2
   8
 
 Test templates and style maps in files:
 
   $ echo "{rev}" > tmpl
   $ hg log -l1 -T./tmpl
   8
   $ hg log -l1 -Tblah/blah
   blah/blah (no-eol)
 
   $ printf 'changeset = "{rev}\\n"\n' > map-simple
   $ hg log -l1 -T./map-simple
   8
 
 Template should precede style option
 
   $ hg log -l1 --style default -T '{rev}\n'
   8
 
 Add a commit with empty description, to ensure that the templates
 below will omit the description line.
 
   $ echo c >> c
   $ hg add c
   $ hg commit -qm ' '
 
 Default style is like normal output. Phases style should be the same
 as default style, except for extra phase lines.
 
   $ hg log > log.out
   $ hg log --style default > style.out
   $ cmp log.out style.out || diff -u log.out style.out
   $ hg log -T phases > phases.out
   $ diff -U 0 log.out phases.out | egrep -v '^---|^\+\+\+|^@@'
   +phase:       draft
   +phase:       draft
   +phase:       draft
   +phase:       draft
   +phase:       draft
   +phase:       draft
   +phase:       draft
   +phase:       draft
   +phase:       draft
   +phase:       draft
 
   $ hg log -v > log.out
   $ hg log -v --style default > style.out
   $ cmp log.out style.out || diff -u log.out style.out
   $ hg log -v -T phases > phases.out
   $ diff -U 0 log.out phases.out | egrep -v '^---|^\+\+\+|^@@'
   +phase:       draft
   +phase:       draft
   +phase:       draft
   +phase:       draft
   +phase:       draft
   +phase:       draft
   +phase:       draft
   +phase:       draft
   +phase:       draft
   +phase:       draft
 
   $ hg log -q > log.out
   $ hg log -q --style default > style.out
   $ cmp log.out style.out || diff -u log.out style.out
   $ hg log -q -T phases > phases.out
   $ cmp log.out phases.out || diff -u log.out phases.out
 
   $ hg log --debug > log.out
   $ hg log --debug --style default > style.out
   $ cmp log.out style.out || diff -u log.out style.out
   $ hg log --debug -T phases > phases.out
   $ cmp log.out phases.out || diff -u log.out phases.out
 
 Default style of working-directory revision should also be the same (but
 date may change while running tests):
 
   $ hg log -r 'wdir()' | sed 's|^date:.*|date:|' > log.out
   $ hg log -r 'wdir()' --style default | sed 's|^date:.*|date:|' > style.out
   $ cmp log.out style.out || diff -u log.out style.out
 
   $ hg log -r 'wdir()' -v | sed 's|^date:.*|date:|' > log.out
   $ hg log -r 'wdir()' -v --style default | sed 's|^date:.*|date:|' > style.out
   $ cmp log.out style.out || diff -u log.out style.out
 
   $ hg log -r 'wdir()' -q > log.out
   $ hg log -r 'wdir()' -q --style default > style.out
   $ cmp log.out style.out || diff -u log.out style.out
 
   $ hg log -r 'wdir()' --debug | sed 's|^date:.*|date:|' > log.out
   $ hg log -r 'wdir()' --debug --style default \
   > | sed 's|^date:.*|date:|' > style.out
   $ cmp log.out style.out || diff -u log.out style.out
 
 Default style should also preserve color information (issue2866):
 
   $ cp $HGRCPATH $HGRCPATH-bak
   $ cat <<EOF >> $HGRCPATH
   > [extensions]
   > color=
   > EOF
 
   $ hg --color=debug log > log.out
   $ hg --color=debug log --style default > style.out
   $ cmp log.out style.out || diff -u log.out style.out
   $ hg --color=debug log -T phases > phases.out
   $ diff -U 0 log.out phases.out | egrep -v '^---|^\+\+\+|^@@'
   +[log.phase|phase:       draft]
   +[log.phase|phase:       draft]
   +[log.phase|phase:       draft]
   +[log.phase|phase:       draft]
   +[log.phase|phase:       draft]
   +[log.phase|phase:       draft]
   +[log.phase|phase:       draft]
   +[log.phase|phase:       draft]
   +[log.phase|phase:       draft]
   +[log.phase|phase:       draft]
 
   $ hg --color=debug -v log > log.out
   $ hg --color=debug -v log --style default > style.out
   $ cmp log.out style.out || diff -u log.out style.out
   $ hg --color=debug -v log -T phases > phases.out
   $ diff -U 0 log.out phases.out | egrep -v '^---|^\+\+\+|^@@'
   +[log.phase|phase:       draft]
   +[log.phase|phase:       draft]
   +[log.phase|phase:       draft]
   +[log.phase|phase:       draft]
   +[log.phase|phase:       draft]
   +[log.phase|phase:       draft]
   +[log.phase|phase:       draft]
   +[log.phase|phase:       draft]
   +[log.phase|phase:       draft]
   +[log.phase|phase:       draft]
 
   $ hg --color=debug -q log > log.out
   $ hg --color=debug -q log --style default > style.out
   $ cmp log.out style.out || diff -u log.out style.out
   $ hg --color=debug -q log -T phases > phases.out
   $ cmp log.out phases.out || diff -u log.out phases.out
 
   $ hg --color=debug --debug log > log.out
   $ hg --color=debug --debug log --style default > style.out
   $ cmp log.out style.out || diff -u log.out style.out
   $ hg --color=debug --debug log -T phases > phases.out
   $ cmp log.out phases.out || diff -u log.out phases.out
 
   $ mv $HGRCPATH-bak $HGRCPATH
 
 Remove commit with empty commit message, so as to not pollute further
 tests.
 
   $ hg --config extensions.strip= strip -q .
 
 Revision with no copies (used to print a traceback):
 
   $ hg tip -v --template '\n'
   
 
 Compact style works:
 
   $ hg log -Tcompact
   8[tip]   95c24699272e   2020-01-01 10:01 +0000   test
     third
   
   7:-1   29114dbae42b   1970-01-12 13:46 +0000   user
     second
   
   6:5,4   d41e714fe50d   1970-01-18 08:40 +0000   person
     merge
   
   5:3   13207e5a10d9   1970-01-18 08:40 +0000   person
     new head
   
   4   bbe44766e73d   1970-01-17 04:53 +0000   person
     new branch
   
   3   10e46f2dcbf4   1970-01-16 01:06 +0000   person
     no user, no domain
   
   2   97054abb4ab8   1970-01-14 21:20 +0000   other
     no person
   
   1   b608e9d1a3f0   1970-01-13 17:33 +0000   other
     other 1
   
   0   1e4e1b8f71e0   1970-01-12 13:46 +0000   user
     line 1
   
 
   $ hg log -v --style compact
   8[tip]   95c24699272e   2020-01-01 10:01 +0000   test
     third
   
   7:-1   29114dbae42b   1970-01-12 13:46 +0000   User Name <user@hostname>
     second
   
   6:5,4   d41e714fe50d   1970-01-18 08:40 +0000   person
     merge
   
   5:3   13207e5a10d9   1970-01-18 08:40 +0000   person
     new head
   
   4   bbe44766e73d   1970-01-17 04:53 +0000   person
     new branch
   
   3   10e46f2dcbf4   1970-01-16 01:06 +0000   person
     no user, no domain
   
   2   97054abb4ab8   1970-01-14 21:20 +0000   other@place
     no person
   
   1   b608e9d1a3f0   1970-01-13 17:33 +0000   A. N. Other <other@place>
     other 1
   other 2
   
   other 3
   
   0   1e4e1b8f71e0   1970-01-12 13:46 +0000   User Name <user@hostname>
     line 1
   line 2
   
 
   $ hg log --debug --style compact
   8[tip]:7,-1   95c24699272e   2020-01-01 10:01 +0000   test
     third
   
   7:-1,-1   29114dbae42b   1970-01-12 13:46 +0000   User Name <user@hostname>
     second
   
   6:5,4   d41e714fe50d   1970-01-18 08:40 +0000   person
     merge
   
   5:3,-1   13207e5a10d9   1970-01-18 08:40 +0000   person
     new head
   
   4:3,-1   bbe44766e73d   1970-01-17 04:53 +0000   person
     new branch
   
   3:2,-1   10e46f2dcbf4   1970-01-16 01:06 +0000   person
     no user, no domain
   
   2:1,-1   97054abb4ab8   1970-01-14 21:20 +0000   other@place
     no person
   
   1:0,-1   b608e9d1a3f0   1970-01-13 17:33 +0000   A. N. Other <other@place>
     other 1
   other 2
   
   other 3
   
   0:-1,-1   1e4e1b8f71e0   1970-01-12 13:46 +0000   User Name <user@hostname>
     line 1
   line 2
   
 
 Test xml styles:
 
   $ hg log --style xml -r 'not all()'
   <?xml version="1.0"?>
   <log>
   </log>
 
   $ hg log --style xml
   <?xml version="1.0"?>
   <log>
   <logentry revision="8" node="95c24699272ef57d062b8bccc32c878bf841784a">
   <tag>tip</tag>
   <author email="test">test</author>
   <date>2020-01-01T10:01:00+00:00</date>
   <msg xml:space="preserve">third</msg>
   </logentry>
   <logentry revision="7" node="29114dbae42b9f078cf2714dbe3a86bba8ec7453">
   <parent revision="-1" node="0000000000000000000000000000000000000000" />
   <author email="user@hostname">User Name</author>
   <date>1970-01-12T13:46:40+00:00</date>
   <msg xml:space="preserve">second</msg>
   </logentry>
   <logentry revision="6" node="d41e714fe50d9e4a5f11b4d595d543481b5f980b">
   <parent revision="5" node="13207e5a10d9fd28ec424934298e176197f2c67f" />
   <parent revision="4" node="bbe44766e73d5f11ed2177f1838de10c53ef3e74" />
   <author email="person">person</author>
   <date>1970-01-18T08:40:01+00:00</date>
   <msg xml:space="preserve">merge</msg>
   </logentry>
   <logentry revision="5" node="13207e5a10d9fd28ec424934298e176197f2c67f">
   <parent revision="3" node="10e46f2dcbf4823578cf180f33ecf0b957964c47" />
   <author email="person">person</author>
   <date>1970-01-18T08:40:00+00:00</date>
   <msg xml:space="preserve">new head</msg>
   </logentry>
   <logentry revision="4" node="bbe44766e73d5f11ed2177f1838de10c53ef3e74">
   <branch>foo</branch>
   <author email="person">person</author>
   <date>1970-01-17T04:53:20+00:00</date>
   <msg xml:space="preserve">new branch</msg>
   </logentry>
   <logentry revision="3" node="10e46f2dcbf4823578cf180f33ecf0b957964c47">
   <author email="person">person</author>
   <date>1970-01-16T01:06:40+00:00</date>
   <msg xml:space="preserve">no user, no domain</msg>
   </logentry>
   <logentry revision="2" node="97054abb4ab824450e9164180baf491ae0078465">
   <author email="other@place">other</author>
   <date>1970-01-14T21:20:00+00:00</date>
   <msg xml:space="preserve">no person</msg>
   </logentry>
   <logentry revision="1" node="b608e9d1a3f0273ccf70fb85fd6866b3482bf965">
   <author email="other@place">A. N. Other</author>
   <date>1970-01-13T17:33:20+00:00</date>
   <msg xml:space="preserve">other 1
   other 2
   
   other 3</msg>
   </logentry>
   <logentry revision="0" node="1e4e1b8f71e05681d422154f5421e385fec3454f">
   <author email="user@hostname">User Name</author>
   <date>1970-01-12T13:46:40+00:00</date>
   <msg xml:space="preserve">line 1
   line 2</msg>
   </logentry>
   </log>
 
   $ hg log -v --style xml
   <?xml version="1.0"?>
   <log>
   <logentry revision="8" node="95c24699272ef57d062b8bccc32c878bf841784a">
   <tag>tip</tag>
   <author email="test">test</author>
   <date>2020-01-01T10:01:00+00:00</date>
   <msg xml:space="preserve">third</msg>
   <paths>
   <path action="A">fourth</path>
   <path action="A">third</path>
   <path action="R">second</path>
   </paths>
   <copies>
   <copy source="second">fourth</copy>
   </copies>
   </logentry>
   <logentry revision="7" node="29114dbae42b9f078cf2714dbe3a86bba8ec7453">
   <parent revision="-1" node="0000000000000000000000000000000000000000" />
   <author email="user@hostname">User Name</author>
   <date>1970-01-12T13:46:40+00:00</date>
   <msg xml:space="preserve">second</msg>
   <paths>
   <path action="A">second</path>
   </paths>
   </logentry>
   <logentry revision="6" node="d41e714fe50d9e4a5f11b4d595d543481b5f980b">
   <parent revision="5" node="13207e5a10d9fd28ec424934298e176197f2c67f" />
   <parent revision="4" node="bbe44766e73d5f11ed2177f1838de10c53ef3e74" />
   <author email="person">person</author>
   <date>1970-01-18T08:40:01+00:00</date>
   <msg xml:space="preserve">merge</msg>
   <paths>
   </paths>
   </logentry>
   <logentry revision="5" node="13207e5a10d9fd28ec424934298e176197f2c67f">
   <parent revision="3" node="10e46f2dcbf4823578cf180f33ecf0b957964c47" />
   <author email="person">person</author>
   <date>1970-01-18T08:40:00+00:00</date>
   <msg xml:space="preserve">new head</msg>
   <paths>
   <path action="A">d</path>
   </paths>
   </logentry>
   <logentry revision="4" node="bbe44766e73d5f11ed2177f1838de10c53ef3e74">
   <branch>foo</branch>
   <author email="person">person</author>
   <date>1970-01-17T04:53:20+00:00</date>
   <msg xml:space="preserve">new branch</msg>
   <paths>
   </paths>
   </logentry>
   <logentry revision="3" node="10e46f2dcbf4823578cf180f33ecf0b957964c47">
   <author email="person">person</author>
   <date>1970-01-16T01:06:40+00:00</date>
   <msg xml:space="preserve">no user, no domain</msg>
   <paths>
   <path action="M">c</path>
   </paths>
   </logentry>
   <logentry revision="2" node="97054abb4ab824450e9164180baf491ae0078465">
   <author email="other@place">other</author>
   <date>1970-01-14T21:20:00+00:00</date>
   <msg xml:space="preserve">no person</msg>
   <paths>
   <path action="A">c</path>
   </paths>
   </logentry>
   <logentry revision="1" node="b608e9d1a3f0273ccf70fb85fd6866b3482bf965">
   <author email="other@place">A. N. Other</author>
   <date>1970-01-13T17:33:20+00:00</date>
   <msg xml:space="preserve">other 1
   other 2
   
   other 3</msg>
   <paths>
   <path action="A">b</path>
   </paths>
   </logentry>
   <logentry revision="0" node="1e4e1b8f71e05681d422154f5421e385fec3454f">
   <author email="user@hostname">User Name</author>
   <date>1970-01-12T13:46:40+00:00</date>
   <msg xml:space="preserve">line 1
   line 2</msg>
   <paths>
   <path action="A">a</path>
   </paths>
   </logentry>
   </log>
 
   $ hg log --debug --style xml
   <?xml version="1.0"?>
   <log>
   <logentry revision="8" node="95c24699272ef57d062b8bccc32c878bf841784a">
   <tag>tip</tag>
   <parent revision="7" node="29114dbae42b9f078cf2714dbe3a86bba8ec7453" />
   <parent revision="-1" node="0000000000000000000000000000000000000000" />
   <author email="test">test</author>
   <date>2020-01-01T10:01:00+00:00</date>
   <msg xml:space="preserve">third</msg>
   <paths>
   <path action="A">fourth</path>
   <path action="A">third</path>
   <path action="R">second</path>
   </paths>
   <copies>
   <copy source="second">fourth</copy>
   </copies>
   <extra key="branch">default</extra>
   </logentry>
   <logentry revision="7" node="29114dbae42b9f078cf2714dbe3a86bba8ec7453">
   <parent revision="-1" node="0000000000000000000000000000000000000000" />
   <parent revision="-1" node="0000000000000000000000000000000000000000" />
   <author email="user@hostname">User Name</author>
   <date>1970-01-12T13:46:40+00:00</date>
   <msg xml:space="preserve">second</msg>
   <paths>
   <path action="A">second</path>
   </paths>
   <extra key="branch">default</extra>
   </logentry>
   <logentry revision="6" node="d41e714fe50d9e4a5f11b4d595d543481b5f980b">
   <parent revision="5" node="13207e5a10d9fd28ec424934298e176197f2c67f" />
   <parent revision="4" node="bbe44766e73d5f11ed2177f1838de10c53ef3e74" />
   <author email="person">person</author>
   <date>1970-01-18T08:40:01+00:00</date>
   <msg xml:space="preserve">merge</msg>
   <paths>
   </paths>
   <extra key="branch">default</extra>
   </logentry>
   <logentry revision="5" node="13207e5a10d9fd28ec424934298e176197f2c67f">
   <parent revision="3" node="10e46f2dcbf4823578cf180f33ecf0b957964c47" />
   <parent revision="-1" node="0000000000000000000000000000000000000000" />
   <author email="person">person</author>
   <date>1970-01-18T08:40:00+00:00</date>
   <msg xml:space="preserve">new head</msg>
   <paths>
   <path action="A">d</path>
   </paths>
   <extra key="branch">default</extra>
   </logentry>
   <logentry revision="4" node="bbe44766e73d5f11ed2177f1838de10c53ef3e74">
   <branch>foo</branch>
   <parent revision="3" node="10e46f2dcbf4823578cf180f33ecf0b957964c47" />
   <parent revision="-1" node="0000000000000000000000000000000000000000" />
   <author email="person">person</author>
   <date>1970-01-17T04:53:20+00:00</date>
   <msg xml:space="preserve">new branch</msg>
   <paths>
   </paths>
   <extra key="branch">foo</extra>
   </logentry>
   <logentry revision="3" node="10e46f2dcbf4823578cf180f33ecf0b957964c47">
   <parent revision="2" node="97054abb4ab824450e9164180baf491ae0078465" />
   <parent revision="-1" node="0000000000000000000000000000000000000000" />
   <author email="person">person</author>
   <date>1970-01-16T01:06:40+00:00</date>
   <msg xml:space="preserve">no user, no domain</msg>
   <paths>
   <path action="M">c</path>
   </paths>
   <extra key="branch">default</extra>
   </logentry>
   <logentry revision="2" node="97054abb4ab824450e9164180baf491ae0078465">
   <parent revision="1" node="b608e9d1a3f0273ccf70fb85fd6866b3482bf965" />
   <parent revision="-1" node="0000000000000000000000000000000000000000" />
   <author email="other@place">other</author>
   <date>1970-01-14T21:20:00+00:00</date>
   <msg xml:space="preserve">no person</msg>
   <paths>
   <path action="A">c</path>
   </paths>
   <extra key="branch">default</extra>
   </logentry>
   <logentry revision="1" node="b608e9d1a3f0273ccf70fb85fd6866b3482bf965">
   <parent revision="0" node="1e4e1b8f71e05681d422154f5421e385fec3454f" />
   <parent revision="-1" node="0000000000000000000000000000000000000000" />
   <author email="other@place">A. N. Other</author>
   <date>1970-01-13T17:33:20+00:00</date>
   <msg xml:space="preserve">other 1
   other 2
   
   other 3</msg>
   <paths>
   <path action="A">b</path>
   </paths>
   <extra key="branch">default</extra>
   </logentry>
   <logentry revision="0" node="1e4e1b8f71e05681d422154f5421e385fec3454f">
   <parent revision="-1" node="0000000000000000000000000000000000000000" />
   <parent revision="-1" node="0000000000000000000000000000000000000000" />
   <author email="user@hostname">User Name</author>
   <date>1970-01-12T13:46:40+00:00</date>
   <msg xml:space="preserve">line 1
   line 2</msg>
   <paths>
   <path action="A">a</path>
   </paths>
   <extra key="branch">default</extra>
   </logentry>
   </log>
 
 
 Test JSON style:
 
   $ hg log -k nosuch -Tjson
   []
 
   $ hg log -qr . -Tjson
   [
    {
     "rev": 8,
     "node": "95c24699272ef57d062b8bccc32c878bf841784a"
    }
   ]
 
   $ hg log -vpr . -Tjson --stat
   [
    {
     "rev": 8,
     "node": "95c24699272ef57d062b8bccc32c878bf841784a",
     "branch": "default",
     "phase": "draft",
     "user": "test",
     "date": [1577872860, 0],
     "desc": "third",
     "bookmarks": [],
     "tags": ["tip"],
     "parents": ["29114dbae42b9f078cf2714dbe3a86bba8ec7453"],
     "files": ["fourth", "second", "third"],
     "diffstat": " fourth |  1 +\n second |  1 -\n third  |  1 +\n 3 files changed, 2 insertions(+), 1 deletions(-)\n",
     "diff": "diff -r 29114dbae42b -r 95c24699272e fourth\n--- /dev/null\tThu Jan 01 00:00:00 1970 +0000\n+++ b/fourth\tWed Jan 01 10:01:00 2020 +0000\n@@ -0,0 +1,1 @@\n+second\ndiff -r 29114dbae42b -r 95c24699272e second\n--- a/second\tMon Jan 12 13:46:40 1970 +0000\n+++ /dev/null\tThu Jan 01 00:00:00 1970 +0000\n@@ -1,1 +0,0 @@\n-second\ndiff -r 29114dbae42b -r 95c24699272e third\n--- /dev/null\tThu Jan 01 00:00:00 1970 +0000\n+++ b/third\tWed Jan 01 10:01:00 2020 +0000\n@@ -0,0 +1,1 @@\n+third\n"
    }
   ]
 
 honor --git but not format-breaking diffopts
   $ hg --config diff.noprefix=True log --git -vpr . -Tjson
   [
    {
     "rev": 8,
     "node": "95c24699272ef57d062b8bccc32c878bf841784a",
     "branch": "default",
     "phase": "draft",
     "user": "test",
     "date": [1577872860, 0],
     "desc": "third",
     "bookmarks": [],
     "tags": ["tip"],
     "parents": ["29114dbae42b9f078cf2714dbe3a86bba8ec7453"],
     "files": ["fourth", "second", "third"],
     "diff": "diff --git a/second b/fourth\nrename from second\nrename to fourth\ndiff --git a/third b/third\nnew file mode 100644\n--- /dev/null\n+++ b/third\n@@ -0,0 +1,1 @@\n+third\n"
    }
   ]
 
   $ hg log -T json
   [
    {
     "rev": 8,
     "node": "95c24699272ef57d062b8bccc32c878bf841784a",
     "branch": "default",
     "phase": "draft",
     "user": "test",
     "date": [1577872860, 0],
     "desc": "third",
     "bookmarks": [],
     "tags": ["tip"],
     "parents": ["29114dbae42b9f078cf2714dbe3a86bba8ec7453"]
    },
    {
     "rev": 7,
     "node": "29114dbae42b9f078cf2714dbe3a86bba8ec7453",
     "branch": "default",
     "phase": "draft",
     "user": "User Name <user@hostname>",
     "date": [1000000, 0],
     "desc": "second",
     "bookmarks": [],
     "tags": [],
     "parents": ["0000000000000000000000000000000000000000"]
    },
    {
     "rev": 6,
     "node": "d41e714fe50d9e4a5f11b4d595d543481b5f980b",
     "branch": "default",
     "phase": "draft",
     "user": "person",
     "date": [1500001, 0],
     "desc": "merge",
     "bookmarks": [],
     "tags": [],
     "parents": ["13207e5a10d9fd28ec424934298e176197f2c67f", "bbe44766e73d5f11ed2177f1838de10c53ef3e74"]
    },
    {
     "rev": 5,
     "node": "13207e5a10d9fd28ec424934298e176197f2c67f",
     "branch": "default",
     "phase": "draft",
     "user": "person",
     "date": [1500000, 0],
     "desc": "new head",
     "bookmarks": [],
     "tags": [],
     "parents": ["10e46f2dcbf4823578cf180f33ecf0b957964c47"]
    },
    {
     "rev": 4,
     "node": "bbe44766e73d5f11ed2177f1838de10c53ef3e74",
     "branch": "foo",
     "phase": "draft",
     "user": "person",
     "date": [1400000, 0],
     "desc": "new branch",
     "bookmarks": [],
     "tags": [],
     "parents": ["10e46f2dcbf4823578cf180f33ecf0b957964c47"]
    },
    {
     "rev": 3,
     "node": "10e46f2dcbf4823578cf180f33ecf0b957964c47",
     "branch": "default",
     "phase": "draft",
     "user": "person",
     "date": [1300000, 0],
     "desc": "no user, no domain",
     "bookmarks": [],
     "tags": [],
     "parents": ["97054abb4ab824450e9164180baf491ae0078465"]
    },
    {
     "rev": 2,
     "node": "97054abb4ab824450e9164180baf491ae0078465",
     "branch": "default",
     "phase": "draft",
     "user": "other@place",
     "date": [1200000, 0],
     "desc": "no person",
     "bookmarks": [],
     "tags": [],
     "parents": ["b608e9d1a3f0273ccf70fb85fd6866b3482bf965"]
    },
    {
     "rev": 1,
     "node": "b608e9d1a3f0273ccf70fb85fd6866b3482bf965",
     "branch": "default",
     "phase": "draft",
     "user": "A. N. Other <other@place>",
     "date": [1100000, 0],
     "desc": "other 1\nother 2\n\nother 3",
     "bookmarks": [],
     "tags": [],
     "parents": ["1e4e1b8f71e05681d422154f5421e385fec3454f"]
    },
    {
     "rev": 0,
     "node": "1e4e1b8f71e05681d422154f5421e385fec3454f",
     "branch": "default",
     "phase": "draft",
     "user": "User Name <user@hostname>",
     "date": [1000000, 0],
     "desc": "line 1\nline 2",
     "bookmarks": [],
     "tags": [],
     "parents": ["0000000000000000000000000000000000000000"]
    }
   ]
 
   $ hg heads -v -Tjson
   [
    {
     "rev": 8,
     "node": "95c24699272ef57d062b8bccc32c878bf841784a",
     "branch": "default",
     "phase": "draft",
     "user": "test",
     "date": [1577872860, 0],
     "desc": "third",
     "bookmarks": [],
     "tags": ["tip"],
     "parents": ["29114dbae42b9f078cf2714dbe3a86bba8ec7453"],
     "files": ["fourth", "second", "third"]
    },
    {
     "rev": 6,
     "node": "d41e714fe50d9e4a5f11b4d595d543481b5f980b",
     "branch": "default",
     "phase": "draft",
     "user": "person",
     "date": [1500001, 0],
     "desc": "merge",
     "bookmarks": [],
     "tags": [],
     "parents": ["13207e5a10d9fd28ec424934298e176197f2c67f", "bbe44766e73d5f11ed2177f1838de10c53ef3e74"],
     "files": []
    },
    {
     "rev": 4,
     "node": "bbe44766e73d5f11ed2177f1838de10c53ef3e74",
     "branch": "foo",
     "phase": "draft",
     "user": "person",
     "date": [1400000, 0],
     "desc": "new branch",
     "bookmarks": [],
     "tags": [],
     "parents": ["10e46f2dcbf4823578cf180f33ecf0b957964c47"],
     "files": []
    }
   ]
 
   $ hg log --debug -Tjson
   [
    {
     "rev": 8,
     "node": "95c24699272ef57d062b8bccc32c878bf841784a",
     "branch": "default",
     "phase": "draft",
     "user": "test",
     "date": [1577872860, 0],
     "desc": "third",
     "bookmarks": [],
     "tags": ["tip"],
     "parents": ["29114dbae42b9f078cf2714dbe3a86bba8ec7453"],
     "manifest": "94961b75a2da554b4df6fb599e5bfc7d48de0c64",
     "extra": {"branch": "default"},
     "modified": [],
     "added": ["fourth", "third"],
     "removed": ["second"]
    },
    {
     "rev": 7,
     "node": "29114dbae42b9f078cf2714dbe3a86bba8ec7453",
     "branch": "default",
     "phase": "draft",
     "user": "User Name <user@hostname>",
     "date": [1000000, 0],
     "desc": "second",
     "bookmarks": [],
     "tags": [],
     "parents": ["0000000000000000000000000000000000000000"],
     "manifest": "f2dbc354b94e5ec0b4f10680ee0cee816101d0bf",
     "extra": {"branch": "default"},
     "modified": [],
     "added": ["second"],
     "removed": []
    },
    {
     "rev": 6,
     "node": "d41e714fe50d9e4a5f11b4d595d543481b5f980b",
     "branch": "default",
     "phase": "draft",
     "user": "person",
     "date": [1500001, 0],
     "desc": "merge",
     "bookmarks": [],
     "tags": [],
     "parents": ["13207e5a10d9fd28ec424934298e176197f2c67f", "bbe44766e73d5f11ed2177f1838de10c53ef3e74"],
     "manifest": "4dc3def4f9b4c6e8de820f6ee74737f91e96a216",
     "extra": {"branch": "default"},
     "modified": [],
     "added": [],
     "removed": []
    },
    {
     "rev": 5,
     "node": "13207e5a10d9fd28ec424934298e176197f2c67f",
     "branch": "default",
     "phase": "draft",
     "user": "person",
     "date": [1500000, 0],
     "desc": "new head",
     "bookmarks": [],
     "tags": [],
     "parents": ["10e46f2dcbf4823578cf180f33ecf0b957964c47"],
     "manifest": "4dc3def4f9b4c6e8de820f6ee74737f91e96a216",
     "extra": {"branch": "default"},
     "modified": [],
     "added": ["d"],
     "removed": []
    },
    {
     "rev": 4,
     "node": "bbe44766e73d5f11ed2177f1838de10c53ef3e74",
     "branch": "foo",
     "phase": "draft",
     "user": "person",
     "date": [1400000, 0],
     "desc": "new branch",
     "bookmarks": [],
     "tags": [],
     "parents": ["10e46f2dcbf4823578cf180f33ecf0b957964c47"],
     "manifest": "cb5a1327723bada42f117e4c55a303246eaf9ccc",
     "extra": {"branch": "foo"},
     "modified": [],
     "added": [],
     "removed": []
    },
    {
     "rev": 3,
     "node": "10e46f2dcbf4823578cf180f33ecf0b957964c47",
     "branch": "default",
     "phase": "draft",
     "user": "person",
     "date": [1300000, 0],
     "desc": "no user, no domain",
     "bookmarks": [],
     "tags": [],
     "parents": ["97054abb4ab824450e9164180baf491ae0078465"],
     "manifest": "cb5a1327723bada42f117e4c55a303246eaf9ccc",
     "extra": {"branch": "default"},
     "modified": ["c"],
     "added": [],
     "removed": []
    },
    {
     "rev": 2,
     "node": "97054abb4ab824450e9164180baf491ae0078465",
     "branch": "default",
     "phase": "draft",
     "user": "other@place",
     "date": [1200000, 0],
     "desc": "no person",
     "bookmarks": [],
     "tags": [],
     "parents": ["b608e9d1a3f0273ccf70fb85fd6866b3482bf965"],
     "manifest": "6e0e82995c35d0d57a52aca8da4e56139e06b4b1",
     "extra": {"branch": "default"},
     "modified": [],
     "added": ["c"],
     "removed": []
    },
    {
     "rev": 1,
     "node": "b608e9d1a3f0273ccf70fb85fd6866b3482bf965",
     "branch": "default",
     "phase": "draft",
     "user": "A. N. Other <other@place>",
     "date": [1100000, 0],
     "desc": "other 1\nother 2\n\nother 3",
     "bookmarks": [],
     "tags": [],
     "parents": ["1e4e1b8f71e05681d422154f5421e385fec3454f"],
     "manifest": "4e8d705b1e53e3f9375e0e60dc7b525d8211fe55",
     "extra": {"branch": "default"},
     "modified": [],
     "added": ["b"],
     "removed": []
    },
    {
     "rev": 0,
     "node": "1e4e1b8f71e05681d422154f5421e385fec3454f",
     "branch": "default",
     "phase": "draft",
     "user": "User Name <user@hostname>",
     "date": [1000000, 0],
     "desc": "line 1\nline 2",
     "bookmarks": [],
     "tags": [],
     "parents": ["0000000000000000000000000000000000000000"],
     "manifest": "a0c8bcbbb45c63b90b70ad007bf38961f64f2af0",
     "extra": {"branch": "default"},
     "modified": [],
     "added": ["a"],
     "removed": []
    }
   ]
 
 Error if style not readable:
 
 #if unix-permissions no-root
   $ touch q
   $ chmod 0 q
   $ hg log --style ./q
   abort: Permission denied: ./q
   [255]
 #endif
 
 Error if no style:
 
   $ hg log --style notexist
   abort: style 'notexist' not found
   (available styles: bisect, changelog, compact, default, phases, status, xml)
   [255]
 
   $ hg log -T list
   available styles: bisect, changelog, compact, default, phases, status, xml
   abort: specify a template
   [255]
 
 Error if style missing key:
 
   $ echo 'q = q' > t
   $ hg log --style ./t
   abort: "changeset" not in template map
   [255]
 
 Error if style missing value:
 
   $ echo 'changeset =' > t
   $ hg log --style t
   hg: parse error at t:1: missing value
   [255]
 
 Error if include fails:
 
   $ echo 'changeset = q' >> t
 #if unix-permissions no-root
   $ hg log --style ./t
   abort: template file ./q: Permission denied
   [255]
   $ rm -f q
 #endif
 
 Include works:
 
   $ echo '{rev}' > q
   $ hg log --style ./t
   8
   7
   6
   5
   4
   3
   2
   1
   0
 
 Check that recursive reference does not fall into RuntimeError (issue4758):
 
  common mistake:
 
   $ hg log -T '{changeset}\n'
   abort: recursive reference 'changeset' in template
   [255]
 
  circular reference:
 
   $ cat << EOF > issue4758
   > changeset = '{foo}'
   > foo = '{changeset}'
   > EOF
   $ hg log --style ./issue4758
   abort: recursive reference 'foo' in template
   [255]
 
  buildmap() -> gettemplate(), where no thunk was made:
 
   $ hg log -T '{files % changeset}\n'
   abort: recursive reference 'changeset' in template
   [255]
 
  not a recursion if a keyword of the same name exists:
 
   $ cat << EOF > issue4758
   > changeset = '{tags % rev}'
   > rev = '{rev} {tag}\n'
   > EOF
   $ hg log --style ./issue4758 -r tip
   8 tip
 
 Check that {phase} works correctly on parents:
 
   $ cat << EOF > parentphase
   > changeset_debug = '{rev} ({phase}):{parents}\n'
   > parent = ' {rev} ({phase})'
   > EOF
   $ hg phase -r 5 --public
   $ hg phase -r 7 --secret --force
   $ hg log --debug -G --style ./parentphase
   @  8 (secret): 7 (secret) -1 (public)
   |
   o  7 (secret): -1 (public) -1 (public)
   
   o    6 (draft): 5 (public) 4 (draft)
   |\
   | o  5 (public): 3 (public) -1 (public)
   | |
   o |  4 (draft): 3 (public) -1 (public)
   |/
   o  3 (public): 2 (public) -1 (public)
   |
   o  2 (public): 1 (public) -1 (public)
   |
   o  1 (public): 0 (public) -1 (public)
   |
   o  0 (public): -1 (public) -1 (public)
   
 
 Missing non-standard names give no error (backward compatibility):
 
   $ echo "changeset = '{c}'" > t
   $ hg log --style ./t
 
 Defining non-standard name works:
 
   $ cat <<EOF > t
   > changeset = '{c}'
   > c = q
   > EOF
   $ hg log --style ./t
   8
   7
   6
   5
   4
   3
   2
   1
   0
 
 ui.style works:
 
   $ echo '[ui]' > .hg/hgrc
   $ echo 'style = t' >> .hg/hgrc
   $ hg log
   8
   7
   6
   5
   4
   3
   2
   1
   0
 
 
 Issue338:
 
   $ hg log --style=changelog > changelog
 
   $ cat changelog
   2020-01-01  test  <test>
   
   	* fourth, second, third:
   	third
   	[95c24699272e] [tip]
   
   1970-01-12  User Name  <user@hostname>
   
   	* second:
   	second
   	[29114dbae42b]
   
   1970-01-18  person  <person>
   
   	* merge
   	[d41e714fe50d]
   
   	* d:
   	new head
   	[13207e5a10d9]
   
   1970-01-17  person  <person>
   
   	* new branch
   	[bbe44766e73d] <foo>
   
   1970-01-16  person  <person>
   
   	* c:
   	no user, no domain
   	[10e46f2dcbf4]
   
   1970-01-14  other  <other@place>
   
   	* c:
   	no person
   	[97054abb4ab8]
   
   1970-01-13  A. N. Other  <other@place>
   
   	* b:
   	other 1 other 2
   
   	other 3
   	[b608e9d1a3f0]
   
   1970-01-12  User Name  <user@hostname>
   
   	* a:
   	line 1 line 2
   	[1e4e1b8f71e0]
   
 
 Issue2130: xml output for 'hg heads' is malformed
 
   $ hg heads --style changelog
   2020-01-01  test  <test>
   
   	* fourth, second, third:
   	third
   	[95c24699272e] [tip]
   
   1970-01-18  person  <person>
   
   	* merge
   	[d41e714fe50d]
   
   1970-01-17  person  <person>
   
   	* new branch
   	[bbe44766e73d] <foo>
   
 
 Keys work:
 
   $ for key in author branch branches date desc file_adds file_dels file_mods \
   >         file_copies file_copies_switch files \
   >         manifest node parents rev tags diffstat extras \
   >         p1rev p2rev p1node p2node; do
   >     for mode in '' --verbose --debug; do
   >         hg log $mode --template "$key$mode: {$key}\n"
   >     done
   > done
   author: test
   author: User Name <user@hostname>
   author: person
   author: person
   author: person
   author: person
   author: other@place
   author: A. N. Other <other@place>
   author: User Name <user@hostname>
   author--verbose: test
   author--verbose: User Name <user@hostname>
   author--verbose: person
   author--verbose: person
   author--verbose: person
   author--verbose: person
   author--verbose: other@place
   author--verbose: A. N. Other <other@place>
   author--verbose: User Name <user@hostname>
   author--debug: test
   author--debug: User Name <user@hostname>
   author--debug: person
   author--debug: person
   author--debug: person
   author--debug: person
   author--debug: other@place
   author--debug: A. N. Other <other@place>
   author--debug: User Name <user@hostname>
   branch: default
   branch: default
   branch: default
   branch: default
   branch: foo
   branch: default
   branch: default
   branch: default
   branch: default
   branch--verbose: default
   branch--verbose: default
   branch--verbose: default
   branch--verbose: default
   branch--verbose: foo
   branch--verbose: default
   branch--verbose: default
   branch--verbose: default
   branch--verbose: default
   branch--debug: default
   branch--debug: default
   branch--debug: default
   branch--debug: default
   branch--debug: foo
   branch--debug: default
   branch--debug: default
   branch--debug: default
   branch--debug: default
   branches: 
   branches: 
   branches: 
   branches: 
   branches: foo
   branches: 
   branches: 
   branches: 
   branches: 
   branches--verbose: 
   branches--verbose: 
   branches--verbose: 
   branches--verbose: 
   branches--verbose: foo
   branches--verbose: 
   branches--verbose: 
   branches--verbose: 
   branches--verbose: 
   branches--debug: 
   branches--debug: 
   branches--debug: 
   branches--debug: 
   branches--debug: foo
   branches--debug: 
   branches--debug: 
   branches--debug: 
   branches--debug: 
   date: 1577872860.00
   date: 1000000.00
   date: 1500001.00
   date: 1500000.00
   date: 1400000.00
   date: 1300000.00
   date: 1200000.00
   date: 1100000.00
   date: 1000000.00
   date--verbose: 1577872860.00
   date--verbose: 1000000.00
   date--verbose: 1500001.00
   date--verbose: 1500000.00
   date--verbose: 1400000.00
   date--verbose: 1300000.00
   date--verbose: 1200000.00
   date--verbose: 1100000.00
   date--verbose: 1000000.00
   date--debug: 1577872860.00
   date--debug: 1000000.00
   date--debug: 1500001.00
   date--debug: 1500000.00
   date--debug: 1400000.00
   date--debug: 1300000.00
   date--debug: 1200000.00
   date--debug: 1100000.00
   date--debug: 1000000.00
   desc: third
   desc: second
   desc: merge
   desc: new head
   desc: new branch
   desc: no user, no domain
   desc: no person
   desc: other 1
   other 2
   
   other 3
   desc: line 1
   line 2
   desc--verbose: third
   desc--verbose: second
   desc--verbose: merge
   desc--verbose: new head
   desc--verbose: new branch
   desc--verbose: no user, no domain
   desc--verbose: no person
   desc--verbose: other 1
   other 2
   
   other 3
   desc--verbose: line 1
   line 2
   desc--debug: third
   desc--debug: second
   desc--debug: merge
   desc--debug: new head
   desc--debug: new branch
   desc--debug: no user, no domain
   desc--debug: no person
   desc--debug: other 1
   other 2
   
   other 3
   desc--debug: line 1
   line 2
   file_adds: fourth third
   file_adds: second
   file_adds: 
   file_adds: d
   file_adds: 
   file_adds: 
   file_adds: c
   file_adds: b
   file_adds: a
   file_adds--verbose: fourth third
   file_adds--verbose: second
   file_adds--verbose: 
   file_adds--verbose: d
   file_adds--verbose: 
   file_adds--verbose: 
   file_adds--verbose: c
   file_adds--verbose: b
   file_adds--verbose: a
   file_adds--debug: fourth third
   file_adds--debug: second
   file_adds--debug: 
   file_adds--debug: d
   file_adds--debug: 
   file_adds--debug: 
   file_adds--debug: c
   file_adds--debug: b
   file_adds--debug: a
   file_dels: second
   file_dels: 
   file_dels: 
   file_dels: 
   file_dels: 
   file_dels: 
   file_dels: 
   file_dels: 
   file_dels: 
   file_dels--verbose: second
   file_dels--verbose: 
   file_dels--verbose: 
   file_dels--verbose: 
   file_dels--verbose: 
   file_dels--verbose: 
   file_dels--verbose: 
   file_dels--verbose: 
   file_dels--verbose: 
   file_dels--debug: second
   file_dels--debug: 
   file_dels--debug: 
   file_dels--debug: 
   file_dels--debug: 
   file_dels--debug: 
   file_dels--debug: 
   file_dels--debug: 
   file_dels--debug: 
   file_mods: 
   file_mods: 
   file_mods: 
   file_mods: 
   file_mods: 
   file_mods: c
   file_mods: 
   file_mods: 
   file_mods: 
   file_mods--verbose: 
   file_mods--verbose: 
   file_mods--verbose: 
   file_mods--verbose: 
   file_mods--verbose: 
   file_mods--verbose: c
   file_mods--verbose: 
   file_mods--verbose: 
   file_mods--verbose: 
   file_mods--debug: 
   file_mods--debug: 
   file_mods--debug: 
   file_mods--debug: 
   file_mods--debug: 
   file_mods--debug: c
   file_mods--debug: 
   file_mods--debug: 
   file_mods--debug: 
   file_copies: fourth (second)
   file_copies: 
   file_copies: 
   file_copies: 
   file_copies: 
   file_copies: 
   file_copies: 
   file_copies: 
   file_copies: 
   file_copies--verbose: fourth (second)
   file_copies--verbose: 
   file_copies--verbose: 
   file_copies--verbose: 
   file_copies--verbose: 
   file_copies--verbose: 
   file_copies--verbose: 
   file_copies--verbose: 
   file_copies--verbose: 
   file_copies--debug: fourth (second)
   file_copies--debug: 
   file_copies--debug: 
   file_copies--debug: 
   file_copies--debug: 
   file_copies--debug: 
   file_copies--debug: 
   file_copies--debug: 
   file_copies--debug: 
   file_copies_switch: 
   file_copies_switch: 
   file_copies_switch: 
   file_copies_switch: 
   file_copies_switch: 
   file_copies_switch: 
   file_copies_switch: 
   file_copies_switch: 
   file_copies_switch: 
   file_copies_switch--verbose: 
   file_copies_switch--verbose: 
   file_copies_switch--verbose: 
   file_copies_switch--verbose: 
   file_copies_switch--verbose: 
   file_copies_switch--verbose: 
   file_copies_switch--verbose: 
   file_copies_switch--verbose: 
   file_copies_switch--verbose: 
   file_copies_switch--debug: 
   file_copies_switch--debug: 
   file_copies_switch--debug: 
   file_copies_switch--debug: 
   file_copies_switch--debug: 
   file_copies_switch--debug: 
   file_copies_switch--debug: 
   file_copies_switch--debug: 
   file_copies_switch--debug: 
   files: fourth second third
   files: second
   files: 
   files: d
   files: 
   files: c
   files: c
   files: b
   files: a
   files--verbose: fourth second third
   files--verbose: second
   files--verbose: 
   files--verbose: d
   files--verbose: 
   files--verbose: c
   files--verbose: c
   files--verbose: b
   files--verbose: a
   files--debug: fourth second third
   files--debug: second
   files--debug: 
   files--debug: d
   files--debug: 
   files--debug: c
   files--debug: c
   files--debug: b
   files--debug: a
   manifest: 6:94961b75a2da
   manifest: 5:f2dbc354b94e
   manifest: 4:4dc3def4f9b4
   manifest: 4:4dc3def4f9b4
   manifest: 3:cb5a1327723b
   manifest: 3:cb5a1327723b
   manifest: 2:6e0e82995c35
   manifest: 1:4e8d705b1e53
   manifest: 0:a0c8bcbbb45c
   manifest--verbose: 6:94961b75a2da
   manifest--verbose: 5:f2dbc354b94e
   manifest--verbose: 4:4dc3def4f9b4
   manifest--verbose: 4:4dc3def4f9b4
   manifest--verbose: 3:cb5a1327723b
   manifest--verbose: 3:cb5a1327723b
   manifest--verbose: 2:6e0e82995c35
   manifest--verbose: 1:4e8d705b1e53
   manifest--verbose: 0:a0c8bcbbb45c
   manifest--debug: 6:94961b75a2da554b4df6fb599e5bfc7d48de0c64
   manifest--debug: 5:f2dbc354b94e5ec0b4f10680ee0cee816101d0bf
   manifest--debug: 4:4dc3def4f9b4c6e8de820f6ee74737f91e96a216
   manifest--debug: 4:4dc3def4f9b4c6e8de820f6ee74737f91e96a216
   manifest--debug: 3:cb5a1327723bada42f117e4c55a303246eaf9ccc
   manifest--debug: 3:cb5a1327723bada42f117e4c55a303246eaf9ccc
   manifest--debug: 2:6e0e82995c35d0d57a52aca8da4e56139e06b4b1
   manifest--debug: 1:4e8d705b1e53e3f9375e0e60dc7b525d8211fe55
   manifest--debug: 0:a0c8bcbbb45c63b90b70ad007bf38961f64f2af0
   node: 95c24699272ef57d062b8bccc32c878bf841784a
   node: 29114dbae42b9f078cf2714dbe3a86bba8ec7453
   node: d41e714fe50d9e4a5f11b4d595d543481b5f980b
   node: 13207e5a10d9fd28ec424934298e176197f2c67f
   node: bbe44766e73d5f11ed2177f1838de10c53ef3e74
   node: 10e46f2dcbf4823578cf180f33ecf0b957964c47
   node: 97054abb4ab824450e9164180baf491ae0078465
   node: b608e9d1a3f0273ccf70fb85fd6866b3482bf965
   node: 1e4e1b8f71e05681d422154f5421e385fec3454f
   node--verbose: 95c24699272ef57d062b8bccc32c878bf841784a
   node--verbose: 29114dbae42b9f078cf2714dbe3a86bba8ec7453
   node--verbose: d41e714fe50d9e4a5f11b4d595d543481b5f980b
   node--verbose: 13207e5a10d9fd28ec424934298e176197f2c67f
   node--verbose: bbe44766e73d5f11ed2177f1838de10c53ef3e74
   node--verbose: 10e46f2dcbf4823578cf180f33ecf0b957964c47
   node--verbose: 97054abb4ab824450e9164180baf491ae0078465
   node--verbose: b608e9d1a3f0273ccf70fb85fd6866b3482bf965
   node--verbose: 1e4e1b8f71e05681d422154f5421e385fec3454f
   node--debug: 95c24699272ef57d062b8bccc32c878bf841784a
   node--debug: 29114dbae42b9f078cf2714dbe3a86bba8ec7453
   node--debug: d41e714fe50d9e4a5f11b4d595d543481b5f980b
   node--debug: 13207e5a10d9fd28ec424934298e176197f2c67f
   node--debug: bbe44766e73d5f11ed2177f1838de10c53ef3e74
   node--debug: 10e46f2dcbf4823578cf180f33ecf0b957964c47
   node--debug: 97054abb4ab824450e9164180baf491ae0078465
   node--debug: b608e9d1a3f0273ccf70fb85fd6866b3482bf965
   node--debug: 1e4e1b8f71e05681d422154f5421e385fec3454f
   parents: 
   parents: -1:000000000000 
   parents: 5:13207e5a10d9 4:bbe44766e73d 
   parents: 3:10e46f2dcbf4 
   parents: 
   parents: 
   parents: 
   parents: 
   parents: 
   parents--verbose: 
   parents--verbose: -1:000000000000 
   parents--verbose: 5:13207e5a10d9 4:bbe44766e73d 
   parents--verbose: 3:10e46f2dcbf4 
   parents--verbose: 
   parents--verbose: 
   parents--verbose: 
   parents--verbose: 
   parents--verbose: 
   parents--debug: 7:29114dbae42b9f078cf2714dbe3a86bba8ec7453 -1:0000000000000000000000000000000000000000 
   parents--debug: -1:0000000000000000000000000000000000000000 -1:0000000000000000000000000000000000000000 
   parents--debug: 5:13207e5a10d9fd28ec424934298e176197f2c67f 4:bbe44766e73d5f11ed2177f1838de10c53ef3e74 
   parents--debug: 3:10e46f2dcbf4823578cf180f33ecf0b957964c47 -1:0000000000000000000000000000000000000000 
   parents--debug: 3:10e46f2dcbf4823578cf180f33ecf0b957964c47 -1:0000000000000000000000000000000000000000 
   parents--debug: 2:97054abb4ab824450e9164180baf491ae0078465 -1:0000000000000000000000000000000000000000 
   parents--debug: 1:b608e9d1a3f0273ccf70fb85fd6866b3482bf965 -1:0000000000000000000000000000000000000000 
   parents--debug: 0:1e4e1b8f71e05681d422154f5421e385fec3454f -1:0000000000000000000000000000000000000000 
   parents--debug: -1:0000000000000000000000000000000000000000 -1:0000000000000000000000000000000000000000 
   rev: 8
   rev: 7
   rev: 6
   rev: 5
   rev: 4
   rev: 3
   rev: 2
   rev: 1
   rev: 0
   rev--verbose: 8
   rev--verbose: 7
   rev--verbose: 6
   rev--verbose: 5
   rev--verbose: 4
   rev--verbose: 3
   rev--verbose: 2
   rev--verbose: 1
   rev--verbose: 0
   rev--debug: 8
   rev--debug: 7
   rev--debug: 6
   rev--debug: 5
   rev--debug: 4
   rev--debug: 3
   rev--debug: 2
   rev--debug: 1
   rev--debug: 0
   tags: tip
   tags: 
   tags: 
   tags: 
   tags: 
   tags: 
   tags: 
   tags: 
   tags: 
   tags--verbose: tip
   tags--verbose: 
   tags--verbose: 
   tags--verbose: 
   tags--verbose: 
   tags--verbose: 
   tags--verbose: 
   tags--verbose: 
   tags--verbose: 
   tags--debug: tip
   tags--debug: 
   tags--debug: 
   tags--debug: 
   tags--debug: 
   tags--debug: 
   tags--debug: 
   tags--debug: 
   tags--debug: 
   diffstat: 3: +2/-1
   diffstat: 1: +1/-0
   diffstat: 0: +0/-0
   diffstat: 1: +1/-0
   diffstat: 0: +0/-0
   diffstat: 1: +1/-0
   diffstat: 1: +4/-0
   diffstat: 1: +2/-0
   diffstat: 1: +1/-0
   diffstat--verbose: 3: +2/-1
   diffstat--verbose: 1: +1/-0
   diffstat--verbose: 0: +0/-0
   diffstat--verbose: 1: +1/-0
   diffstat--verbose: 0: +0/-0
   diffstat--verbose: 1: +1/-0
   diffstat--verbose: 1: +4/-0
   diffstat--verbose: 1: +2/-0
   diffstat--verbose: 1: +1/-0
   diffstat--debug: 3: +2/-1
   diffstat--debug: 1: +1/-0
   diffstat--debug: 0: +0/-0
   diffstat--debug: 1: +1/-0
   diffstat--debug: 0: +0/-0
   diffstat--debug: 1: +1/-0
   diffstat--debug: 1: +4/-0
   diffstat--debug: 1: +2/-0
   diffstat--debug: 1: +1/-0
   extras: branch=default
   extras: branch=default
   extras: branch=default
   extras: branch=default
   extras: branch=foo
   extras: branch=default
   extras: branch=default
   extras: branch=default
   extras: branch=default
   extras--verbose: branch=default
   extras--verbose: branch=default
   extras--verbose: branch=default
   extras--verbose: branch=default
   extras--verbose: branch=foo
   extras--verbose: branch=default
   extras--verbose: branch=default
   extras--verbose: branch=default
   extras--verbose: branch=default
   extras--debug: branch=default
   extras--debug: branch=default
   extras--debug: branch=default
   extras--debug: branch=default
   extras--debug: branch=foo
   extras--debug: branch=default
   extras--debug: branch=default
   extras--debug: branch=default
   extras--debug: branch=default
   p1rev: 7
   p1rev: -1
   p1rev: 5
   p1rev: 3
   p1rev: 3
   p1rev: 2
   p1rev: 1
   p1rev: 0
   p1rev: -1
   p1rev--verbose: 7
   p1rev--verbose: -1
   p1rev--verbose: 5
   p1rev--verbose: 3
   p1rev--verbose: 3
   p1rev--verbose: 2
   p1rev--verbose: 1
   p1rev--verbose: 0
   p1rev--verbose: -1
   p1rev--debug: 7
   p1rev--debug: -1
   p1rev--debug: 5
   p1rev--debug: 3
   p1rev--debug: 3
   p1rev--debug: 2
   p1rev--debug: 1
   p1rev--debug: 0
   p1rev--debug: -1
   p2rev: -1
   p2rev: -1
   p2rev: 4
   p2rev: -1
   p2rev: -1
   p2rev: -1
   p2rev: -1
   p2rev: -1
   p2rev: -1
   p2rev--verbose: -1
   p2rev--verbose: -1
   p2rev--verbose: 4
   p2rev--verbose: -1
   p2rev--verbose: -1
   p2rev--verbose: -1
   p2rev--verbose: -1
   p2rev--verbose: -1
   p2rev--verbose: -1
   p2rev--debug: -1
   p2rev--debug: -1
   p2rev--debug: 4
   p2rev--debug: -1
   p2rev--debug: -1
   p2rev--debug: -1
   p2rev--debug: -1
   p2rev--debug: -1
   p2rev--debug: -1
   p1node: 29114dbae42b9f078cf2714dbe3a86bba8ec7453
   p1node: 0000000000000000000000000000000000000000
   p1node: 13207e5a10d9fd28ec424934298e176197f2c67f
   p1node: 10e46f2dcbf4823578cf180f33ecf0b957964c47
   p1node: 10e46f2dcbf4823578cf180f33ecf0b957964c47
   p1node: 97054abb4ab824450e9164180baf491ae0078465
   p1node: b608e9d1a3f0273ccf70fb85fd6866b3482bf965
   p1node: 1e4e1b8f71e05681d422154f5421e385fec3454f
   p1node: 0000000000000000000000000000000000000000
   p1node--verbose: 29114dbae42b9f078cf2714dbe3a86bba8ec7453
   p1node--verbose: 0000000000000000000000000000000000000000
   p1node--verbose: 13207e5a10d9fd28ec424934298e176197f2c67f
   p1node--verbose: 10e46f2dcbf4823578cf180f33ecf0b957964c47
   p1node--verbose: 10e46f2dcbf4823578cf180f33ecf0b957964c47
   p1node--verbose: 97054abb4ab824450e9164180baf491ae0078465
   p1node--verbose: b608e9d1a3f0273ccf70fb85fd6866b3482bf965
   p1node--verbose: 1e4e1b8f71e05681d422154f5421e385fec3454f
   p1node--verbose: 0000000000000000000000000000000000000000
   p1node--debug: 29114dbae42b9f078cf2714dbe3a86bba8ec7453
   p1node--debug: 0000000000000000000000000000000000000000
   p1node--debug: 13207e5a10d9fd28ec424934298e176197f2c67f
   p1node--debug: 10e46f2dcbf4823578cf180f33ecf0b957964c47
   p1node--debug: 10e46f2dcbf4823578cf180f33ecf0b957964c47
   p1node--debug: 97054abb4ab824450e9164180baf491ae0078465
   p1node--debug: b608e9d1a3f0273ccf70fb85fd6866b3482bf965
   p1node--debug: 1e4e1b8f71e05681d422154f5421e385fec3454f
   p1node--debug: 0000000000000000000000000000000000000000
   p2node: 0000000000000000000000000000000000000000
   p2node: 0000000000000000000000000000000000000000
   p2node: bbe44766e73d5f11ed2177f1838de10c53ef3e74
   p2node: 0000000000000000000000000000000000000000
   p2node: 0000000000000000000000000000000000000000
   p2node: 0000000000000000000000000000000000000000
   p2node: 0000000000000000000000000000000000000000
   p2node: 0000000000000000000000000000000000000000
   p2node: 0000000000000000000000000000000000000000
   p2node--verbose: 0000000000000000000000000000000000000000
   p2node--verbose: 0000000000000000000000000000000000000000
   p2node--verbose: bbe44766e73d5f11ed2177f1838de10c53ef3e74
   p2node--verbose: 0000000000000000000000000000000000000000
   p2node--verbose: 0000000000000000000000000000000000000000
   p2node--verbose: 0000000000000000000000000000000000000000
   p2node--verbose: 0000000000000000000000000000000000000000
   p2node--verbose: 0000000000000000000000000000000000000000
   p2node--verbose: 0000000000000000000000000000000000000000
   p2node--debug: 0000000000000000000000000000000000000000
   p2node--debug: 0000000000000000000000000000000000000000
   p2node--debug: bbe44766e73d5f11ed2177f1838de10c53ef3e74
   p2node--debug: 0000000000000000000000000000000000000000
   p2node--debug: 0000000000000000000000000000000000000000
   p2node--debug: 0000000000000000000000000000000000000000
   p2node--debug: 0000000000000000000000000000000000000000
   p2node--debug: 0000000000000000000000000000000000000000
   p2node--debug: 0000000000000000000000000000000000000000
 
 Filters work:
 
   $ hg log --template '{author|domain}\n'
   
   hostname
   
   
   
   
   place
   place
   hostname
 
   $ hg log --template '{author|person}\n'
   test
   User Name
   person
   person
   person
   person
   other
   A. N. Other
   User Name
 
   $ hg log --template '{author|user}\n'
   test
   user
   person
   person
   person
   person
   other
   other
   user
 
   $ hg log --template '{date|date}\n'
   Wed Jan 01 10:01:00 2020 +0000
   Mon Jan 12 13:46:40 1970 +0000
   Sun Jan 18 08:40:01 1970 +0000
   Sun Jan 18 08:40:00 1970 +0000
   Sat Jan 17 04:53:20 1970 +0000
   Fri Jan 16 01:06:40 1970 +0000
   Wed Jan 14 21:20:00 1970 +0000
   Tue Jan 13 17:33:20 1970 +0000
   Mon Jan 12 13:46:40 1970 +0000
 
   $ hg log --template '{date|isodate}\n'
   2020-01-01 10:01 +0000
   1970-01-12 13:46 +0000
   1970-01-18 08:40 +0000
   1970-01-18 08:40 +0000
   1970-01-17 04:53 +0000
   1970-01-16 01:06 +0000
   1970-01-14 21:20 +0000
   1970-01-13 17:33 +0000
   1970-01-12 13:46 +0000
 
   $ hg log --template '{date|isodatesec}\n'
   2020-01-01 10:01:00 +0000
   1970-01-12 13:46:40 +0000
   1970-01-18 08:40:01 +0000
   1970-01-18 08:40:00 +0000
   1970-01-17 04:53:20 +0000
   1970-01-16 01:06:40 +0000
   1970-01-14 21:20:00 +0000
   1970-01-13 17:33:20 +0000
   1970-01-12 13:46:40 +0000
 
   $ hg log --template '{date|rfc822date}\n'
   Wed, 01 Jan 2020 10:01:00 +0000
   Mon, 12 Jan 1970 13:46:40 +0000
   Sun, 18 Jan 1970 08:40:01 +0000
   Sun, 18 Jan 1970 08:40:00 +0000
   Sat, 17 Jan 1970 04:53:20 +0000
   Fri, 16 Jan 1970 01:06:40 +0000
   Wed, 14 Jan 1970 21:20:00 +0000
   Tue, 13 Jan 1970 17:33:20 +0000
   Mon, 12 Jan 1970 13:46:40 +0000
 
   $ hg log --template '{desc|firstline}\n'
   third
   second
   merge
   new head
   new branch
   no user, no domain
   no person
   other 1
   line 1
 
   $ hg log --template '{node|short}\n'
   95c24699272e
   29114dbae42b
   d41e714fe50d
   13207e5a10d9
   bbe44766e73d
   10e46f2dcbf4
   97054abb4ab8
   b608e9d1a3f0
   1e4e1b8f71e0
 
   $ hg log --template '<changeset author="{author|xmlescape}"/>\n'
   <changeset author="test"/>
   <changeset author="User Name &lt;user@hostname&gt;"/>
   <changeset author="person"/>
   <changeset author="person"/>
   <changeset author="person"/>
   <changeset author="person"/>
   <changeset author="other@place"/>
   <changeset author="A. N. Other &lt;other@place&gt;"/>
   <changeset author="User Name &lt;user@hostname&gt;"/>
 
   $ hg log --template '{rev}: {children}\n'
   8: 
   7: 8:95c24699272e
   6: 
   5: 6:d41e714fe50d
   4: 6:d41e714fe50d
   3: 4:bbe44766e73d 5:13207e5a10d9
   2: 3:10e46f2dcbf4
   1: 2:97054abb4ab8
   0: 1:b608e9d1a3f0
 
 Formatnode filter works:
 
   $ hg -q log -r 0 --template '{node|formatnode}\n'
   1e4e1b8f71e0
 
   $ hg log -r 0 --template '{node|formatnode}\n'
   1e4e1b8f71e0
 
   $ hg -v log -r 0 --template '{node|formatnode}\n'
   1e4e1b8f71e0
 
   $ hg --debug log -r 0 --template '{node|formatnode}\n'
   1e4e1b8f71e05681d422154f5421e385fec3454f
 
 Age filter:
 
   $ hg init unstable-hash
   $ cd unstable-hash
   $ hg log --template '{date|age}\n' > /dev/null || exit 1
 
   >>> from datetime import datetime, timedelta
   >>> fp = open('a', 'w')
   >>> n = datetime.now() + timedelta(366 * 7)
   >>> fp.write('%d-%d-%d 00:00' % (n.year, n.month, n.day))
   >>> fp.close()
   $ hg add a
   $ hg commit -m future -d "`cat a`"
 
   $ hg log -l1 --template '{date|age}\n'
   7 years from now
 
   $ cd ..
   $ rm -rf unstable-hash
 
 Add a dummy commit to make up for the instability of the above:
 
   $ echo a > a
   $ hg add a
   $ hg ci -m future
 
 Count filter:
 
   $ hg log -l1 --template '{node|count} {node|short|count}\n'
   40 12
 
   $ hg log -l1 --template '{revset("null^")|count} {revset(".")|count} {revset("0::3")|count}\n'
   0 1 4
 
   $ hg log -G --template '{rev}: children: {children|count}, \
   > tags: {tags|count}, file_adds: {file_adds|count}, \
   > ancestors: {revset("ancestors(%s)", rev)|count}'
   @  9: children: 0, tags: 1, file_adds: 1, ancestors: 3
   |
   o  8: children: 1, tags: 0, file_adds: 2, ancestors: 2
   |
   o  7: children: 1, tags: 0, file_adds: 1, ancestors: 1
   
   o    6: children: 0, tags: 0, file_adds: 0, ancestors: 7
   |\
   | o  5: children: 1, tags: 0, file_adds: 1, ancestors: 5
   | |
   o |  4: children: 1, tags: 0, file_adds: 0, ancestors: 5
   |/
   o  3: children: 2, tags: 0, file_adds: 0, ancestors: 4
   |
   o  2: children: 1, tags: 0, file_adds: 1, ancestors: 3
   |
   o  1: children: 1, tags: 0, file_adds: 1, ancestors: 2
   |
   o  0: children: 1, tags: 0, file_adds: 1, ancestors: 1
   
 
 Upper/lower filters:
 
   $ hg log -r0 --template '{branch|upper}\n'
   DEFAULT
   $ hg log -r0 --template '{author|lower}\n'
   user name <user@hostname>
   $ hg log -r0 --template '{date|upper}\n'
   abort: template filter 'upper' is not compatible with keyword 'date'
   [255]
 
 Add a commit that does all possible modifications at once
 
   $ echo modify >> third
   $ touch b
   $ hg add b
   $ hg mv fourth fifth
   $ hg rm a
   $ hg ci -m "Modify, add, remove, rename"
 
 Check the status template
 
   $ cat <<EOF >> $HGRCPATH
   > [extensions]
   > color=
   > EOF
 
   $ hg log -T status -r 10
   changeset:   10:0f9759ec227a
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     Modify, add, remove, rename
   files:
   M third
   A b
   A fifth
   R a
   R fourth
   
   $ hg log -T status -C -r 10
   changeset:   10:0f9759ec227a
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     Modify, add, remove, rename
   files:
   M third
   A b
   A fifth
     fourth
   R a
   R fourth
   
   $ hg log -T status -C -r 10 -v
   changeset:   10:0f9759ec227a
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   description:
   Modify, add, remove, rename
   
   files:
   M third
   A b
   A fifth
     fourth
   R a
   R fourth
   
   $ hg log -T status -C -r 10 --debug
   changeset:   10:0f9759ec227a4859c2014a345cd8a859022b7c6c
   tag:         tip
   phase:       secret
   parent:      9:bf9dfba36635106d6a73ccc01e28b762da60e066
   parent:      -1:0000000000000000000000000000000000000000
   manifest:    8:89dd546f2de0a9d6d664f58d86097eb97baba567
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   extra:       branch=default
   description:
   Modify, add, remove, rename
   
   files:
   M third
   A b
   A fifth
     fourth
   R a
   R fourth
   
   $ hg log -T status -C -r 10 --quiet
   10:0f9759ec227a
   $ hg --color=debug log -T status -r 10
   [log.changeset changeset.secret|changeset:   10:0f9759ec227a]
   [log.tag|tag:         tip]
   [log.user|user:        test]
   [log.date|date:        Thu Jan 01 00:00:00 1970 +0000]
   [log.summary|summary:     Modify, add, remove, rename]
   [ui.note log.files|files:]
   [status.modified|M third]
   [status.added|A b]
   [status.added|A fifth]
   [status.removed|R a]
   [status.removed|R fourth]
   
   $ hg --color=debug log -T status -C -r 10
   [log.changeset changeset.secret|changeset:   10:0f9759ec227a]
   [log.tag|tag:         tip]
   [log.user|user:        test]
   [log.date|date:        Thu Jan 01 00:00:00 1970 +0000]
   [log.summary|summary:     Modify, add, remove, rename]
   [ui.note log.files|files:]
   [status.modified|M third]
   [status.added|A b]
   [status.added|A fifth]
   [status.copied|  fourth]
   [status.removed|R a]
   [status.removed|R fourth]
   
   $ hg --color=debug log -T status -C -r 10 -v
   [log.changeset changeset.secret|changeset:   10:0f9759ec227a]
   [log.tag|tag:         tip]
   [log.user|user:        test]
   [log.date|date:        Thu Jan 01 00:00:00 1970 +0000]
   [ui.note log.description|description:]
   [ui.note log.description|Modify, add, remove, rename]
   
   [ui.note log.files|files:]
   [status.modified|M third]
   [status.added|A b]
   [status.added|A fifth]
   [status.copied|  fourth]
   [status.removed|R a]
   [status.removed|R fourth]
   
   $ hg --color=debug log -T status -C -r 10 --debug
   [log.changeset changeset.secret|changeset:   10:0f9759ec227a4859c2014a345cd8a859022b7c6c]
   [log.tag|tag:         tip]
   [log.phase|phase:       secret]
   [log.parent changeset.secret|parent:      9:bf9dfba36635106d6a73ccc01e28b762da60e066]
   [log.parent changeset.public|parent:      -1:0000000000000000000000000000000000000000]
   [ui.debug log.manifest|manifest:    8:89dd546f2de0a9d6d664f58d86097eb97baba567]
   [log.user|user:        test]
   [log.date|date:        Thu Jan 01 00:00:00 1970 +0000]
   [ui.debug log.extra|extra:       branch=default]
   [ui.note log.description|description:]
   [ui.note log.description|Modify, add, remove, rename]
   
   [ui.note log.files|files:]
   [status.modified|M third]
   [status.added|A b]
   [status.added|A fifth]
   [status.copied|  fourth]
   [status.removed|R a]
   [status.removed|R fourth]
   
   $ hg --color=debug log -T status -C -r 10 --quiet
   [log.node|10:0f9759ec227a]
 
 Check the bisect template
 
   $ hg bisect -g 1
   $ hg bisect -b 3 --noupdate
   Testing changeset 2:97054abb4ab8 (2 changesets remaining, ~1 tests)
   $ hg log -T bisect -r 0:4
   changeset:   0:1e4e1b8f71e0
   bisect:      good (implicit)
   user:        User Name <user@hostname>
   date:        Mon Jan 12 13:46:40 1970 +0000
   summary:     line 1
   
   changeset:   1:b608e9d1a3f0
   bisect:      good
   user:        A. N. Other <other@place>
   date:        Tue Jan 13 17:33:20 1970 +0000
   summary:     other 1
   
   changeset:   2:97054abb4ab8
   bisect:      untested
   user:        other@place
   date:        Wed Jan 14 21:20:00 1970 +0000
   summary:     no person
   
   changeset:   3:10e46f2dcbf4
   bisect:      bad
   user:        person
   date:        Fri Jan 16 01:06:40 1970 +0000
   summary:     no user, no domain
   
   changeset:   4:bbe44766e73d
   bisect:      bad (implicit)
   branch:      foo
   user:        person
   date:        Sat Jan 17 04:53:20 1970 +0000
   summary:     new branch
   
   $ hg log --debug -T bisect -r 0:4
   changeset:   0:1e4e1b8f71e05681d422154f5421e385fec3454f
   bisect:      good (implicit)
   phase:       public
   parent:      -1:0000000000000000000000000000000000000000
   parent:      -1:0000000000000000000000000000000000000000
   manifest:    0:a0c8bcbbb45c63b90b70ad007bf38961f64f2af0
   user:        User Name <user@hostname>
   date:        Mon Jan 12 13:46:40 1970 +0000
   files+:      a
   extra:       branch=default
   description:
   line 1
   line 2
   
   
   changeset:   1:b608e9d1a3f0273ccf70fb85fd6866b3482bf965
   bisect:      good
   phase:       public
   parent:      0:1e4e1b8f71e05681d422154f5421e385fec3454f
   parent:      -1:0000000000000000000000000000000000000000
   manifest:    1:4e8d705b1e53e3f9375e0e60dc7b525d8211fe55
   user:        A. N. Other <other@place>
   date:        Tue Jan 13 17:33:20 1970 +0000
   files+:      b
   extra:       branch=default
   description:
   other 1
   other 2
   
   other 3
   
   
   changeset:   2:97054abb4ab824450e9164180baf491ae0078465
   bisect:      untested
   phase:       public
   parent:      1:b608e9d1a3f0273ccf70fb85fd6866b3482bf965
   parent:      -1:0000000000000000000000000000000000000000
   manifest:    2:6e0e82995c35d0d57a52aca8da4e56139e06b4b1
   user:        other@place
   date:        Wed Jan 14 21:20:00 1970 +0000
   files+:      c
   extra:       branch=default
   description:
   no person
   
   
   changeset:   3:10e46f2dcbf4823578cf180f33ecf0b957964c47
   bisect:      bad
   phase:       public
   parent:      2:97054abb4ab824450e9164180baf491ae0078465
   parent:      -1:0000000000000000000000000000000000000000
   manifest:    3:cb5a1327723bada42f117e4c55a303246eaf9ccc
   user:        person
   date:        Fri Jan 16 01:06:40 1970 +0000
   files:       c
   extra:       branch=default
   description:
   no user, no domain
   
   
   changeset:   4:bbe44766e73d5f11ed2177f1838de10c53ef3e74
   bisect:      bad (implicit)
   branch:      foo
   phase:       draft
   parent:      3:10e46f2dcbf4823578cf180f33ecf0b957964c47
   parent:      -1:0000000000000000000000000000000000000000
   manifest:    3:cb5a1327723bada42f117e4c55a303246eaf9ccc
   user:        person
   date:        Sat Jan 17 04:53:20 1970 +0000
   extra:       branch=foo
   description:
   new branch
   
   
   $ hg log -v -T bisect -r 0:4
   changeset:   0:1e4e1b8f71e0
   bisect:      good (implicit)
   user:        User Name <user@hostname>
   date:        Mon Jan 12 13:46:40 1970 +0000
   files:       a
   description:
   line 1
   line 2
   
   
   changeset:   1:b608e9d1a3f0
   bisect:      good
   user:        A. N. Other <other@place>
   date:        Tue Jan 13 17:33:20 1970 +0000
   files:       b
   description:
   other 1
   other 2
   
   other 3
   
   
   changeset:   2:97054abb4ab8
   bisect:      untested
   user:        other@place
   date:        Wed Jan 14 21:20:00 1970 +0000
   files:       c
   description:
   no person
   
   
   changeset:   3:10e46f2dcbf4
   bisect:      bad
   user:        person
   date:        Fri Jan 16 01:06:40 1970 +0000
   files:       c
   description:
   no user, no domain
   
   
   changeset:   4:bbe44766e73d
   bisect:      bad (implicit)
   branch:      foo
   user:        person
   date:        Sat Jan 17 04:53:20 1970 +0000
   description:
   new branch
   
   
   $ hg --color=debug log -T bisect -r 0:4
   [log.changeset changeset.public|changeset:   0:1e4e1b8f71e0]
   [log.bisect bisect.good|bisect:      good (implicit)]
   [log.user|user:        User Name <user@hostname>]
   [log.date|date:        Mon Jan 12 13:46:40 1970 +0000]
   [log.summary|summary:     line 1]
   
   [log.changeset changeset.public|changeset:   1:b608e9d1a3f0]
   [log.bisect bisect.good|bisect:      good]
   [log.user|user:        A. N. Other <other@place>]
   [log.date|date:        Tue Jan 13 17:33:20 1970 +0000]
   [log.summary|summary:     other 1]
   
   [log.changeset changeset.public|changeset:   2:97054abb4ab8]
   [log.bisect bisect.untested|bisect:      untested]
   [log.user|user:        other@place]
   [log.date|date:        Wed Jan 14 21:20:00 1970 +0000]
   [log.summary|summary:     no person]
   
   [log.changeset changeset.public|changeset:   3:10e46f2dcbf4]
   [log.bisect bisect.bad|bisect:      bad]
   [log.user|user:        person]
   [log.date|date:        Fri Jan 16 01:06:40 1970 +0000]
   [log.summary|summary:     no user, no domain]
   
   [log.changeset changeset.draft|changeset:   4:bbe44766e73d]
   [log.bisect bisect.bad|bisect:      bad (implicit)]
   [log.branch|branch:      foo]
   [log.user|user:        person]
   [log.date|date:        Sat Jan 17 04:53:20 1970 +0000]
   [log.summary|summary:     new branch]
   
   $ hg --color=debug log --debug -T bisect -r 0:4
   [log.changeset changeset.public|changeset:   0:1e4e1b8f71e05681d422154f5421e385fec3454f]
   [log.bisect bisect.good|bisect:      good (implicit)]
   [log.phase|phase:       public]
   [log.parent changeset.public|parent:      -1:0000000000000000000000000000000000000000]
   [log.parent changeset.public|parent:      -1:0000000000000000000000000000000000000000]
   [ui.debug log.manifest|manifest:    0:a0c8bcbbb45c63b90b70ad007bf38961f64f2af0]
   [log.user|user:        User Name <user@hostname>]
   [log.date|date:        Mon Jan 12 13:46:40 1970 +0000]
   [ui.debug log.files|files+:      a]
   [ui.debug log.extra|extra:       branch=default]
   [ui.note log.description|description:]
   [ui.note log.description|line 1
   line 2]
   
   
   [log.changeset changeset.public|changeset:   1:b608e9d1a3f0273ccf70fb85fd6866b3482bf965]
   [log.bisect bisect.good|bisect:      good]
   [log.phase|phase:       public]
   [log.parent changeset.public|parent:      0:1e4e1b8f71e05681d422154f5421e385fec3454f]
   [log.parent changeset.public|parent:      -1:0000000000000000000000000000000000000000]
   [ui.debug log.manifest|manifest:    1:4e8d705b1e53e3f9375e0e60dc7b525d8211fe55]
   [log.user|user:        A. N. Other <other@place>]
   [log.date|date:        Tue Jan 13 17:33:20 1970 +0000]
   [ui.debug log.files|files+:      b]
   [ui.debug log.extra|extra:       branch=default]
   [ui.note log.description|description:]
   [ui.note log.description|other 1
   other 2
   
   other 3]
   
   
   [log.changeset changeset.public|changeset:   2:97054abb4ab824450e9164180baf491ae0078465]
   [log.bisect bisect.untested|bisect:      untested]
   [log.phase|phase:       public]
   [log.parent changeset.public|parent:      1:b608e9d1a3f0273ccf70fb85fd6866b3482bf965]
   [log.parent changeset.public|parent:      -1:0000000000000000000000000000000000000000]
   [ui.debug log.manifest|manifest:    2:6e0e82995c35d0d57a52aca8da4e56139e06b4b1]
   [log.user|user:        other@place]
   [log.date|date:        Wed Jan 14 21:20:00 1970 +0000]
   [ui.debug log.files|files+:      c]
   [ui.debug log.extra|extra:       branch=default]
   [ui.note log.description|description:]
   [ui.note log.description|no person]
   
   
   [log.changeset changeset.public|changeset:   3:10e46f2dcbf4823578cf180f33ecf0b957964c47]
   [log.bisect bisect.bad|bisect:      bad]
   [log.phase|phase:       public]
   [log.parent changeset.public|parent:      2:97054abb4ab824450e9164180baf491ae0078465]
   [log.parent changeset.public|parent:      -1:0000000000000000000000000000000000000000]
   [ui.debug log.manifest|manifest:    3:cb5a1327723bada42f117e4c55a303246eaf9ccc]
   [log.user|user:        person]
   [log.date|date:        Fri Jan 16 01:06:40 1970 +0000]
   [ui.debug log.files|files:       c]
   [ui.debug log.extra|extra:       branch=default]
   [ui.note log.description|description:]
   [ui.note log.description|no user, no domain]
   
   
   [log.changeset changeset.draft|changeset:   4:bbe44766e73d5f11ed2177f1838de10c53ef3e74]
   [log.bisect bisect.bad|bisect:      bad (implicit)]
   [log.branch|branch:      foo]
   [log.phase|phase:       draft]
   [log.parent changeset.public|parent:      3:10e46f2dcbf4823578cf180f33ecf0b957964c47]
   [log.parent changeset.public|parent:      -1:0000000000000000000000000000000000000000]
   [ui.debug log.manifest|manifest:    3:cb5a1327723bada42f117e4c55a303246eaf9ccc]
   [log.user|user:        person]
   [log.date|date:        Sat Jan 17 04:53:20 1970 +0000]
   [ui.debug log.extra|extra:       branch=foo]
   [ui.note log.description|description:]
   [ui.note log.description|new branch]
   
   
   $ hg --color=debug log -v -T bisect -r 0:4
   [log.changeset changeset.public|changeset:   0:1e4e1b8f71e0]
   [log.bisect bisect.good|bisect:      good (implicit)]
   [log.user|user:        User Name <user@hostname>]
   [log.date|date:        Mon Jan 12 13:46:40 1970 +0000]
   [ui.note log.files|files:       a]
   [ui.note log.description|description:]
   [ui.note log.description|line 1
   line 2]
   
   
   [log.changeset changeset.public|changeset:   1:b608e9d1a3f0]
   [log.bisect bisect.good|bisect:      good]
   [log.user|user:        A. N. Other <other@place>]
   [log.date|date:        Tue Jan 13 17:33:20 1970 +0000]
   [ui.note log.files|files:       b]
   [ui.note log.description|description:]
   [ui.note log.description|other 1
   other 2
   
   other 3]
   
   
   [log.changeset changeset.public|changeset:   2:97054abb4ab8]
   [log.bisect bisect.untested|bisect:      untested]
   [log.user|user:        other@place]
   [log.date|date:        Wed Jan 14 21:20:00 1970 +0000]
   [ui.note log.files|files:       c]
   [ui.note log.description|description:]
   [ui.note log.description|no person]
   
   
   [log.changeset changeset.public|changeset:   3:10e46f2dcbf4]
   [log.bisect bisect.bad|bisect:      bad]
   [log.user|user:        person]
   [log.date|date:        Fri Jan 16 01:06:40 1970 +0000]
   [ui.note log.files|files:       c]
   [ui.note log.description|description:]
   [ui.note log.description|no user, no domain]
   
   
   [log.changeset changeset.draft|changeset:   4:bbe44766e73d]
   [log.bisect bisect.bad|bisect:      bad (implicit)]
   [log.branch|branch:      foo]
   [log.user|user:        person]
   [log.date|date:        Sat Jan 17 04:53:20 1970 +0000]
   [ui.note log.description|description:]
   [ui.note log.description|new branch]
   
   
   $ hg bisect --reset
 
 Error on syntax:
 
   $ echo 'x = "f' >> t
   $ hg log
   hg: parse error at t:3: unmatched quotes
   [255]
 
   $ hg log -T '{date'
   hg: parse error at 1: unterminated template expansion
   [255]
 
 Behind the scenes, this will throw TypeError
 
   $ hg log -l 3 --template '{date|obfuscate}\n'
   abort: template filter 'obfuscate' is not compatible with keyword 'date'
   [255]
 
 Behind the scenes, this will throw a ValueError
 
   $ hg log -l 3 --template 'line: {desc|shortdate}\n'
   abort: template filter 'shortdate' is not compatible with keyword 'desc'
   [255]
 
 Behind the scenes, this will throw AttributeError
 
   $ hg log -l 3 --template 'line: {date|escape}\n'
   abort: template filter 'escape' is not compatible with keyword 'date'
   [255]
 
   $ hg log -l 3 --template 'line: {extras|localdate}\n'
   hg: parse error: localdate expects a date information
   [255]
 
 Behind the scenes, this will throw ValueError
 
   $ hg tip --template '{author|email|date}\n'
   hg: parse error: date expects a date information
   [255]
 
 Error in nested template:
 
   $ hg log -T '{"date'
   hg: parse error at 2: unterminated string
   [255]
 
   $ hg log -T '{"foo{date|=}"}'
   hg: parse error at 11: syntax error
   [255]
 
 Thrown an error if a template function doesn't exist
 
   $ hg tip --template '{foo()}\n'
   hg: parse error: unknown function 'foo'
   [255]
 
 Pass generator object created by template function to filter
 
   $ hg log -l 1 --template '{if(author, author)|user}\n'
   test
 
 Test diff function:
 
   $ hg diff -c 8
   diff -r 29114dbae42b -r 95c24699272e fourth
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/fourth	Wed Jan 01 10:01:00 2020 +0000
   @@ -0,0 +1,1 @@
   +second
   diff -r 29114dbae42b -r 95c24699272e second
   --- a/second	Mon Jan 12 13:46:40 1970 +0000
   +++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
   @@ -1,1 +0,0 @@
   -second
   diff -r 29114dbae42b -r 95c24699272e third
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/third	Wed Jan 01 10:01:00 2020 +0000
   @@ -0,0 +1,1 @@
   +third
 
   $ hg log -r 8 -T "{diff()}"
   diff -r 29114dbae42b -r 95c24699272e fourth
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/fourth	Wed Jan 01 10:01:00 2020 +0000
   @@ -0,0 +1,1 @@
   +second
   diff -r 29114dbae42b -r 95c24699272e second
   --- a/second	Mon Jan 12 13:46:40 1970 +0000
   +++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
   @@ -1,1 +0,0 @@
   -second
   diff -r 29114dbae42b -r 95c24699272e third
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/third	Wed Jan 01 10:01:00 2020 +0000
   @@ -0,0 +1,1 @@
   +third
 
   $ hg log -r 8 -T "{diff('glob:f*')}"
   diff -r 29114dbae42b -r 95c24699272e fourth
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/fourth	Wed Jan 01 10:01:00 2020 +0000
   @@ -0,0 +1,1 @@
   +second
 
   $ hg log -r 8 -T "{diff('', 'glob:f*')}"
   diff -r 29114dbae42b -r 95c24699272e second
   --- a/second	Mon Jan 12 13:46:40 1970 +0000
   +++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
   @@ -1,1 +0,0 @@
   -second
   diff -r 29114dbae42b -r 95c24699272e third
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/third	Wed Jan 01 10:01:00 2020 +0000
   @@ -0,0 +1,1 @@
   +third
 
   $ hg log -r 8 -T "{diff('FOURTH'|lower)}"
   diff -r 29114dbae42b -r 95c24699272e fourth
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/fourth	Wed Jan 01 10:01:00 2020 +0000
   @@ -0,0 +1,1 @@
   +second
 
   $ cd ..
 
 
 latesttag:
 
   $ hg init latesttag
   $ cd latesttag
 
   $ echo a > file
   $ hg ci -Am a -d '0 0'
   adding file
 
   $ echo b >> file
   $ hg ci -m b -d '1 0'
 
   $ echo c >> head1
   $ hg ci -Am h1c -d '2 0'
   adding head1
 
   $ hg update -q 1
   $ echo d >> head2
   $ hg ci -Am h2d -d '3 0'
   adding head2
   created new head
 
   $ echo e >> head2
   $ hg ci -m h2e -d '4 0'
 
   $ hg merge -q
   $ hg ci -m merge -d '5 -3600'
 
 No tag set:
 
   $ hg log --template '{rev}: {latesttag}+{latesttagdistance}\n'
   5: null+5
   4: null+4
   3: null+3
   2: null+3
   1: null+2
   0: null+1
 
 One common tag: longest path wins:
 
   $ hg tag -r 1 -m t1 -d '6 0' t1
   $ hg log --template '{rev}: {latesttag}+{latesttagdistance}\n'
   6: t1+4
   5: t1+3
   4: t1+2
   3: t1+1
   2: t1+1
   1: t1+0
   0: null+1
 
 One ancestor tag: more recent wins:
 
   $ hg tag -r 2 -m t2 -d '7 0' t2
   $ hg log --template '{rev}: {latesttag}+{latesttagdistance}\n'
   7: t2+3
   6: t2+2
   5: t2+1
   4: t1+2
   3: t1+1
   2: t2+0
   1: t1+0
   0: null+1
 
 Two branch tags: more recent wins:
 
   $ hg tag -r 3 -m t3 -d '8 0' t3
   $ hg log --template '{rev}: {latesttag}+{latesttagdistance}\n'
   8: t3+5
   7: t3+4
   6: t3+3
   5: t3+2
   4: t3+1
   3: t3+0
   2: t2+0
   1: t1+0
   0: null+1
 
 Merged tag overrides:
 
   $ hg tag -r 5 -m t5 -d '9 0' t5
   $ hg tag -r 3 -m at3 -d '10 0' at3
   $ hg log --template '{rev}: {latesttag}+{latesttagdistance}\n'
   10: t5+5
   9: t5+4
   8: t5+3
   7: t5+2
   6: t5+1
   5: t5+0
   4: at3:t3+1
   3: at3:t3+0
   2: t2+0
   1: t1+0
   0: null+1
 
   $ hg log --template "{rev}: {latesttag % '{tag}+{distance},{changes} '}\n"
   10: t5+5,5 
   9: t5+4,4 
   8: t5+3,3 
   7: t5+2,2 
   6: t5+1,1 
   5: t5+0,0 
   4: at3+1,1 t3+1,1 
   3: at3+0,0 t3+0,0 
   2: t2+0,0 
   1: t1+0,0 
   0: null+1,1 
 
   $ hg log --template "{rev}: {latesttag('re:^t[13]$') % '{tag}, C: {changes}, D: {distance}'}\n"
   10: t3, C: 8, D: 7
   9: t3, C: 7, D: 6
   8: t3, C: 6, D: 5
   7: t3, C: 5, D: 4
   6: t3, C: 4, D: 3
   5: t3, C: 3, D: 2
   4: t3, C: 1, D: 1
   3: t3, C: 0, D: 0
   2: t1, C: 1, D: 1
   1: t1, C: 0, D: 0
   0: null, C: 1, D: 1
 
   $ cd ..
 
 
 Style path expansion: issue1948 - ui.style option doesn't work on OSX
 if it is a relative path
 
   $ mkdir -p home/styles
 
   $ cat > home/styles/teststyle <<EOF
   > changeset = 'test {rev}:{node|short}\n'
   > EOF
 
   $ HOME=`pwd`/home; export HOME
 
   $ cat > latesttag/.hg/hgrc <<EOF
   > [ui]
   > style = ~/styles/teststyle
   > EOF
 
   $ hg -R latesttag tip
   test 10:9b4a630e5f5f
 
 Test recursive showlist template (issue1989):
 
   $ cat > style1989 <<EOF
   > changeset = '{file_mods}{manifest}{extras}'
   > file_mod  = 'M|{author|person}\n'
   > manifest = '{rev},{author}\n'
   > extra = '{key}: {author}\n'
   > EOF
 
   $ hg -R latesttag log -r tip --style=style1989
   M|test
   10,test
   branch: test
 
 Test new-style inline templating:
 
   $ hg log -R latesttag -r tip --template 'modified files: {file_mods % " {file}\n"}\n'
   modified files:  .hgtags
   
 
   $ hg log -R latesttag -r tip -T '{rev % "a"}\n'
   hg: parse error: keyword 'rev' is not iterable
   [255]
   $ hg log -R latesttag -r tip -T '{get(extras, "unknown") % "a"}\n'
   hg: parse error: None is not iterable
   [255]
 
 Test the sub function of templating for expansion:
 
   $ hg log -R latesttag -r 10 --template '{sub("[0-9]", "x", "{rev}")}\n'
   xx
 
   $ hg log -R latesttag -r 10 -T '{sub("[", "x", rev)}\n'
   hg: parse error: sub got an invalid pattern: [
   [255]
   $ hg log -R latesttag -r 10 -T '{sub("[0-9]", r"\1", rev)}\n'
   hg: parse error: sub got an invalid replacement: \1
   [255]
 
 Test the strip function with chars specified:
 
   $ hg log -R latesttag --template '{desc}\n'
   at3
   t5
   t3
   t2
   t1
   merge
   h2e
   h2d
   h1c
   b
   a
 
   $ hg log -R latesttag --template '{strip(desc, "te")}\n'
   at3
   5
   3
   2
   1
   merg
   h2
   h2d
   h1c
   b
   a
 
 Test date format:
 
   $ hg log -R latesttag --template 'date: {date(date, "%y %m %d %S %z")}\n'
   date: 70 01 01 10 +0000
   date: 70 01 01 09 +0000
   date: 70 01 01 08 +0000
   date: 70 01 01 07 +0000
   date: 70 01 01 06 +0000
   date: 70 01 01 05 +0100
   date: 70 01 01 04 +0000
   date: 70 01 01 03 +0000
   date: 70 01 01 02 +0000
   date: 70 01 01 01 +0000
   date: 70 01 01 00 +0000
 
 Test invalid date:
 
   $ hg log -R latesttag -T '{date(rev)}\n'
   hg: parse error: date expects a date information
   [255]
 
 Test integer literal:
 
   $ hg debugtemplate -v '{(0)}\n'
   (template
     (group
       ('integer', '0'))
     ('string', '\n'))
   0
   $ hg debugtemplate -v '{(123)}\n'
   (template
     (group
       ('integer', '123'))
     ('string', '\n'))
   123
   $ hg debugtemplate -v '{(-4)}\n'
   (template
     (group
       ('integer', '-4'))
     ('string', '\n'))
   -4
   $ hg debugtemplate '{(-)}\n'
   hg: parse error at 2: integer literal without digits
   [255]
   $ hg debugtemplate '{(-a)}\n'
   hg: parse error at 2: integer literal without digits
   [255]
 
 top-level integer literal is interpreted as symbol (i.e. variable name):
 
   $ hg debugtemplate -D 1=one -v '{1}\n'
   (template
     ('integer', '1')
     ('string', '\n'))
   one
   $ hg debugtemplate -D 1=one -v '{if("t", "{1}")}\n'
   (template
     (func
       ('symbol', 'if')
       (list
         ('string', 't')
         (template
           ('integer', '1'))))
     ('string', '\n'))
   one
   $ hg debugtemplate -D 1=one -v '{1|stringify}\n'
   (template
     (|
       ('integer', '1')
       ('symbol', 'stringify'))
     ('string', '\n'))
   one
 
 unless explicit symbol is expected:
 
   $ hg log -Ra -r0 -T '{desc|1}\n'
   hg: parse error: expected a symbol, got 'integer'
   [255]
   $ hg log -Ra -r0 -T '{1()}\n'
   hg: parse error: expected a symbol, got 'integer'
   [255]
 
 Test string literal:
 
   $ hg debugtemplate -Ra -r0 -v '{"string with no template fragment"}\n'
   (template
     ('string', 'string with no template fragment')
     ('string', '\n'))
   string with no template fragment
   $ hg debugtemplate -Ra -r0 -v '{"template: {rev}"}\n'
   (template
     (template
       ('string', 'template: ')
       ('symbol', 'rev'))
     ('string', '\n'))
   template: 0
   $ hg debugtemplate -Ra -r0 -v '{r"rawstring: {rev}"}\n'
   (template
     ('string', 'rawstring: {rev}')
     ('string', '\n'))
   rawstring: {rev}
   $ hg debugtemplate -Ra -r0 -v '{files % r"rawstring: {file}"}\n'
   (template
     (%
       ('symbol', 'files')
       ('string', 'rawstring: {file}'))
     ('string', '\n'))
   rawstring: {file}
 
 Test string escaping:
 
   $ hg log -R latesttag -r 0 --template '>\n<>\\n<{if(rev, "[>\n<>\\n<]")}>\n<>\\n<\n'
   >
   <>\n<[>
   <>\n<]>
   <>\n<
 
   $ hg log -R latesttag -r 0 \
   > --config ui.logtemplate='>\n<>\\n<{if(rev, "[>\n<>\\n<]")}>\n<>\\n<\n'
   >
   <>\n<[>
   <>\n<]>
   <>\n<
 
   $ hg log -R latesttag -r 0 -T esc \
   > --config templates.esc='>\n<>\\n<{if(rev, "[>\n<>\\n<]")}>\n<>\\n<\n'
   >
   <>\n<[>
   <>\n<]>
   <>\n<
 
   $ cat <<'EOF' > esctmpl
   > changeset = '>\n<>\\n<{if(rev, "[>\n<>\\n<]")}>\n<>\\n<\n'
   > EOF
   $ hg log -R latesttag -r 0 --style ./esctmpl
   >
   <>\n<[>
   <>\n<]>
   <>\n<
 
 Test string escaping of quotes:
 
   $ hg log -Ra -r0 -T '{"\""}\n'
   "
   $ hg log -Ra -r0 -T '{"\\\""}\n'
   \"
   $ hg log -Ra -r0 -T '{r"\""}\n'
   \"
   $ hg log -Ra -r0 -T '{r"\\\""}\n'
   \\\"
 
 
   $ hg log -Ra -r0 -T '{"\""}\n'
   "
   $ hg log -Ra -r0 -T '{"\\\""}\n'
   \"
   $ hg log -Ra -r0 -T '{r"\""}\n'
   \"
   $ hg log -Ra -r0 -T '{r"\\\""}\n'
   \\\"
 
 Test exception in quoted template. single backslash before quotation mark is
 stripped before parsing:
 
   $ cat <<'EOF' > escquotetmpl
   > changeset = "\" \\" \\\" \\\\" {files % \"{file}\"}\n"
   > EOF
   $ cd latesttag
   $ hg log -r 2 --style ../escquotetmpl
   " \" \" \\" head1
 
   $ hg log -r 2 -T esc --config templates.esc='"{\"valid\"}\n"'
   valid
   $ hg log -r 2 -T esc --config templates.esc="'"'{\'"'"'valid\'"'"'}\n'"'"
   valid
 
 Test compatibility with 2.9.2-3.4 of escaped quoted strings in nested
 _evalifliteral() templates (issue4733):
 
   $ hg log -r 2 -T '{if(rev, "\"{rev}")}\n'
   "2
   $ hg log -r 2 -T '{if(rev, "{if(rev, \"\\\"{rev}\")}")}\n'
   "2
   $ hg log -r 2 -T '{if(rev, "{if(rev, \"{if(rev, \\\"\\\\\\\"{rev}\\\")}\")}")}\n'
   "2
 
   $ hg log -r 2 -T '{if(rev, "\\\"")}\n'
   \"
   $ hg log -r 2 -T '{if(rev, "{if(rev, \"\\\\\\\"\")}")}\n'
   \"
   $ hg log -r 2 -T '{if(rev, "{if(rev, \"{if(rev, \\\"\\\\\\\\\\\\\\\"\\\")}\")}")}\n'
   \"
 
   $ hg log -r 2 -T '{if(rev, r"\\\"")}\n'
   \\\"
   $ hg log -r 2 -T '{if(rev, "{if(rev, r\"\\\\\\\"\")}")}\n'
   \\\"
   $ hg log -r 2 -T '{if(rev, "{if(rev, \"{if(rev, r\\\"\\\\\\\\\\\\\\\"\\\")}\")}")}\n'
   \\\"
 
 escaped single quotes and errors:
 
   $ hg log -r 2 -T "{if(rev, '{if(rev, \'foo\')}')}"'\n'
   foo
   $ hg log -r 2 -T "{if(rev, '{if(rev, r\'foo\')}')}"'\n'
   foo
   $ hg log -r 2 -T '{if(rev, "{if(rev, \")}")}\n'
   hg: parse error at 21: unterminated string
   [255]
   $ hg log -r 2 -T '{if(rev, \"\\"")}\n'
   hg: parse error: trailing \ in string
   [255]
   $ hg log -r 2 -T '{if(rev, r\"\\"")}\n'
   hg: parse error: trailing \ in string
   [255]
 
   $ cd ..
 
 Test leading backslashes:
 
   $ cd latesttag
   $ hg log -r 2 -T '\{rev} {files % "\{file}"}\n'
   {rev} {file}
   $ hg log -r 2 -T '\\{rev} {files % "\\{file}"}\n'
   \2 \head1
   $ hg log -r 2 -T '\\\{rev} {files % "\\\{file}"}\n'
   \{rev} \{file}
   $ cd ..
 
 Test leading backslashes in "if" expression (issue4714):
 
   $ cd latesttag
   $ hg log -r 2 -T '{if("1", "\{rev}")} {if("1", r"\{rev}")}\n'
   {rev} \{rev}
   $ hg log -r 2 -T '{if("1", "\\{rev}")} {if("1", r"\\{rev}")}\n'
   \2 \\{rev}
   $ hg log -r 2 -T '{if("1", "\\\{rev}")} {if("1", r"\\\{rev}")}\n'
   \{rev} \\\{rev}
   $ cd ..
 
 "string-escape"-ed "\x5c\x786e" becomes r"\x6e" (once) or r"n" (twice)
 
   $ hg log -R a -r 0 --template '{if("1", "\x5c\x786e", "NG")}\n'
   \x6e
   $ hg log -R a -r 0 --template '{if("1", r"\x5c\x786e", "NG")}\n'
   \x5c\x786e
   $ hg log -R a -r 0 --template '{if("", "NG", "\x5c\x786e")}\n'
   \x6e
   $ hg log -R a -r 0 --template '{if("", "NG", r"\x5c\x786e")}\n'
   \x5c\x786e
 
   $ hg log -R a -r 2 --template '{ifeq("no perso\x6e", desc, "\x5c\x786e", "NG")}\n'
   \x6e
   $ hg log -R a -r 2 --template '{ifeq(r"no perso\x6e", desc, "NG", r"\x5c\x786e")}\n'
   \x5c\x786e
   $ hg log -R a -r 2 --template '{ifeq(desc, "no perso\x6e", "\x5c\x786e", "NG")}\n'
   \x6e
   $ hg log -R a -r 2 --template '{ifeq(desc, r"no perso\x6e", "NG", r"\x5c\x786e")}\n'
   \x5c\x786e
 
   $ hg log -R a -r 8 --template '{join(files, "\n")}\n'
   fourth
   second
   third
   $ hg log -R a -r 8 --template '{join(files, r"\n")}\n'
   fourth\nsecond\nthird
 
   $ hg log -R a -r 2 --template '{rstdoc("1st\n\n2nd", "htm\x6c")}'
   <p>
   1st
   </p>
   <p>
   2nd
   </p>
   $ hg log -R a -r 2 --template '{rstdoc(r"1st\n\n2nd", "html")}'
   <p>
   1st\n\n2nd
   </p>
   $ hg log -R a -r 2 --template '{rstdoc("1st\n\n2nd", r"htm\x6c")}'
   1st
   
   2nd
 
   $ hg log -R a -r 2 --template '{strip(desc, "\x6e")}\n'
   o perso
   $ hg log -R a -r 2 --template '{strip(desc, r"\x6e")}\n'
   no person
   $ hg log -R a -r 2 --template '{strip("no perso\x6e", "\x6e")}\n'
   o perso
   $ hg log -R a -r 2 --template '{strip(r"no perso\x6e", r"\x6e")}\n'
   no perso
 
   $ hg log -R a -r 2 --template '{sub("\\x6e", "\x2d", desc)}\n'
   -o perso-
   $ hg log -R a -r 2 --template '{sub(r"\\x6e", "-", desc)}\n'
   no person
   $ hg log -R a -r 2 --template '{sub("n", r"\x2d", desc)}\n'
   \x2do perso\x2d
   $ hg log -R a -r 2 --template '{sub("n", "\x2d", "no perso\x6e")}\n'
   -o perso-
   $ hg log -R a -r 2 --template '{sub("n", r"\x2d", r"no perso\x6e")}\n'
   \x2do perso\x6e
 
   $ hg log -R a -r 8 --template '{files % "{file}\n"}'
   fourth
   second
   third
 
 Test string escaping in nested expression:
 
   $ hg log -R a -r 8 --template '{ifeq(r"\x6e", if("1", "\x5c\x786e"), join(files, "\x5c\x786e"))}\n'
   fourth\x6esecond\x6ethird
   $ hg log -R a -r 8 --template '{ifeq(if("1", r"\x6e"), "\x5c\x786e", join(files, "\x5c\x786e"))}\n'
   fourth\x6esecond\x6ethird
 
   $ hg log -R a -r 8 --template '{join(files, ifeq(branch, "default", "\x5c\x786e"))}\n'
   fourth\x6esecond\x6ethird
   $ hg log -R a -r 8 --template '{join(files, ifeq(branch, "default", r"\x5c\x786e"))}\n'
   fourth\x5c\x786esecond\x5c\x786ethird
 
   $ hg log -R a -r 3:4 --template '{rev}:{sub(if("1", "\x6e"), ifeq(branch, "foo", r"\x5c\x786e", "\x5c\x786e"), desc)}\n'
   3:\x6eo user, \x6eo domai\x6e
   4:\x5c\x786eew bra\x5c\x786ech
 
 Test quotes in nested expression are evaluated just like a $(command)
 substitution in POSIX shells:
 
   $ hg log -R a -r 8 -T '{"{"{rev}:{node|short}"}"}\n'
   8:95c24699272e
   $ hg log -R a -r 8 -T '{"{"\{{rev}} \"{node|short}\""}"}\n'
   {8} "95c24699272e"
 
 Test recursive evaluation:
 
   $ hg init r
   $ cd r
   $ echo a > a
   $ hg ci -Am '{rev}'
   adding a
   $ hg log -r 0 --template '{if(rev, desc)}\n'
   {rev}
   $ hg log -r 0 --template '{if(rev, "{author} {rev}")}\n'
   test 0
 
   $ hg branch -q 'text.{rev}'
   $ echo aa >> aa
   $ hg ci -u '{node|short}' -m 'desc to be wrapped desc to be wrapped'
 
   $ hg log -l1 --template '{fill(desc, "20", author, branch)}'
   {node|short}desc to
   text.{rev}be wrapped
   text.{rev}desc to be
   text.{rev}wrapped (no-eol)
   $ hg log -l1 --template '{fill(desc, "20", "{node|short}:", "text.{rev}:")}'
   bcc7ff960b8e:desc to
   text.1:be wrapped
   text.1:desc to be
   text.1:wrapped (no-eol)
   $ hg log -l1 -T '{fill(desc, date, "", "")}\n'
   hg: parse error: fill expects an integer width
   [255]
 
   $ hg log -l 1 --template '{sub(r"[0-9]", "-", author)}'
   {node|short} (no-eol)
   $ hg log -l 1 --template '{sub(r"[0-9]", "-", "{node|short}")}'
   bcc-ff---b-e (no-eol)
 
   $ cat >> .hg/hgrc <<EOF
   > [extensions]
   > color=
   > [color]
   > mode=ansi
   > text.{rev} = red
   > text.1 = green
   > EOF
   $ hg log --color=always -l 1 --template '{label(branch, "text\n")}'
   \x1b[0;31mtext\x1b[0m (esc)
   $ hg log --color=always -l 1 --template '{label("text.{rev}", "text\n")}'
   \x1b[0;32mtext\x1b[0m (esc)
 
 color effect can be specified without quoting:
 
   $ hg log --color=always -l 1 --template '{label(red, "text\n")}'
   \x1b[0;31mtext\x1b[0m (esc)
 
 label should be no-op if color is disabled:
 
   $ hg log --color=never -l 1 --template '{label(red, "text\n")}'
   text
   $ hg log --config extensions.color=! -l 1 --template '{label(red, "text\n")}'
   text
 
 Test branches inside if statement:
 
   $ hg log -r 0 --template '{if(branches, "yes", "no")}\n'
   no
 
 Test get function:
 
   $ hg log -r 0 --template '{get(extras, "branch")}\n'
   default
   $ hg log -r 0 --template '{get(extras, "br{"anch"}")}\n'
   default
   $ hg log -r 0 --template '{get(files, "should_fail")}\n'
   hg: parse error: get() expects a dict as first argument
   [255]
 
 Test localdate(date, tz) function:
 
   $ TZ=JST-09 hg log -r0 -T '{date|localdate|isodate}\n'
   1970-01-01 09:00 +0900
   $ TZ=JST-09 hg log -r0 -T '{localdate(date, "UTC")|isodate}\n'
   1970-01-01 00:00 +0000
   $ TZ=JST-09 hg log -r0 -T '{localdate(date, "+0200")|isodate}\n'
   1970-01-01 02:00 +0200
   $ TZ=JST-09 hg log -r0 -T '{localdate(date, "0")|isodate}\n'
   1970-01-01 00:00 +0000
   $ TZ=JST-09 hg log -r0 -T '{localdate(date, 0)|isodate}\n'
   1970-01-01 00:00 +0000
   $ hg log -r0 -T '{localdate(date, "invalid")|isodate}\n'
   hg: parse error: localdate expects a timezone
   [255]
   $ hg log -r0 -T '{localdate(date, date)|isodate}\n'
   hg: parse error: localdate expects a timezone
   [255]
 
 Test shortest(node) function:
 
   $ echo b > b
   $ hg ci -qAm b
   $ hg log --template '{shortest(node)}\n'
   e777
   bcc7
   f776
   $ hg log --template '{shortest(node, 10)}\n'
   e777603221
   bcc7ff960b
   f7769ec2ab
   $ hg log --template '{node|shortest}\n' -l1
   e777
 
   $ hg log -r 0 -T '{shortest(node, "1{"0"}")}\n'
   f7769ec2ab
   $ hg log -r 0 -T '{shortest(node, "not an int")}\n'
   hg: parse error: shortest() expects an integer minlength
   [255]
 
 Test pad function
 
   $ hg log --template '{pad(rev, 20)} {author|user}\n'
   2                    test
   1                    {node|short}
   0                    test
 
   $ hg log --template '{pad(rev, 20, " ", True)} {author|user}\n'
                      2 test
                      1 {node|short}
                      0 test
 
   $ hg log --template '{pad(rev, 20, "-", False)} {author|user}\n'
   2------------------- test
   1------------------- {node|short}
   0------------------- test
 
 Test template string in pad function
 
   $ hg log -r 0 -T '{pad("\{{rev}}", 10)} {author|user}\n'
   {0}        test
 
   $ hg log -r 0 -T '{pad(r"\{rev}", 10)} {author|user}\n'
   \{rev}     test
 
 Test width argument passed to pad function
 
   $ hg log -r 0 -T '{pad(rev, "1{"0"}")} {author|user}\n'
   0          test
   $ hg log -r 0 -T '{pad(rev, "not an int")}\n'
   hg: parse error: pad() expects an integer width
   [255]
 
 Test ifcontains function
 
   $ hg log --template '{rev} {ifcontains(rev, "2 two 0", "is in the string", "is not")}\n'
   2 is in the string
   1 is not
   0 is in the string
 
   $ hg log -T '{rev} {ifcontains(rev, "2 two{" 0"}", "is in the string", "is not")}\n'
   2 is in the string
   1 is not
   0 is in the string
 
   $ hg log --template '{rev} {ifcontains("a", file_adds, "added a", "did not add a")}\n'
   2 did not add a
   1 did not add a
   0 added a
 
   $ hg log --debug -T '{rev}{ifcontains(1, parents, " is parent of 1")}\n'
   2 is parent of 1
   1
   0
 
 Test revset function
 
   $ hg log --template '{rev} {ifcontains(rev, revset("."), "current rev", "not current rev")}\n'
   2 current rev
   1 not current rev
   0 not current rev
 
   $ hg log --template '{rev} {ifcontains(rev, revset(". + .^"), "match rev", "not match rev")}\n'
   2 match rev
   1 match rev
   0 not match rev
 
   $ hg log --template '{rev} Parents: {revset("parents(%s)", rev)}\n'
   2 Parents: 1
   1 Parents: 0
   0 Parents: 
 
   $ cat >> .hg/hgrc <<EOF
   > [revsetalias]
   > myparents(\$1) = parents(\$1)
   > EOF
   $ hg log --template '{rev} Parents: {revset("myparents(%s)", rev)}\n'
   2 Parents: 1
   1 Parents: 0
   0 Parents: 
 
   $ hg log --template 'Rev: {rev}\n{revset("::%s", rev) % "Ancestor: {revision}\n"}\n'
   Rev: 2
   Ancestor: 0
   Ancestor: 1
   Ancestor: 2
   
   Rev: 1
   Ancestor: 0
   Ancestor: 1
   
   Rev: 0
   Ancestor: 0
   
   $ hg log --template '{revset("TIP"|lower)}\n' -l1
   2
 
   $ hg log -T '{revset("%s", "t{"ip"}")}\n' -l1
   2
 
  a list template is evaluated for each item of revset/parents
 
   $ hg log -T '{rev} p: {revset("p1(%s)", rev) % "{rev}:{node|short}"}\n'
   2 p: 1:bcc7ff960b8e
   1 p: 0:f7769ec2ab97
   0 p: 
 
   $ hg log --debug -T '{rev} p:{parents % " {rev}:{node|short}"}\n'
   2 p: 1:bcc7ff960b8e -1:000000000000
   1 p: 0:f7769ec2ab97 -1:000000000000
   0 p: -1:000000000000 -1:000000000000
 
  therefore, 'revcache' should be recreated for each rev
 
   $ hg log -T '{rev} {file_adds}\np {revset("p1(%s)", rev) % "{file_adds}"}\n'
   2 aa b
   p 
   1 
   p a
   0 a
   p 
 
   $ hg log --debug -T '{rev} {file_adds}\np {parents % "{file_adds}"}\n'
   2 aa b
   p 
   1 
   p a
   0 a
   p 
 
 a revset item must be evaluated as an integer revision, not an offset from tip
 
   $ hg log -l 1 -T '{revset("null") % "{rev}:{node|short}"}\n'
   -1:000000000000
   $ hg log -l 1 -T '{revset("%s", "null") % "{rev}:{node|short}"}\n'
   -1:000000000000
 
 Test active bookmark templating
 
   $ hg book foo
   $ hg book bar
   $ hg log --template "{rev} {bookmarks % '{bookmark}{ifeq(bookmark, active, \"*\")} '}\n"
   2 bar* foo 
   1 
   0 
   $ hg log --template "{rev} {activebookmark}\n"
   2 bar
   1 
   0 
   $ hg bookmarks --inactive bar
   $ hg log --template "{rev} {activebookmark}\n"
   2 
   1 
   0 
   $ hg book -r1 baz
   $ hg log --template "{rev} {join(bookmarks, ' ')}\n"
   2 bar foo
   1 baz
   0 
   $ hg log --template "{rev} {ifcontains('foo', bookmarks, 't', 'f')}\n"
   2 t
   1 f
   0 f
 
 Test namespaces dict
 
   $ hg log -T '{rev}{namespaces % " {namespace}={join(names, ",")}"}\n'
   2 bookmarks=bar,foo tags=tip branches=text.{rev}
   1 bookmarks=baz tags= branches=text.{rev}
   0 bookmarks= tags= branches=default
   $ hg log -r2 -T '{namespaces % "{namespace}: {names}\n"}'
   bookmarks: bar foo
   tags: tip
   branches: text.{rev}
   $ hg log -r2 -T '{namespaces % "{namespace}:\n{names % " {name}\n"}"}'
   bookmarks:
    bar
    foo
   tags:
    tip
   branches:
    text.{rev}
   $ hg log -r2 -T '{get(namespaces, "bookmarks") % "{name}\n"}'
   bar
   foo
 
 Test stringify on sub expressions
 
   $ cd ..
   $ hg log -R a -r 8 --template '{join(files, if("1", if("1", ", ")))}\n'
   fourth, second, third
   $ hg log -R a -r 8 --template '{strip(if("1", if("1", "-abc-")), if("1", if("1", "-")))}\n'
   abc
 
 Test splitlines
 
   $ hg log -Gv -R a --template "{splitlines(desc) % 'foo {line}\n'}"
   @  foo Modify, add, remove, rename
   |
   o  foo future
   |
   o  foo third
   |
   o  foo second
   
   o    foo merge
   |\
   | o  foo new head
   | |
   o |  foo new branch
   |/
   o  foo no user, no domain
   |
   o  foo no person
   |
   o  foo other 1
   |  foo other 2
   |  foo
   |  foo other 3
   o  foo line 1
      foo line 2
 
 Test startswith
   $ hg log -Gv -R a --template "{startswith(desc)}"
   hg: parse error: startswith expects two arguments
   [255]
 
   $ hg log -Gv -R a --template "{startswith('line', desc)}"
   @
   |
   o
   |
   o
   |
   o
   
   o
   |\
   | o
   | |
   o |
   |/
   o
   |
   o
   |
   o
   |
   o  line 1
      line 2
 
 Test bad template with better error message
 
   $ hg log -Gv -R a --template '{desc|user()}'
   hg: parse error: expected a symbol, got 'func'
   [255]
 
 Test word function (including index out of bounds graceful failure)
 
   $ hg log -Gv -R a --template "{word('1', desc)}"
   @  add,
   |
   o
   |
   o
   |
   o
   
   o
   |\
   | o  head
   | |
   o |  branch
   |/
   o  user,
   |
   o  person
   |
   o  1
   |
   o  1
   
 
 Test word third parameter used as splitter
 
   $ hg log -Gv -R a --template "{word('0', desc, 'o')}"
   @  M
   |
   o  future
   |
   o  third
   |
   o  sec
   
   o    merge
   |\
   | o  new head
   | |
   o |  new branch
   |/
   o  n
   |
   o  n
   |
   o
   |
   o  line 1
      line 2
 
 Test word error messages for not enough and too many arguments
 
   $ hg log -Gv -R a --template "{word('0')}"
   hg: parse error: word expects two or three arguments, got 1
   [255]
 
   $ hg log -Gv -R a --template "{word('0', desc, 'o', 'h', 'b', 'o', 'y')}"
   hg: parse error: word expects two or three arguments, got 7
   [255]
 
 Test word for integer literal
 
   $ hg log -R a --template "{word(2, desc)}\n" -r0
   line
 
 Test word for invalid numbers
 
   $ hg log -Gv -R a --template "{word('a', desc)}"
   hg: parse error: word expects an integer index
   [255]
 
 Test word for out of range
 
   $ hg log -R a --template "{word(10000, desc)}"
   $ hg log -R a --template "{word(-10000, desc)}"
 
 Test indent and not adding to empty lines
 
   $ hg log -T "-----\n{indent(desc, '>> ', ' > ')}\n" -r 0:1 -R a
   -----
    > line 1
   >> line 2
   -----
    > other 1
   >> other 2
   
   >> other 3
 
 Test with non-strings like dates
 
   $ hg log -T "{indent(date, '   ')}\n" -r 2:3 -R a
      1200000.00
      1300000.00
 
 Test broken string escapes:
 
   $ hg log -T "bogus\\" -R a
   hg: parse error: trailing \ in string
   [255]
   $ hg log -T "\\xy" -R a
   hg: parse error: invalid \x escape
   [255]
 
 json filter should escape HTML tags so that the output can be embedded in hgweb:
 
   $ hg log -T "{'<[e-mail]>'|json}\n" -R a -l1
   "\[e-mail]\u003e"
 
 Set up repository for non-ascii encoding tests:
 
   $ hg init nonascii
   $ cd nonascii
   $ python <<EOF
   > open('latin1', 'w').write('\xe9')
   > open('utf-8', 'w').write('\xc3\xa9')
   > EOF
   $ HGENCODING=utf-8 hg branch -q `cat utf-8`
   $ HGENCODING=utf-8 hg ci -qAm "non-ascii branch: `cat utf-8`" utf-8
 
 json filter should try round-trip conversion to utf-8:
 
   $ HGENCODING=ascii hg log -T "{branch|json}\n" -r0
   "\u00e9"
   $ HGENCODING=ascii hg log -T "{desc|json}\n" -r0
   "non-ascii branch: \u00e9"
 
 json filter takes input as utf-8b:
 
   $ HGENCODING=ascii hg log -T "{'`cat utf-8`'|json}\n" -l1
   "\u00e9"
   $ HGENCODING=ascii hg log -T "{'`cat latin1`'|json}\n" -l1
   "\udce9"
 
 utf8 filter:
 
   $ HGENCODING=ascii hg log -T "round-trip: {branch|utf8|hex}\n" -r0
   round-trip: c3a9
   $ HGENCODING=latin1 hg log -T "decoded: {'`cat latin1`'|utf8|hex}\n" -l1
   decoded: c3a9
   $ HGENCODING=ascii hg log -T "replaced: {'`cat latin1`'|utf8|hex}\n" -l1
   abort: decoding near * (glob)
   [255]
   $ hg log -T "invalid type: {rev|utf8}\n" -r0
   abort: template filter 'utf8' is not compatible with keyword 'rev'
   [255]
 
   $ cd ..
+
+Test that template function in extension is registered as expected
+
+  $ cd a
+
+  $ cat <<EOF > $TESTTMP/customfunc.py
+  > from mercurial import registrar
+  > 
+  > templatefunc = registrar.templatefunc()
+  > 
+  > @templatefunc('custom()')
+  > def custom(context, mapping, args):
+  >     return 'custom'
+  > EOF
+  $ cat <<EOF > .hg/hgrc
+  > [extensions]
+  > customfunc = $TESTTMP/customfunc.py
+  > EOF
+
+  $ hg log -r . -T "{custom()}\n" --config customfunc.enabled=true
+  custom
+
+  $ cd ..