templater: make templatepath() not return directory paths

The previous patch added a test showing an unusal error message. This
make it more like other error messages.

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

mercurial/templater.py

@@ -1,1114 +1,1114 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.
 
 """Slightly complicated template engine for commands and hgweb
 
 This module provides low-level interface to the template engine. See the
 formatter and cmdutil modules if you are looking for high-level functions
 such as ``cmdutil.rendertemplate(ctx, tmpl)``.
 
 Internal Data Types
 -------------------
 
 Template keywords and functions take a dictionary of current symbols and
 resources (a "mapping") and return result. Inputs and outputs must be one
 of the following data types:
 
 bytes
     a byte string, which is generally a human-readable text in local encoding.
 
 generator
     a lazily-evaluated byte string, which is a possibly nested generator of
     values of any printable types, and  will be folded by ``stringify()``
     or ``flatten()``.
 
 None
     sometimes represents an empty value, which can be stringified to ''.
 
 True, False, int, float
     can be stringified as such.
 
 wrappedbytes, wrappedvalue
     a wrapper for the above printable types.
 
 date
     represents a (unixtime, offset) tuple.
 
 hybrid
     represents a list/dict of printable values, which can also be converted
     to mappings by % operator.
 
 hybriditem
     represents a scalar printable value, also supports % operator.
 
 revslist
     represents a list of revision numbers.
 
 mappinggenerator, mappinglist
     represents mappings (i.e. a list of dicts), which may have default
     output format.
 
 mappingdict
     represents a single mapping (i.e. a dict), which may have default output
     format.
 
 mappingnone
     represents None of Optional[mappable], which will be mapped to an empty
     string by % operation.
 
 mappedgenerator
     a lazily-evaluated list of byte strings, which is e.g. a result of %
     operation.
 """
 
 from __future__ import absolute_import, print_function
 
 import abc
 import os
 
 from .i18n import _
 from .pycompat import getattr
 from . import (
     config,
     encoding,
     error,
     parser,
     pycompat,
     templatefilters,
     templatefuncs,
     templateutil,
     util,
 )
 from .utils import (
     resourceutil,
     stringutil,
 )
 
 # template parsing
 
 elements = {
     # token-type: binding-strength, primary, prefix, infix, suffix
     b"(": (20, None, (b"group", 1, b")"), (b"func", 1, b")"), None),
     b".": (18, None, None, (b".", 18), None),
     b"%": (15, None, None, (b"%", 15), None),
     b"|": (15, None, None, (b"|", 15), None),
     b"*": (5, None, None, (b"*", 5), None),
     b"/": (5, None, None, (b"/", 5), None),
     b"+": (4, None, None, (b"+", 4), None),
     b"-": (4, None, (b"negate", 19), (b"-", 4), None),
     b"=": (3, None, None, (b"keyvalue", 3), None),
     b",": (2, None, None, (b"list", 2), None),
     b")": (0, None, None, None, None),
     b"integer": (0, b"integer", None, None, None),
     b"symbol": (0, b"symbol", None, None, None),
     b"string": (0, b"string", None, None, None),
     b"template": (0, b"template", None, None, None),
     b"end": (0, None, None, None, None),
 }
 
 
 def tokenize(program, start, end, term=None):
     """Parse a template expression into a stream of tokens, which must end
     with term if specified"""
     pos = start
     program = pycompat.bytestr(program)
     while pos < end:
         c = program[pos]
         if c.isspace():  # skip inter-token whitespace
             pass
         elif c in b"(=,).%|+-*/":  # handle simple operators
             yield (c, None, pos)
         elif c in b'"\'':  # handle quoted templates
             s = pos + 1
             data, pos = _parsetemplate(program, s, end, c)
             yield (b'template', data, s)
             pos -= 1
         elif c == b'r' and program[pos : pos + 2] in (b"r'", b'r"'):
             # handle quoted strings
             c = program[pos + 1]
             s = pos = pos + 2
             while pos < end:  # find closing quote
                 d = program[pos]
                 if d == b'\\':  # skip over escaped characters
                     pos += 2
                     continue
                 if d == c:
                     yield (b'string', program[s:pos], s)
                     break
                 pos += 1
             else:
                 raise error.ParseError(_(b"unterminated string"), s)
         elif c.isdigit():
             s = pos
             while pos < end:
                 d = program[pos]
                 if not d.isdigit():
                     break
                 pos += 1
             yield (b'integer', program[s:pos], s)
             pos -= 1
         elif (
             c == b'\\'
             and program[pos : pos + 2] in (br"\'", br'\"')
             or c == b'r'
             and program[pos : pos + 3] in (br"r\'", br'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 == b'r':
                 pos += 1
                 token = b'string'
             else:
                 token = b'template'
             quote = program[pos : pos + 2]
             s = pos = pos + 2
             while pos < end:  # find closing escaped quote
                 if program.startswith(b'\\\\\\', 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 == b'template':
                         data = _parsetemplate(data, 0, len(data))[0]
                     yield (token, data, s)
                     pos += 1
                     break
                 pos += 1
             else:
                 raise error.ParseError(_(b"unterminated string"), s)
         elif c.isalnum() or c in b'_':
             s = pos
             pos += 1
             while pos < end:  # find end of symbol
                 d = program[pos]
                 if not (d.isalnum() or d == b"_"):
                     break
                 pos += 1
             sym = program[s:pos]
             yield (b'symbol', sym, s)
             pos -= 1
         elif c == term:
             yield (b'end', None, pos)
             return
         else:
             raise error.ParseError(_(b"syntax error"), pos)
         pos += 1
     if term:
         raise error.ParseError(_(b"unterminated template expansion"), start)
     yield (b'end', None, pos)
 
 
 def _parsetemplate(tmpl, start, stop, quote=b''):
     r"""
     >>> _parsetemplate(b'foo{bar}"baz', 0, 12)
     ([('string', 'foo'), ('symbol', 'bar'), ('string', '"baz')], 12)
     >>> _parsetemplate(b'foo{bar}"baz', 0, 12, quote=b'"')
     ([('string', 'foo'), ('symbol', 'bar')], 9)
     >>> _parsetemplate(b'foo"{bar}', 0, 9, quote=b'"')
     ([('string', 'foo')], 4)
     >>> _parsetemplate(br'foo\"bar"baz', 0, 12, quote=b'"')
     ([('string', 'foo"'), ('string', 'bar')], 9)
     >>> _parsetemplate(br'foo\\"bar', 0, 10, quote=b'"')
     ([('string', 'foo\\')], 6)
     """
     parsed = []
     for typ, val, pos in _scantemplate(tmpl, start, stop, quote):
         if typ == b'string':
             parsed.append((typ, val))
         elif typ == b'template':
             parsed.append(val)
         elif typ == b'end':
             return parsed, pos
         else:
             raise error.ProgrammingError(b'unexpected type: %s' % typ)
     raise error.ProgrammingError(b'unterminated scanning of template')
 
 
 def scantemplate(tmpl, raw=False):
     r"""Scan (type, start, end) positions of outermost elements in template
 
     If raw=True, a backslash is not taken as an escape character just like
     r'' string in Python. Note that this is different from r'' literal in
     template in that no template fragment can appear in r'', e.g. r'{foo}'
     is a literal '{foo}', but ('{foo}', raw=True) is a template expression
     'foo'.
 
     >>> list(scantemplate(b'foo{bar}"baz'))
     [('string', 0, 3), ('template', 3, 8), ('string', 8, 12)]
     >>> list(scantemplate(b'outer{"inner"}outer'))
     [('string', 0, 5), ('template', 5, 14), ('string', 14, 19)]
     >>> list(scantemplate(b'foo\\{escaped}'))
     [('string', 0, 5), ('string', 5, 13)]
     >>> list(scantemplate(b'foo\\{escaped}', raw=True))
     [('string', 0, 4), ('template', 4, 13)]
     """
     last = None
     for typ, val, pos in _scantemplate(tmpl, 0, len(tmpl), raw=raw):
         if last:
             yield last + (pos,)
         if typ == b'end':
             return
         else:
             last = (typ, pos)
     raise error.ProgrammingError(b'unterminated scanning of template')
 
 
 def _scantemplate(tmpl, start, stop, quote=b'', raw=False):
     """Parse template string into chunks of strings and template expressions"""
     sepchars = b'{' + quote
     unescape = [parser.unescapestr, pycompat.identity][raw]
     pos = start
     p = parser.parser(elements)
     try:
         while pos < stop:
             n = min(
                 (tmpl.find(c, pos, stop) for c in pycompat.bytestr(sepchars)),
                 key=lambda n: (n < 0, n),
             )
             if n < 0:
                 yield (b'string', unescape(tmpl[pos:stop]), pos)
                 pos = stop
                 break
             c = tmpl[n : n + 1]
             bs = 0  # count leading backslashes
             if not raw:
                 bs = (n - pos) - len(tmpl[pos:n].rstrip(b'\\'))
             if bs % 2 == 1:
                 # escaped (e.g. '\{', '\\\{', but not '\\{')
                 yield (b'string', unescape(tmpl[pos : n - 1]) + c, pos)
                 pos = n + 1
                 continue
             if n > pos:
                 yield (b'string', unescape(tmpl[pos:n]), pos)
             if c == quote:
                 yield (b'end', None, n + 1)
                 return
 
             parseres, pos = p.parse(tokenize(tmpl, n + 1, stop, b'}'))
             if not tmpl.startswith(b'}', pos):
                 raise error.ParseError(_(b"invalid token"), pos)
             yield (b'template', parseres, n)
             pos += 1
 
         if quote:
             raise error.ParseError(_(b"unterminated string"), start)
     except error.ParseError as inst:
         _addparseerrorhint(inst, tmpl)
         raise
     yield (b'end', None, pos)
 
 
 def _addparseerrorhint(inst, tmpl):
     if len(inst.args) <= 1:
         return  # no location
     loc = inst.args[1]
     # Offset the caret location by the number of newlines before the
     # location of the error, since we will replace one-char newlines
     # with the two-char literal r'\n'.
     offset = tmpl[:loc].count(b'\n')
     tmpl = tmpl.replace(b'\n', br'\n')
     # We want the caret to point to the place in the template that
     # failed to parse, but in a hint we get a open paren at the
     # start. Therefore, we print "loc + 1" spaces (instead of "loc")
     # to line up the caret with the location of the error.
     inst.hint = tmpl + b'\n' + b' ' * (loc + 1 + offset) + b'^ ' + _(b'here')
 
 
 def _unnesttemplatelist(tree):
     """Expand list of templates to node tuple
 
     >>> def f(tree):
     ...     print(pycompat.sysstr(prettyformat(_unnesttemplatelist(tree))))
     >>> f((b'template', []))
     (string '')
     >>> f((b'template', [(b'string', b'foo')]))
     (string 'foo')
     >>> f((b'template', [(b'string', b'foo'), (b'symbol', b'rev')]))
     (template
       (string 'foo')
       (symbol 'rev'))
     >>> f((b'template', [(b'symbol', b'rev')]))  # template(rev) -> str
     (template
       (symbol 'rev'))
     >>> f((b'template', [(b'template', [(b'string', b'foo')])]))
     (string 'foo')
     """
     if not isinstance(tree, tuple):
         return tree
     op = tree[0]
     if op != b'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 (b'string', b'')  # empty template ""
     elif len(xs) == 1 and xs[0][0] == b'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), b'unquoted template should be consumed'
     return _unnesttemplatelist((b'template', parsed))
 
 
 def parseexpr(expr):
     """Parse a template expression into tree
 
     >>> parseexpr(b'"foo"')
     ('string', 'foo')
     >>> parseexpr(b'foo(bar)')
     ('func', ('symbol', 'foo'), ('symbol', 'bar'))
     >>> parseexpr(b'foo(')
     Traceback (most recent call last):
       ...
     ParseError: ('not a prefix: end', 4)
     >>> parseexpr(b'"foo" "bar"')
     Traceback (most recent call last):
       ...
     ParseError: ('invalid token', 7)
     """
     try:
         return _parseexpr(expr)
     except error.ParseError as inst:
         _addparseerrorhint(inst, expr)
         raise
 
 
 def _parseexpr(expr):
     p = parser.parser(elements)
     tree, pos = p.parse(tokenize(expr, 0, len(expr)))
     if pos != len(expr):
         raise error.ParseError(_(b'invalid token'), pos)
     return _unnesttemplatelist(tree)
 
 
 def prettyformat(tree):
     return parser.prettyformat(tree, (b'integer', b'string', b'symbol'))
 
 
 def compileexp(exp, context, curmethods):
     """Compile parsed template tree to (func, data) pair"""
     if not exp:
         raise error.ParseError(_(b"missing argument"))
     t = exp[0]
     return curmethods[t](exp, context)
 
 
 # template evaluation
 
 
 def getsymbol(exp):
     if exp[0] == b'symbol':
         return exp[1]
     raise error.ParseError(_(b"expected a symbol, got '%s'") % exp[0])
 
 
 def getlist(x):
     if not x:
         return []
     if x[0] == b'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 (b'template', b'string'):
         return compileexp(exp, context, methods)
     if exp[0] == b'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(_(b"expected template specifier"))
 
 
 def _runrecursivesymbol(context, mapping, key):
     raise error.Abort(_(b"recursive reference '%s' in template") % key)
 
 
 def buildtemplate(exp, context):
     ctmpl = [compileexp(e, context, methods) for e in exp[1:]]
     return (templateutil.runtemplate, ctmpl)
 
 
 def buildfilter(exp, context):
     n = getsymbol(exp[2])
     if n in context._filters:
         filt = context._filters[n]
         arg = compileexp(exp[1], context, methods)
         return (templateutil.runfilter, (arg, filt))
     if n in context._funcs:
         f = context._funcs[n]
         args = _buildfuncargs(exp[1], context, methods, n, f._argspec)
         return (f, args)
     raise error.ParseError(_(b"unknown function '%s'") % n)
 
 
 def buildmap(exp, context):
     darg = compileexp(exp[1], context, methods)
     targ = gettemplate(exp[2], context)
     return (templateutil.runmap, (darg, targ))
 
 
 def buildmember(exp, context):
     darg = compileexp(exp[1], context, methods)
     memb = getsymbol(exp[2])
     return (templateutil.runmember, (darg, memb))
 
 
 def buildnegate(exp, context):
     arg = compileexp(exp[1], context, exprmethods)
     return (templateutil.runnegate, arg)
 
 
 def buildarithmetic(exp, context, func):
     left = compileexp(exp[1], context, exprmethods)
     right = compileexp(exp[2], context, exprmethods)
     return (templateutil.runarithmetic, (func, left, right))
 
 
 def buildfunc(exp, context):
     n = getsymbol(exp[1])
     if n in context._funcs:
         f = context._funcs[n]
         args = _buildfuncargs(exp[2], context, exprmethods, n, f._argspec)
         return (f, args)
     if n in context._filters:
         args = _buildfuncargs(exp[2], context, exprmethods, n, argspec=None)
         if len(args) != 1:
             raise error.ParseError(_(b"filter %s expects one argument") % n)
         f = context._filters[n]
         return (templateutil.runfilter, (args[0], f))
     raise error.ParseError(_(b"unknown function '%s'") % n)
 
 
 def _buildfuncargs(exp, context, curmethods, funcname, argspec):
     """Compile parsed tree of function arguments into list or dict of
     (func, data) pairs
 
     >>> context = engine(lambda t: (templateutil.runsymbol, t))
     >>> def fargs(expr, argspec):
     ...     x = _parseexpr(expr)
     ...     n = getsymbol(x[1])
     ...     return _buildfuncargs(x[2], context, exprmethods, n, argspec)
     >>> list(fargs(b'a(l=1, k=2)', b'k l m').keys())
     ['l', 'k']
     >>> args = fargs(b'a(opts=1, k=2)', b'**opts')
     >>> list(args.keys()), list(args[b'opts'].keys())
     (['opts'], ['opts', 'k'])
     """
 
     def compiledict(xs):
         return util.sortdict(
             (k, compileexp(x, context, curmethods))
             for k, x in pycompat.iteritems(xs)
         )
 
     def compilelist(xs):
         return [compileexp(x, context, curmethods) for x in xs]
 
     if not argspec:
         # filter or function with no argspec: return list of positional args
         return compilelist(getlist(exp))
 
     # function with argspec: return dict of named args
     _poskeys, varkey, _keys, optkey = argspec = parser.splitargspec(argspec)
     treeargs = parser.buildargsdict(
         getlist(exp),
         funcname,
         argspec,
         keyvaluenode=b'keyvalue',
         keynode=b'symbol',
     )
     compargs = util.sortdict()
     if varkey:
         compargs[varkey] = compilelist(treeargs.pop(varkey))
     if optkey:
         compargs[optkey] = compiledict(treeargs.pop(optkey))
     compargs.update(compiledict(treeargs))
     return compargs
 
 
 def buildkeyvaluepair(exp, content):
     raise error.ParseError(_(b"can't use a key-value pair in this context"))
 
 
 def buildlist(exp, context):
     raise error.ParseError(
         _(b"can't use a list in this context"),
         hint=_(b'check place of comma and parens'),
     )
 
 
 # methods to interpret function arguments or inner expressions (e.g. {_(x)})
 exprmethods = {
     b"integer": lambda e, c: (templateutil.runinteger, e[1]),
     b"string": lambda e, c: (templateutil.runstring, e[1]),
     b"symbol": lambda e, c: (templateutil.runsymbol, e[1]),
     b"template": buildtemplate,
     b"group": lambda e, c: compileexp(e[1], c, exprmethods),
     b".": buildmember,
     b"|": buildfilter,
     b"%": buildmap,
     b"func": buildfunc,
     b"keyvalue": buildkeyvaluepair,
     b"list": buildlist,
     b"+": lambda e, c: buildarithmetic(e, c, lambda a, b: a + b),
     b"-": lambda e, c: buildarithmetic(e, c, lambda a, b: a - b),
     b"negate": buildnegate,
     b"*": lambda e, c: buildarithmetic(e, c, lambda a, b: a * b),
     b"/": lambda e, c: buildarithmetic(e, c, lambda a, b: a // b),
 }
 
 # methods to interpret top-level template (e.g. {x}, {x|_}, {x % "y"})
 methods = exprmethods.copy()
 methods[b"integer"] = exprmethods[b"symbol"]  # '{1}' as variable
 
 
 class _aliasrules(parser.basealiasrules):
     """Parsing and expansion rule set of template aliases"""
 
     _section = _(b'template alias')
     _parse = staticmethod(_parseexpr)
 
     @staticmethod
     def _trygetfunc(tree):
         """Return (name, args) if tree is func(...) or ...|filter; otherwise
         None"""
         if tree[0] == b'func' and tree[1][0] == b'symbol':
             return tree[1][1], getlist(tree[2])
         if tree[0] == b'|' and tree[2][0] == b'symbol':
             return tree[2][1], [tree[1]]
 
 
 def expandaliases(tree, aliases):
     """Return new tree of aliases are expanded"""
     aliasmap = _aliasrules.buildmap(aliases)
     return _aliasrules.expand(aliasmap, tree)
 
 
 # template engine
 
 
 def unquotestring(s):
     '''unwrap quotes if any; otherwise returns unmodified string'''
     if len(s) < 2 or s[0] not in b"'\"" or s[0] != s[-1]:
         return s
     return s[1:-1]
 
 
 class resourcemapper(object):  # pytype: disable=ignored-metaclass
     """Mapper of internal template resources"""
 
     __metaclass__ = abc.ABCMeta
 
     @abc.abstractmethod
     def availablekeys(self, mapping):
         """Return a set of available resource keys based on the given mapping"""
 
     @abc.abstractmethod
     def knownkeys(self):
         """Return a set of supported resource keys"""
 
     @abc.abstractmethod
     def lookup(self, mapping, key):
         """Return a resource for the key if available; otherwise None"""
 
     @abc.abstractmethod
     def populatemap(self, context, origmapping, newmapping):
         """Return a dict of additional mapping items which should be paired
         with the given new mapping"""
 
 
 class nullresourcemapper(resourcemapper):
     def availablekeys(self, mapping):
         return set()
 
     def knownkeys(self):
         return set()
 
     def lookup(self, mapping, key):
         return None
 
     def populatemap(self, context, origmapping, newmapping):
         return {}
 
 
 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, resources=None):
         self._loader = loader
         if filters is None:
             filters = {}
         self._filters = filters
         self._funcs = templatefuncs.funcs  # make this a parameter if needed
         if defaults is None:
             defaults = {}
         if resources is None:
             resources = nullresourcemapper()
         self._defaults = defaults
         self._resources = resources
         self._cache = {}  # key: (func, data)
         self._tmplcache = {}  # literal template: (func, data)
 
     def overlaymap(self, origmapping, newmapping):
         """Create combined mapping from the original mapping and partial
         mapping to override the original"""
         # do not copy symbols which overrides the defaults depending on
         # new resources, so the defaults will be re-evaluated (issue5612)
         knownres = self._resources.knownkeys()
         newres = self._resources.availablekeys(newmapping)
         mapping = {
             k: v
             for k, v in pycompat.iteritems(origmapping)
             if (
                 k in knownres  # not a symbol per self.symbol()
                 or newres.isdisjoint(self._defaultrequires(k))
             )
         }
         mapping.update(newmapping)
         mapping.update(
             self._resources.populatemap(self, origmapping, newmapping)
         )
         return mapping
 
     def _defaultrequires(self, key):
         """Resource keys required by the specified default symbol function"""
         v = self._defaults.get(key)
         if v is None or not callable(v):
             return ()
         return getattr(v, '_requires', ())
 
     def symbol(self, mapping, key):
         """Resolve symbol to value or function; None if nothing found"""
         v = None
         if key not in self._resources.knownkeys():
             v = mapping.get(key)
         if v is None:
             v = self._defaults.get(key)
         return v
 
     def availableresourcekeys(self, mapping):
         """Return a set of available resource keys based on the given mapping"""
         return self._resources.availablekeys(mapping)
 
     def knownresourcekeys(self):
         """Return a set of supported resource keys"""
         return self._resources.knownkeys()
 
     def resource(self, mapping, key):
         """Return internal data (e.g. cache) used for keyword/function
         evaluation"""
         v = self._resources.lookup(mapping, key)
         if v is None:
             raise templateutil.ResourceUnavailable(
                 _(b'template resource not available: %s') % key
             )
         return v
 
     def _load(self, t):
         '''load, parse, and cache a template'''
         if t not in self._cache:
             x = self._loader(t)
             # put poison to cut recursion while compiling 't'
             self._cache[t] = (_runrecursivesymbol, t)
             try:
                 self._cache[t] = compileexp(x, self, methods)
             except:  # re-raises
                 del self._cache[t]
                 raise
         return self._cache[t]
 
     def _parse(self, tmpl):
         """Parse and cache a literal template"""
         if tmpl not in self._tmplcache:
             x = parse(tmpl)
             self._tmplcache[tmpl] = compileexp(x, self, methods)
         return self._tmplcache[tmpl]
 
     def preload(self, t):
         """Load, parse, and cache the specified template if available"""
         try:
             self._load(t)
             return True
         except templateutil.TemplateNotFound:
             return False
 
     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 self._expand(func, data, mapping)
 
     def expand(self, tmpl, mapping):
         """Perform expansion over a literal template
 
         No user aliases will be expanded since this is supposed to be called
         with an internal template string.
         """
         func, data = self._parse(tmpl)
         return self._expand(func, data, mapping)
 
     def _expand(self, func, data, mapping):
         # populate additional items only if they don't exist in the given
         # mapping. this is slightly different from overlaymap() because the
         # initial 'revcache' may contain pre-computed items.
         extramapping = self._resources.populatemap(self, {}, mapping)
         if extramapping:
             extramapping.update(mapping)
             mapping = extramapping
         return templateutil.flatten(self, mapping, func(self, mapping, data))
 
 
 def stylelist():
     path = templatedir()
     if not path:
         return _(b'no templates found, try `hg debuginstall` for more info')
     dirlist = os.listdir(path)
     stylelist = []
     for file in dirlist:
         split = file.split(b".")
         if split[-1] in (b'orig', b'rej'):
             continue
         if split[0] == b"map-cmdline":
             stylelist.append(split[1])
     return b", ".join(sorted(stylelist))
 
 
 def _readmapfile(mapfile):
     """Load template elements from the given map file"""
     if not os.path.exists(mapfile):
         raise error.Abort(
             _(b"style '%s' not found") % mapfile,
             hint=_(b"available styles: %s") % stylelist(),
         )
 
     base = os.path.dirname(mapfile)
     conf = config.config()
 
     def include(rel, remap, sections):
         templatedirs = [base, templatedir()]
         for dir in templatedirs:
             if dir is None:
                 continue
             abs = os.path.normpath(os.path.join(dir, rel))
             if os.path.isfile(abs):
                 data = util.posixfile(abs, b'rb').read()
                 conf.parse(
                     abs, data, sections=sections, remap=remap, include=include
                 )
                 break
 
     data = util.posixfile(mapfile, b'rb').read()
     conf.parse(mapfile, data, remap={b'': b'templates'}, include=include)
 
     cache = {}
     tmap = {}
     aliases = []
 
     val = conf.get(b'templates', b'__base__')
     if val and val[0] not in b"'\"":
         # treat as a pointer to a base class for this style
         path = util.normpath(os.path.join(base, val))
 
         # fallback check in template paths
         if not os.path.exists(path):
             dir = templatedir()
             if dir is not None:
                 p2 = util.normpath(os.path.join(dir, val))
                 if os.path.isfile(p2):
                     path = p2
                 else:
                     p3 = util.normpath(os.path.join(p2, b"map"))
                     if os.path.isfile(p3):
                         path = p3
 
         cache, tmap, aliases = _readmapfile(path)
 
     for key, val in conf[b'templates'].items():
         if not val:
             raise error.ParseError(
                 _(b'missing value'), conf.source(b'templates', key)
             )
         if val[0] in b"'\"":
             if val[0] != val[-1]:
                 raise error.ParseError(
                     _(b'unmatched quotes'), conf.source(b'templates', key)
                 )
             cache[key] = unquotestring(val)
         elif key != b'__base__':
             tmap[key] = os.path.join(base, val)
     aliases.extend(conf[b'templatealias'].items())
     return cache, tmap, aliases
 
 
 class loader(object):
     """Load template fragments optionally from a map file"""
 
     def __init__(self, cache, aliases):
         if cache is None:
             cache = {}
         self.cache = cache.copy()
         self._map = {}
         self._aliasmap = _aliasrules.buildmap(aliases)
 
     def __contains__(self, key):
         return key in self.cache or key in self._map
 
     def load(self, t):
         """Get parsed tree for the given template name. Use a local cache."""
         if t not in self.cache:
             try:
                 self.cache[t] = util.readfile(self._map[t])
             except KeyError as inst:
                 raise templateutil.TemplateNotFound(
                     _(b'"%s" not in template map') % inst.args[0]
                 )
             except IOError as inst:
                 reason = _(b'template file %s: %s') % (
                     self._map[t],
                     stringutil.forcebytestr(inst.args[1]),
                 )
                 raise IOError(inst.args[0], encoding.strfromlocal(reason))
         return self._parse(self.cache[t])
 
     def _parse(self, tmpl):
         x = parse(tmpl)
         if self._aliasmap:
             x = _aliasrules.expand(self._aliasmap, x)
         return x
 
     def _findsymbolsused(self, tree, syms):
         if not tree:
             return
         op = tree[0]
         if op == b'symbol':
             s = tree[1]
             if s in syms[0]:
                 return  # avoid recursion: s -> cache[s] -> s
             syms[0].add(s)
             if s in self.cache or s in self._map:
                 # s may be a reference for named template
                 self._findsymbolsused(self.load(s), syms)
             return
         if op in {b'integer', b'string'}:
             return
         # '{arg|func}' == '{func(arg)}'
         if op == b'|':
             syms[1].add(getsymbol(tree[2]))
             self._findsymbolsused(tree[1], syms)
             return
         if op == b'func':
             syms[1].add(getsymbol(tree[1]))
             self._findsymbolsused(tree[2], syms)
             return
         for x in tree[1:]:
             self._findsymbolsused(x, syms)
 
     def symbolsused(self, t):
         """Look up (keywords, filters/functions) referenced from the name
         template 't'
 
         This may load additional templates from the map file.
         """
         syms = (set(), set())
         self._findsymbolsused(self.load(t), syms)
         return syms
 
 
 class templater(object):
     def __init__(
         self,
         filters=None,
         defaults=None,
         resources=None,
         cache=None,
         aliases=(),
         minchunk=1024,
         maxchunk=65536,
     ):
         """Create template engine optionally with preloaded template fragments
 
         - ``filters``: a dict of functions to transform a value into another.
         - ``defaults``: a dict of symbol values/functions; may be overridden
           by a ``mapping`` dict.
         - ``resources``: a resourcemapper object to look up internal data
           (e.g. cache), inaccessible from user template.
         - ``cache``: a dict of preloaded template fragments.
         - ``aliases``: a list of alias (name, replacement) pairs.
 
         self.cache may be updated later to register additional template
         fragments.
         """
         allfilters = templatefilters.filters.copy()
         if filters:
             allfilters.update(filters)
         self._loader = loader(cache, aliases)
         self._proc = engine(self._loader.load, allfilters, defaults, resources)
         self._minchunk, self._maxchunk = minchunk, maxchunk
 
     @classmethod
     def frommapfile(
         cls,
         mapfile,
         filters=None,
         defaults=None,
         resources=None,
         cache=None,
         minchunk=1024,
         maxchunk=65536,
     ):
         """Create templater from the specified map file"""
         t = cls(filters, defaults, resources, cache, [], minchunk, maxchunk)
         cache, tmap, aliases = _readmapfile(mapfile)
         t._loader.cache.update(cache)
         t._loader._map = tmap
         t._loader._aliasmap = _aliasrules.buildmap(aliases)
         return t
 
     def __contains__(self, key):
         return key in self._loader
 
     @property
     def cache(self):
         return self._loader.cache
 
     # for highlight extension to insert one-time 'colorize' filter
     @property
     def _filters(self):
         return self._proc._filters
 
     @property
     def defaults(self):
         return self._proc._defaults
 
     def load(self, t):
         """Get parsed tree for the given template name. Use a local cache."""
         return self._loader.load(t)
 
     def symbolsuseddefault(self):
         """Look up (keywords, filters/functions) referenced from the default
         unnamed template
 
         This may load additional templates from the map file.
         """
         return self.symbolsused(b'')
 
     def symbolsused(self, t):
         """Look up (keywords, filters/functions) referenced from the name
         template 't'
 
         This may load additional templates from the map file.
         """
         return self._loader.symbolsused(t)
 
     def renderdefault(self, mapping):
         """Render the default unnamed template and return result as string"""
         return self.render(b'', mapping)
 
     def render(self, t, mapping):
         """Render the specified named template and return result as string"""
         return b''.join(self.generate(t, mapping))
 
     def generate(self, t, mapping):
         """Return a generator that renders the specified named template and
         yields chunks"""
         stream = self._proc.process(t, mapping)
         if self._minchunk:
             stream = util.increasingchunks(
                 stream, min=self._minchunk, max=self._maxchunk
             )
         return stream
 
 
 def templatedir():
     '''return the directory used for template files, or None.'''
     path = os.path.normpath(os.path.join(resourceutil.datapath, b'templates'))
     return path if os.path.isdir(path) else None
 
 
 def templatepath(name):
     '''return location of template file. returns None if not found.'''
     dir = templatedir()
     if dir is None:
         return None
     f = os.path.join(templatedir(), name)
-    if f and os.path.exists(f):
+    if f and os.path.isfile(f):
         return f
     return None
 
 
 def stylemap(styles, path=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 path is None:
         path = templatedir()
 
     if isinstance(styles, bytes):
         styles = [styles]
 
     if path is not None:
         for style in styles:
             # only plain name is allowed to honor template paths
             if (
                 not style
                 or style in (pycompat.oscurdir, pycompat.ospardir)
                 or pycompat.ossep in style
                 or pycompat.osaltsep
                 and pycompat.osaltsep in style
             ):
                 continue
             locations = [os.path.join(style, b'map'), b'map-' + style]
             locations.append(b'map')
 
             for location in locations:
                 mapfile = os.path.join(path, location)
                 if os.path.isfile(mapfile):
                     return style, mapfile
 
     raise RuntimeError(b"No hgweb templates found in %r" % path)

tests/test-template-map.t

@@ -1,1992 +1,1993 b''
 Test template map files and styles
 ==================================
 
   $ 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"
 
 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
 
   $ cat <<'EOF' >> .hg/hgrc
   > [templates]
   > simple = "{rev}\n"
   > simple2 = {rev}\n
   > rev = "should not precede {rev} keyword\n"
   > EOF
 
   $ hg log -l1 -Tsimple
   8
   $ hg log -l1 -Tsimple2
   8
   $ hg log -l1 -Trev
   should not precede 8 keyword
   $ hg log -l1 -T '{simple}'
   8
 
 Map file shouldn't see user templates:
 
   $ cat <<EOF > tmpl
   > changeset = 'nothing expanded:{simple}\n'
   > EOF
   $ hg log -l1 --style ./tmpl
   nothing expanded:
 
 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
 
  a map file may have [templates] and [templatealias] sections:
 
   $ cat <<'EOF' > map-simple
   > [templates]
   > changeset = "{a}\n"
   > [templatealias]
   > a = rev
   > EOF
   $ hg log -l1 -T./map-simple
   8
 
  so it can be included in hgrc
 
   $ cat <<EOF > myhgrc
   > %include $HGRCPATH
   > %include map-simple
   > [templates]
   > foo = "{changeset}"
   > EOF
   $ HGRCPATH=./myhgrc hg log -l1 -Tfoo
   8
   $ HGRCPATH=./myhgrc hg log -l1 -T'{a}\n'
   8
 
 Test template map inheritance
 
   $ echo "__base__ = map-cmdline.default" > map-simple
   $ printf 'cset = "changeset: ***{rev}***\\n"\n' >> map-simple
   $ hg log -l1 -T./map-simple
   changeset: ***8***
   tag:         tip
   user:        test
   date:        Wed Jan 01 10:01:00 2020 +0000
   summary:     third
   
 Test map inheritance with non-existent base
 
   $ echo "__base__ = non-existent" > map-base-nonexistent
   $ hg log -l1 -T./map-base-nonexistent
   abort: style '$TESTTMP/a/non-existent' not found
   (available styles: bisect, changelog, compact, default, phases, show, status, xml)
   [255]
 
 Test map inheritance with directory as base
 
   $ mkdir somedir
   $ echo "__base__ = somedir" > map-base-dir
   $ hg log -l1 -T./map-base-dir
   abort: Is a directory: '$TESTTMP/a/somedir'
   [255]
 
 Test including a built-in template map
 
   $ cat <<'EOF' > map-include-builtin
   > %include map-cmdline.default
   > [templates]
   > changeset = "{changeset_quiet}\n"
   > EOF
   $ hg log -l1 -T./map-include-builtin
   8:95c24699272e
   
 
 Test including a nonexistent template map
 BROKEN: This should probably be an error just like the bad __base__ above
 
   $ cat <<'EOF' > map-include-nonexistent
   > %include nonexistent
   > [templates]
   > changeset = "test\n"
   > EOF
   $ hg log -l1 -T./map-include-nonexistent
   test
 
 Test including a directory as template map
 BROKEN: This should probably be an error just like the bad __base__ above
 
   $ cat <<'EOF' > map-include-dir
   > %include somedir
   > [templates]
   > changeset = "test\n"
   > EOF
   $ hg log -l1 -T./map-include-dir
   test
 
 Test docheader, docfooter and separator in template map
 
   $ cat <<'EOF' > map-myjson
   > docheader = '\{\n'
   > docfooter = '\n}\n'
   > separator = ',\n'
   > changeset = ' {dict(rev, node|short)|json}'
   > EOF
   $ hg log -l2 -T./map-myjson
   {
    {"node": "95c24699272e", "rev": 8},
    {"node": "29114dbae42b", "rev": 7}
   }
 
 Test docheader, docfooter and separator in [templates] section
 
   $ cat <<'EOF' >> .hg/hgrc
   > [templates]
   > myjson = ' {dict(rev, node|short)|json}'
   > myjson:docheader = '\{\n'
   > myjson:docfooter = '\n}\n'
   > myjson:separator = ',\n'
   > :docheader = 'should not be selected as a docheader for literal templates\n'
   > EOF
   $ hg log -l2 -Tmyjson
   {
    {"node": "95c24699272e", "rev": 8},
    {"node": "29114dbae42b", "rev": 7}
   }
   $ hg log -l1 -T'{rev}\n'
   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 CBOR style:
 
   $ cat <<'EOF' > "$TESTTMP/decodecborarray.py"
   > from __future__ import absolute_import
   > from mercurial import (
   >     dispatch,
   > )
   > from mercurial.utils import (
   >     cborutil,
   >     procutil,
   >     stringutil,
   > )
   > dispatch.initstdio()
   > data = procutil.stdin.read()
   > # our CBOR decoder doesn't support parsing indefinite-length arrays,
   > # but the log output is indefinite stream by nature.
   > assert data[:1] == cborutil.BEGIN_INDEFINITE_ARRAY
   > assert data[-1:] == cborutil.BREAK
   > items = cborutil.decodeall(data[1:-1])
   > procutil.stdout.write(stringutil.pprint(items, indent=1) + b'\n')
   > EOF
 
   $ hg log -k nosuch -Tcbor | "$PYTHON" "$TESTTMP/decodecborarray.py"
   []
 
   $ hg log -qr0:1 -Tcbor | "$PYTHON" "$TESTTMP/decodecborarray.py"
   [
    {
     'node': '1e4e1b8f71e05681d422154f5421e385fec3454f',
     'rev': 0
    },
    {
     'node': 'b608e9d1a3f0273ccf70fb85fd6866b3482bf965',
     'rev': 1
    }
   ]
 
   $ hg log -vpr . -Tcbor --stat | "$PYTHON" "$TESTTMP/decodecborarray.py"
   [
    {
     'bookmarks': [],
     'branch': 'default',
     'date': [
      1577872860,
      0
     ],
     'desc': 'third',
     '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',
     'diffstat': ' fourth |  1 +\n second |  1 -\n third  |  1 +\n 3 files changed, 2 insertions(+), 1 deletions(-)\n',
     'files': [
      'fourth',
      'second',
      'third'
     ],
     'node': '95c24699272ef57d062b8bccc32c878bf841784a',
     'parents': [
      '29114dbae42b9f078cf2714dbe3a86bba8ec7453'
     ],
     'phase': 'draft',
     'rev': 8,
     'tags': [
      'tip'
     ],
     'user': 'test'
    }
   ]
 
   $ hg log -r . -T'cbor(rev, node|short)' | "$PYTHON" "$TESTTMP/decodecborarray.py"
   [
    {
     'node': '95c24699272e',
     'rev': 8
    }
   ]
 
   $ hg log -r . -T'cbor()' | "$PYTHON" "$TESTTMP/decodecborarray.py"
   [
    {}
   ]
 
 Test JSON style:
 
   $ hg log -k nosuch -Tjson
   [
   ]
 
   $ hg log -qr . -Tjson
   [
    {
     "node": "95c24699272ef57d062b8bccc32c878bf841784a",
     "rev": 8
    }
   ]
 
   $ hg log -vpr . -Tjson --stat
   [
    {
     "bookmarks": [],
     "branch": "default",
     "date": [1577872860, 0],
     "desc": "third",
     "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",
     "diffstat": " fourth |  1 +\n second |  1 -\n third  |  1 +\n 3 files changed, 2 insertions(+), 1 deletions(-)\n",
     "files": ["fourth", "second", "third"],
     "node": "95c24699272ef57d062b8bccc32c878bf841784a",
     "parents": ["29114dbae42b9f078cf2714dbe3a86bba8ec7453"],
     "phase": "draft",
     "rev": 8,
     "tags": ["tip"],
     "user": "test"
    }
   ]
 
 honor --git but not format-breaking diffopts
   $ hg --config diff.noprefix=True log --git -vpr . -Tjson
   [
    {
     "bookmarks": [],
     "branch": "default",
     "date": [1577872860, 0],
     "desc": "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",
     "files": ["fourth", "second", "third"],
     "node": "95c24699272ef57d062b8bccc32c878bf841784a",
     "parents": ["29114dbae42b9f078cf2714dbe3a86bba8ec7453"],
     "phase": "draft",
     "rev": 8,
     "tags": ["tip"],
     "user": "test"
    }
   ]
 
   $ hg log -T json
   [
    {
     "bookmarks": [],
     "branch": "default",
     "date": [1577872860, 0],
     "desc": "third",
     "node": "95c24699272ef57d062b8bccc32c878bf841784a",
     "parents": ["29114dbae42b9f078cf2714dbe3a86bba8ec7453"],
     "phase": "draft",
     "rev": 8,
     "tags": ["tip"],
     "user": "test"
    },
    {
     "bookmarks": [],
     "branch": "default",
     "date": [1000000, 0],
     "desc": "second",
     "node": "29114dbae42b9f078cf2714dbe3a86bba8ec7453",
     "parents": ["0000000000000000000000000000000000000000"],
     "phase": "draft",
     "rev": 7,
     "tags": [],
     "user": "User Name <user@hostname>"
    },
    {
     "bookmarks": [],
     "branch": "default",
     "date": [1500001, 0],
     "desc": "merge",
     "node": "d41e714fe50d9e4a5f11b4d595d543481b5f980b",
     "parents": ["13207e5a10d9fd28ec424934298e176197f2c67f", "bbe44766e73d5f11ed2177f1838de10c53ef3e74"],
     "phase": "draft",
     "rev": 6,
     "tags": [],
     "user": "person"
    },
    {
     "bookmarks": [],
     "branch": "default",
     "date": [1500000, 0],
     "desc": "new head",
     "node": "13207e5a10d9fd28ec424934298e176197f2c67f",
     "parents": ["10e46f2dcbf4823578cf180f33ecf0b957964c47"],
     "phase": "draft",
     "rev": 5,
     "tags": [],
     "user": "person"
    },
    {
     "bookmarks": [],
     "branch": "foo",
     "date": [1400000, 0],
     "desc": "new branch",
     "node": "bbe44766e73d5f11ed2177f1838de10c53ef3e74",
     "parents": ["10e46f2dcbf4823578cf180f33ecf0b957964c47"],
     "phase": "draft",
     "rev": 4,
     "tags": [],
     "user": "person"
    },
    {
     "bookmarks": [],
     "branch": "default",
     "date": [1300000, 0],
     "desc": "no user, no domain",
     "node": "10e46f2dcbf4823578cf180f33ecf0b957964c47",
     "parents": ["97054abb4ab824450e9164180baf491ae0078465"],
     "phase": "draft",
     "rev": 3,
     "tags": [],
     "user": "person"
    },
    {
     "bookmarks": [],
     "branch": "default",
     "date": [1200000, 0],
     "desc": "no person",
     "node": "97054abb4ab824450e9164180baf491ae0078465",
     "parents": ["b608e9d1a3f0273ccf70fb85fd6866b3482bf965"],
     "phase": "draft",
     "rev": 2,
     "tags": [],
     "user": "other@place"
    },
    {
     "bookmarks": [],
     "branch": "default",
     "date": [1100000, 0],
     "desc": "other 1\nother 2\n\nother 3",
     "node": "b608e9d1a3f0273ccf70fb85fd6866b3482bf965",
     "parents": ["1e4e1b8f71e05681d422154f5421e385fec3454f"],
     "phase": "draft",
     "rev": 1,
     "tags": [],
     "user": "A. N. Other <other@place>"
    },
    {
     "bookmarks": [],
     "branch": "default",
     "date": [1000000, 0],
     "desc": "line 1\nline 2",
     "node": "1e4e1b8f71e05681d422154f5421e385fec3454f",
     "parents": ["0000000000000000000000000000000000000000"],
     "phase": "draft",
     "rev": 0,
     "tags": [],
     "user": "User Name <user@hostname>"
    }
   ]
 
   $ hg heads -v -Tjson
   [
    {
     "bookmarks": [],
     "branch": "default",
     "date": [1577872860, 0],
     "desc": "third",
     "files": ["fourth", "second", "third"],
     "node": "95c24699272ef57d062b8bccc32c878bf841784a",
     "parents": ["29114dbae42b9f078cf2714dbe3a86bba8ec7453"],
     "phase": "draft",
     "rev": 8,
     "tags": ["tip"],
     "user": "test"
    },
    {
     "bookmarks": [],
     "branch": "default",
     "date": [1500001, 0],
     "desc": "merge",
     "files": [],
     "node": "d41e714fe50d9e4a5f11b4d595d543481b5f980b",
     "parents": ["13207e5a10d9fd28ec424934298e176197f2c67f", "bbe44766e73d5f11ed2177f1838de10c53ef3e74"],
     "phase": "draft",
     "rev": 6,
     "tags": [],
     "user": "person"
    },
    {
     "bookmarks": [],
     "branch": "foo",
     "date": [1400000, 0],
     "desc": "new branch",
     "files": [],
     "node": "bbe44766e73d5f11ed2177f1838de10c53ef3e74",
     "parents": ["10e46f2dcbf4823578cf180f33ecf0b957964c47"],
     "phase": "draft",
     "rev": 4,
     "tags": [],
     "user": "person"
    }
   ]
 
   $ hg log --debug -Tjson
   [
    {
     "added": ["fourth", "third"],
     "bookmarks": [],
     "branch": "default",
     "date": [1577872860, 0],
     "desc": "third",
     "extra": {"branch": "default"},
     "manifest": "94961b75a2da554b4df6fb599e5bfc7d48de0c64",
     "modified": [],
     "node": "95c24699272ef57d062b8bccc32c878bf841784a",
     "parents": ["29114dbae42b9f078cf2714dbe3a86bba8ec7453"],
     "phase": "draft",
     "removed": ["second"],
     "rev": 8,
     "tags": ["tip"],
     "user": "test"
    },
    {
     "added": ["second"],
     "bookmarks": [],
     "branch": "default",
     "date": [1000000, 0],
     "desc": "second",
     "extra": {"branch": "default"},
     "manifest": "f2dbc354b94e5ec0b4f10680ee0cee816101d0bf",
     "modified": [],
     "node": "29114dbae42b9f078cf2714dbe3a86bba8ec7453",
     "parents": ["0000000000000000000000000000000000000000"],
     "phase": "draft",
     "removed": [],
     "rev": 7,
     "tags": [],
     "user": "User Name <user@hostname>"
    },
    {
     "added": [],
     "bookmarks": [],
     "branch": "default",
     "date": [1500001, 0],
     "desc": "merge",
     "extra": {"branch": "default"},
     "manifest": "4dc3def4f9b4c6e8de820f6ee74737f91e96a216",
     "modified": [],
     "node": "d41e714fe50d9e4a5f11b4d595d543481b5f980b",
     "parents": ["13207e5a10d9fd28ec424934298e176197f2c67f", "bbe44766e73d5f11ed2177f1838de10c53ef3e74"],
     "phase": "draft",
     "removed": [],
     "rev": 6,
     "tags": [],
     "user": "person"
    },
    {
     "added": ["d"],
     "bookmarks": [],
     "branch": "default",
     "date": [1500000, 0],
     "desc": "new head",
     "extra": {"branch": "default"},
     "manifest": "4dc3def4f9b4c6e8de820f6ee74737f91e96a216",
     "modified": [],
     "node": "13207e5a10d9fd28ec424934298e176197f2c67f",
     "parents": ["10e46f2dcbf4823578cf180f33ecf0b957964c47"],
     "phase": "draft",
     "removed": [],
     "rev": 5,
     "tags": [],
     "user": "person"
    },
    {
     "added": [],
     "bookmarks": [],
     "branch": "foo",
     "date": [1400000, 0],
     "desc": "new branch",
     "extra": {"branch": "foo"},
     "manifest": "cb5a1327723bada42f117e4c55a303246eaf9ccc",
     "modified": [],
     "node": "bbe44766e73d5f11ed2177f1838de10c53ef3e74",
     "parents": ["10e46f2dcbf4823578cf180f33ecf0b957964c47"],
     "phase": "draft",
     "removed": [],
     "rev": 4,
     "tags": [],
     "user": "person"
    },
    {
     "added": [],
     "bookmarks": [],
     "branch": "default",
     "date": [1300000, 0],
     "desc": "no user, no domain",
     "extra": {"branch": "default"},
     "manifest": "cb5a1327723bada42f117e4c55a303246eaf9ccc",
     "modified": ["c"],
     "node": "10e46f2dcbf4823578cf180f33ecf0b957964c47",
     "parents": ["97054abb4ab824450e9164180baf491ae0078465"],
     "phase": "draft",
     "removed": [],
     "rev": 3,
     "tags": [],
     "user": "person"
    },
    {
     "added": ["c"],
     "bookmarks": [],
     "branch": "default",
     "date": [1200000, 0],
     "desc": "no person",
     "extra": {"branch": "default"},
     "manifest": "6e0e82995c35d0d57a52aca8da4e56139e06b4b1",
     "modified": [],
     "node": "97054abb4ab824450e9164180baf491ae0078465",
     "parents": ["b608e9d1a3f0273ccf70fb85fd6866b3482bf965"],
     "phase": "draft",
     "removed": [],
     "rev": 2,
     "tags": [],
     "user": "other@place"
    },
    {
     "added": ["b"],
     "bookmarks": [],
     "branch": "default",
     "date": [1100000, 0],
     "desc": "other 1\nother 2\n\nother 3",
     "extra": {"branch": "default"},
     "manifest": "4e8d705b1e53e3f9375e0e60dc7b525d8211fe55",
     "modified": [],
     "node": "b608e9d1a3f0273ccf70fb85fd6866b3482bf965",
     "parents": ["1e4e1b8f71e05681d422154f5421e385fec3454f"],
     "phase": "draft",
     "removed": [],
     "rev": 1,
     "tags": [],
     "user": "A. N. Other <other@place>"
    },
    {
     "added": ["a"],
     "bookmarks": [],
     "branch": "default",
     "date": [1000000, 0],
     "desc": "line 1\nline 2",
     "extra": {"branch": "default"},
     "manifest": "a0c8bcbbb45c63b90b70ad007bf38961f64f2af0",
     "modified": [],
     "node": "1e4e1b8f71e05681d422154f5421e385fec3454f",
     "parents": ["0000000000000000000000000000000000000000"],
     "phase": "draft",
     "removed": [],
     "rev": 0,
     "tags": [],
     "user": "User Name <user@hostname>"
    }
   ]
 
   $ hg log -l2 -T'json(rev, parents)'
   [
    {"parents": ["29114dbae42b9f078cf2714dbe3a86bba8ec7453"], "rev": 8},
    {"parents": ["0000000000000000000000000000000000000000"], "rev": 7}
   ]
 
   $ hg log -qr. -T'json(rev, parents)'
   [
    {"parents": ["29114dbae42b9f078cf2714dbe3a86bba8ec7453"], "rev": 8}
   ]
 
   $ hg log -r. -T'json(diff)'
   [
    {"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"}
   ]
 
   $ hg log -r. -T'json(diffstat)'
   [
    {"diffstat": " fourth |  1 +\n second |  1 -\n third  |  1 +\n 3 files changed, 2 insertions(+), 1 deletions(-)\n"}
   ]
 
   $ hg log -r. -T'json(manifest)'
   [
    {"manifest": "94961b75a2da554b4df6fb599e5bfc7d48de0c64"}
   ]
 
   $ hg log -r. -T'json(extra)'
   [
    {"extra": {"branch": "default"}}
   ]
 
   $ hg log -r3 -T'json(modified)'
   [
    {"modified": ["c"]}
   ]
 
   $ hg log -r. -T'json(added)'
   [
    {"added": ["fourth", "third"]}
   ]
 
   $ hg log -r. -T'json(removed)'
   [
    {"removed": ["second"]}
   ]
 
   $ hg log -r. -T'json(files)'
   [
    {"files": ["fourth", "second", "third"]}
   ]
 
  --copies is the exception. copies dict is built only when --copies switch
  is on:
 
   $ hg log -r'.^:' -T'json(copies)' --copies
   [
    {"copies": {}},
    {"copies": {"fourth": "second"}}
   ]
 
   $ hg log -r. -T'json()'
   [
    {}
   ]
 
 Other unsupported formatter styles:
 
   $ hg log -qr . -Tpickle
   abort: "pickle" not in template map
   [255]
   $ hg log -qr . -Tdebug
   abort: "debug" not in template map
   [255]
 
 Unparsable function-style references:
 
   $ hg log -qr . -T'json(-)'
   hg: parse error at 6: not a prefix: )
   (json(-)
          ^ here)
   [255]
 
 For backward compatibility, the following examples are not parsed as
 function-style references:
 
   $ hg log -qr . -T'cbor(rev'
   cbor(rev (no-eol)
   $ hg log -qr . -T'json (rev)'
   json (rev) (no-eol)
   $ hg log -qr . -T'json(x="{rev}")'
   json(x="8") (no-eol)
 
 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, show, status, xml)
   [255]
 
   $ hg log -T list
   available styles: bisect, changelog, compact, default, phases, show, status, xml
   abort: specify a template
   [255]
 
 Error if style is a directory:
 
   $ hg log --style somedir
   abort: Is a directory: 'somedir'
   [255]
 
 Error if style is a directory whose name is a built-in style:
 
   $ hg log --style coal
-  abort: Is a directory: '*/mercurial/templates/coal' (glob)
+  abort: style 'coal' not found
+  (available styles: bisect, changelog, compact, default, phases, show, status, xml)
   [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
 
   $ hg phase -r 5 --public
   $ hg phase -r 7 --secret --force
 
 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>
   
 
 Add a dummy commit to make up for the instability of the above:
 
   $ echo a > a
   $ hg add a
   $ hg ci -m future
 
 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
 
   $ cd ..
 
 Set up latesttag repository:
 
   $ 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'
 
   $ hg tag -r 1 -m t1 -d '6 0' t1
   $ hg tag -r 2 -m t2 -d '7 0' t2
   $ hg tag -r 3 -m t3 -d '8 0' t3
   $ hg tag -r 4 -m t4 -d '4 0' t4 # older than t2, but should not matter
   $ hg tag -r 5 -m t5 -d '9 0' t5
   $ hg tag -r 3 -m at3 -d '10 0' at3
 
   $ 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 11:97e5943b523a
 
 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
   11,
   branch: test