templater: abstract ifcontains() over wrapped types

This allows us to make .keytype private.

There's a minor BC that a hybrid dict/list of keytype=None now strictly
checks the type of the needle. For example, {ifcontains(rev, files)} no longer
matches a file named "1" at the rev=1. I made this change for consistency
with the get(dict, key) function. We can restore the old behavior by making
keytype=bytes the default if desired.

mercurial/hgweb/webutil.py

@@ -1,793 +1,797 b''
 # hgweb/webutil.py - utility library for the web interface.
 #
 # Copyright 21 May 2005 - (c) 2005 Jake Edge <[e-mail]>
 # Copyright 2005-2007 Matt Mackall <[e-mail]>
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 from __future__ import absolute_import
 
 import copy
 import difflib
 import os
 import re
 
 from ..i18n import _
 from ..node import hex, nullid, short
 
 from .common import (
     ErrorResponse,
     HTTP_BAD_REQUEST,
     HTTP_NOT_FOUND,
     paritygen,
 )
 
 from .. import (
     context,
     error,
     match,
     mdiff,
     obsutil,
     patch,
     pathutil,
     pycompat,
     scmutil,
     templatefilters,
     templatekw,
     templateutil,
     ui as uimod,
     util,
 )
 
 from ..utils import (
     stringutil,
 )
 
 archivespecs = util.sortdict((
     ('zip', ('application/zip', 'zip', '.zip', None)),
     ('gz', ('application/x-gzip', 'tgz', '.tar.gz', None)),
     ('bz2', ('application/x-bzip2', 'tbz2', '.tar.bz2', None)),
 ))
 
 def archivelist(ui, nodeid, url=None):
     allowed = ui.configlist('web', 'allow-archive', untrusted=True)
     archives = []
 
     for typ, spec in archivespecs.iteritems():
         if typ in allowed or ui.configbool('web', 'allow' + typ,
                                            untrusted=True):
             archives.append({
                 'type': typ,
                 'extension': spec[2],
                 'node': nodeid,
                 'url': url,
             })
 
     return templateutil.mappinglist(archives)
 
 def up(p):
     if p[0:1] != "/":
         p = "/" + p
     if p[-1:] == "/":
         p = p[:-1]
     up = os.path.dirname(p)
     if up == "/":
         return "/"
     return up + "/"
 
 def _navseq(step, firststep=None):
     if firststep:
         yield firststep
         if firststep >= 20 and firststep <= 40:
             firststep = 50
             yield firststep
         assert step > 0
         assert firststep > 0
         while step <= firststep:
             step *= 10
     while True:
         yield 1 * step
         yield 3 * step
         step *= 10
 
 class revnav(object):
 
     def __init__(self, repo):
         """Navigation generation object
 
         :repo: repo object we generate nav for
         """
         # used for hex generation
         self._revlog = repo.changelog
 
     def __nonzero__(self):
         """return True if any revision to navigate over"""
         return self._first() is not None
 
     __bool__ = __nonzero__
 
     def _first(self):
         """return the minimum non-filtered changeset or None"""
         try:
             return next(iter(self._revlog))
         except StopIteration:
             return None
 
     def hex(self, rev):
         return hex(self._revlog.node(rev))
 
     def gen(self, pos, pagelen, limit):
         """computes label and revision id for navigation link
 
         :pos: is the revision relative to which we generate navigation.
         :pagelen: the size of each navigation page
         :limit: how far shall we link
 
         The return is:
             - a single element mappinglist
             - containing a dictionary with a `before` and `after` key
             - values are dictionaries with `label` and `node` keys
         """
         if not self:
             # empty repo
             return templateutil.mappinglist([
                 {'before': templateutil.mappinglist([]),
                  'after': templateutil.mappinglist([])},
             ])
 
         targets = []
         for f in _navseq(1, pagelen):
             if f > limit:
                 break
             targets.append(pos + f)
             targets.append(pos - f)
         targets.sort()
 
         first = self._first()
         navbefore = [{'label': '(%i)' % first, 'node': self.hex(first)}]
         navafter = []
         for rev in targets:
             if rev not in self._revlog:
                 continue
             if pos < rev < limit:
                 navafter.append({'label': '+%d' % abs(rev - pos),
                                  'node': self.hex(rev)})
             if 0 < rev < pos:
                 navbefore.append({'label': '-%d' % abs(rev - pos),
                                   'node': self.hex(rev)})
 
         navafter.append({'label': 'tip', 'node': 'tip'})
 
         # TODO: maybe this can be a scalar object supporting tomap()
         return templateutil.mappinglist([
             {'before': templateutil.mappinglist(navbefore),
              'after': templateutil.mappinglist(navafter)},
         ])
 
 class filerevnav(revnav):
 
     def __init__(self, repo, path):
         """Navigation generation object
 
         :repo: repo object we generate nav for
         :path: path of the file we generate nav for
         """
         # used for iteration
         self._changelog = repo.unfiltered().changelog
         # used for hex generation
         self._revlog = repo.file(path)
 
     def hex(self, rev):
         return hex(self._changelog.node(self._revlog.linkrev(rev)))
 
 # TODO: maybe this can be a wrapper class for changectx/filectx list, which
 # yields {'ctx': ctx}
 def _ctxsgen(context, ctxs):
     for s in ctxs:
         d = {
             'node': s.hex(),
             'rev': s.rev(),
             'user': s.user(),
             'date': s.date(),
             'description': s.description(),
             'branch': s.branch(),
         }
         if util.safehasattr(s, 'path'):
             d['file'] = s.path()
         yield d
 
 def _siblings(siblings=None, hiderev=None):
     if siblings is None:
         siblings = []
     siblings = [s for s in siblings if s.node() != nullid]
     if len(siblings) == 1 and siblings[0].rev() == hiderev:
         siblings = []
     return templateutil.mappinggenerator(_ctxsgen, args=(siblings,))
 
 def difffeatureopts(req, ui, section):
     diffopts = patch.difffeatureopts(ui, untrusted=True,
                                      section=section, whitespace=True)
 
     for k in ('ignorews', 'ignorewsamount', 'ignorewseol', 'ignoreblanklines'):
         v = req.qsparams.get(k)
         if v is not None:
             v = stringutil.parsebool(v)
             setattr(diffopts, k, v if v is not None else True)
 
     return diffopts
 
 def annotate(req, fctx, ui):
     diffopts = difffeatureopts(req, ui, 'annotate')
     return fctx.annotate(follow=True, diffopts=diffopts)
 
 def parents(ctx, hide=None):
     if isinstance(ctx, context.basefilectx):
         introrev = ctx.introrev()
         if ctx.changectx().rev() != introrev:
             return _siblings([ctx.repo()[introrev]], hide)
     return _siblings(ctx.parents(), hide)
 
 def children(ctx, hide=None):
     return _siblings(ctx.children(), hide)
 
 def renamelink(fctx):
     r = fctx.renamed()
     if r:
         return templateutil.mappinglist([{'file': r[0], 'node': hex(r[1])}])
     return templateutil.mappinglist([])
 
 def nodetagsdict(repo, node):
     return templateutil.hybridlist(repo.nodetags(node), name='name')
 
 def nodebookmarksdict(repo, node):
     return templateutil.hybridlist(repo.nodebookmarks(node), name='name')
 
 def nodebranchdict(repo, ctx):
     branches = []
     branch = ctx.branch()
     # If this is an empty repo, ctx.node() == nullid,
     # ctx.branch() == 'default'.
     try:
         branchnode = repo.branchtip(branch)
     except error.RepoLookupError:
         branchnode = None
     if branchnode == ctx.node():
         branches.append(branch)
     return templateutil.hybridlist(branches, name='name')
 
 def nodeinbranch(repo, ctx):
     branches = []
     branch = ctx.branch()
     try:
         branchnode = repo.branchtip(branch)
     except error.RepoLookupError:
         branchnode = None
     if branch != 'default' and branchnode != ctx.node():
         branches.append(branch)
     return templateutil.hybridlist(branches, name='name')
 
 def nodebranchnodefault(ctx):
     branches = []
     branch = ctx.branch()
     if branch != 'default':
         branches.append(branch)
     return templateutil.hybridlist(branches, name='name')
 
 def _nodenamesgen(context, f, node, name):
     for t in f(node):
         yield {name: t}
 
 def showtag(repo, t1, node=nullid):
     args = (repo.nodetags, node, 'tag')
     return templateutil.mappinggenerator(_nodenamesgen, args=args, name=t1)
 
 def showbookmark(repo, t1, node=nullid):
     args = (repo.nodebookmarks, node, 'bookmark')
     return templateutil.mappinggenerator(_nodenamesgen, args=args, name=t1)
 
 def branchentries(repo, stripecount, limit=0):
     tips = []
     heads = repo.heads()
     parity = paritygen(stripecount)
     sortkey = lambda item: (not item[1], item[0].rev())
 
     def entries(context):
         count = 0
         if not tips:
             for tag, hs, tip, closed in repo.branchmap().iterbranches():
                 tips.append((repo[tip], closed))
         for ctx, closed in sorted(tips, key=sortkey, reverse=True):
             if limit > 0 and count >= limit:
                 return
             count += 1
             if closed:
                 status = 'closed'
             elif ctx.node() not in heads:
                 status = 'inactive'
             else:
                 status = 'open'
             yield {
                 'parity': next(parity),
                 'branch': ctx.branch(),
                 'status': status,
                 'node': ctx.hex(),
                 'date': ctx.date()
             }
 
     return templateutil.mappinggenerator(entries)
 
 def cleanpath(repo, path):
     path = path.lstrip('/')
     return pathutil.canonpath(repo.root, '', path)
 
 def changectx(repo, req):
     changeid = "tip"
     if 'node' in req.qsparams:
         changeid = req.qsparams['node']
         ipos = changeid.find(':')
         if ipos != -1:
             changeid = changeid[(ipos + 1):]
 
     return scmutil.revsymbol(repo, changeid)
 
 def basechangectx(repo, req):
     if 'node' in req.qsparams:
         changeid = req.qsparams['node']
         ipos = changeid.find(':')
         if ipos != -1:
             changeid = changeid[:ipos]
             return scmutil.revsymbol(repo, changeid)
 
     return None
 
 def filectx(repo, req):
     if 'file' not in req.qsparams:
         raise ErrorResponse(HTTP_NOT_FOUND, 'file not given')
     path = cleanpath(repo, req.qsparams['file'])
     if 'node' in req.qsparams:
         changeid = req.qsparams['node']
     elif 'filenode' in req.qsparams:
         changeid = req.qsparams['filenode']
     else:
         raise ErrorResponse(HTTP_NOT_FOUND, 'node or filenode not given')
     try:
         fctx = scmutil.revsymbol(repo, changeid)[path]
     except error.RepoError:
         fctx = repo.filectx(path, fileid=changeid)
 
     return fctx
 
 def linerange(req):
     linerange = req.qsparams.getall('linerange')
     if not linerange:
         return None
     if len(linerange) > 1:
         raise ErrorResponse(HTTP_BAD_REQUEST,
                             'redundant linerange parameter')
     try:
         fromline, toline = map(int, linerange[0].split(':', 1))
     except ValueError:
         raise ErrorResponse(HTTP_BAD_REQUEST,
                             'invalid linerange parameter')
     try:
         return util.processlinerange(fromline, toline)
     except error.ParseError as exc:
         raise ErrorResponse(HTTP_BAD_REQUEST, pycompat.bytestr(exc))
 
 def formatlinerange(fromline, toline):
     return '%d:%d' % (fromline + 1, toline)
 
 def _succsandmarkersgen(context, mapping):
     repo = context.resource(mapping, 'repo')
     itemmappings = templatekw.showsuccsandmarkers(context, mapping)
     for item in itemmappings.tovalue(context, mapping):
         item['successors'] = _siblings(repo[successor]
                                        for successor in item['successors'])
         yield item
 
 def succsandmarkers(context, mapping):
     return templateutil.mappinggenerator(_succsandmarkersgen, args=(mapping,))
 
 # teach templater succsandmarkers is switched to (context, mapping) API
 succsandmarkers._requires = {'repo', 'ctx'}
 
 def _whyunstablegen(context, mapping):
     repo = context.resource(mapping, 'repo')
     ctx = context.resource(mapping, 'ctx')
 
     entries = obsutil.whyunstable(repo, ctx)
     for entry in entries:
         if entry.get('divergentnodes'):
             entry['divergentnodes'] = _siblings(entry['divergentnodes'])
         yield entry
 
 def whyunstable(context, mapping):
     return templateutil.mappinggenerator(_whyunstablegen, args=(mapping,))
 
 whyunstable._requires = {'repo', 'ctx'}
 
 def commonentry(repo, ctx):
     node = ctx.node()
     return {
         # TODO: perhaps ctx.changectx() should be assigned if ctx is a
         # filectx, but I'm not pretty sure if that would always work because
         # fctx.parents() != fctx.changectx.parents() for example.
         'ctx': ctx,
         'rev': ctx.rev(),
         'node': hex(node),
         'author': ctx.user(),
         'desc': ctx.description(),
         'date': ctx.date(),
         'extra': ctx.extra(),
         'phase': ctx.phasestr(),
         'obsolete': ctx.obsolete(),
         'succsandmarkers': succsandmarkers,
         'instabilities': templateutil.hybridlist(ctx.instabilities(),
                                                  name='instability'),
         'whyunstable': whyunstable,
         'branch': nodebranchnodefault(ctx),
         'inbranch': nodeinbranch(repo, ctx),
         'branches': nodebranchdict(repo, ctx),
         'tags': nodetagsdict(repo, node),
         'bookmarks': nodebookmarksdict(repo, node),
         'parent': lambda **x: parents(ctx),
         'child': lambda **x: children(ctx),
     }
 
 def changelistentry(web, ctx):
     '''Obtain a dictionary to be used for entries in a changelist.
 
     This function is called when producing items for the "entries" list passed
     to the "shortlog" and "changelog" templates.
     '''
     repo = web.repo
     rev = ctx.rev()
     n = ctx.node()
     showtags = showtag(repo, 'changelogtag', n)
     files = listfilediffs(ctx.files(), n, web.maxfiles)
 
     entry = commonentry(repo, ctx)
     entry.update(
         allparents=lambda **x: parents(ctx),
         parent=lambda **x: parents(ctx, rev - 1),
         child=lambda **x: children(ctx, rev + 1),
         changelogtag=showtags,
         files=files,
     )
     return entry
 
 def changelistentries(web, revs, maxcount, parityfn):
     """Emit up to N records for an iterable of revisions."""
     repo = web.repo
 
     count = 0
     for rev in revs:
         if count >= maxcount:
             break
 
         count += 1
 
         entry = changelistentry(web, repo[rev])
         entry['parity'] = next(parityfn)
 
         yield entry
 
 def symrevorshortnode(req, ctx):
     if 'node' in req.qsparams:
         return templatefilters.revescape(req.qsparams['node'])
     else:
         return short(ctx.node())
 
 def _listfilesgen(context, ctx, stripecount):
     parity = paritygen(stripecount)
     for blockno, f in enumerate(ctx.files()):
         template = 'filenodelink' if f in ctx else 'filenolink'
         yield context.process(template, {
             'node': ctx.hex(),
             'file': f,
             'blockno': blockno + 1,
             'parity': next(parity),
         })
 
 def changesetentry(web, ctx):
     '''Obtain a dictionary to be used to render the "changeset" template.'''
 
     showtags = showtag(web.repo, 'changesettag', ctx.node())
     showbookmarks = showbookmark(web.repo, 'changesetbookmark', ctx.node())
     showbranch = nodebranchnodefault(ctx)
 
     basectx = basechangectx(web.repo, web.req)
     if basectx is None:
         basectx = ctx.p1()
 
     style = web.config('web', 'style')
     if 'style' in web.req.qsparams:
         style = web.req.qsparams['style']
 
     diff = diffs(web, ctx, basectx, None, style)
 
     parity = paritygen(web.stripecount)
     diffstatsgen = diffstatgen(ctx, basectx)
     diffstats = diffstat(ctx, diffstatsgen, parity)
 
     return dict(
         diff=diff,
         symrev=symrevorshortnode(web.req, ctx),
         basenode=basectx.hex(),
         changesettag=showtags,
         changesetbookmark=showbookmarks,
         changesetbranch=showbranch,
         files=templateutil.mappedgenerator(_listfilesgen,
                                            args=(ctx, web.stripecount)),
         diffsummary=lambda **x: diffsummary(diffstatsgen),
         diffstat=diffstats,
         archives=web.archivelist(ctx.hex()),
         **pycompat.strkwargs(commonentry(web.repo, ctx)))
 
 def _listfilediffsgen(context, files, node, max):
     for f in files[:max]:
         yield context.process('filedifflink', {'node': hex(node), 'file': f})
     if len(files) > max:
         yield context.process('fileellipses', {})
 
 def listfilediffs(files, node, max):
     return templateutil.mappedgenerator(_listfilediffsgen,
                                         args=(files, node, max))
 
 def _prettyprintdifflines(context, lines, blockno, lineidprefix):
     for lineno, l in enumerate(lines, 1):
         difflineno = "%d.%d" % (blockno, lineno)
         if l.startswith('+'):
             ltype = "difflineplus"
         elif l.startswith('-'):
             ltype = "difflineminus"
         elif l.startswith('@'):
             ltype = "difflineat"
         else:
             ltype = "diffline"
         yield context.process(ltype, {
             'line': l,
             'lineno': lineno,
             'lineid': lineidprefix + "l%s" % difflineno,
             'linenumber': "% 8s" % difflineno,
         })
 
 def _diffsgen(context, repo, ctx, basectx, files, style, stripecount,
               linerange, lineidprefix):
     if files:
         m = match.exact(repo.root, repo.getcwd(), files)
     else:
         m = match.always(repo.root, repo.getcwd())
 
     diffopts = patch.diffopts(repo.ui, untrusted=True)
     node1 = basectx.node()
     node2 = ctx.node()
     parity = paritygen(stripecount)
 
     diffhunks = patch.diffhunks(repo, node1, node2, m, opts=diffopts)
     for blockno, (fctx1, fctx2, header, hunks) in enumerate(diffhunks, 1):
         if style != 'raw':
             header = header[1:]
         lines = [h + '\n' for h in header]
         for hunkrange, hunklines in hunks:
             if linerange is not None and hunkrange is not None:
                 s1, l1, s2, l2 = hunkrange
                 if not mdiff.hunkinrange((s2, l2), linerange):
                     continue
             lines.extend(hunklines)
         if lines:
             l = templateutil.mappedgenerator(_prettyprintdifflines,
                                              args=(lines, blockno,
                                                    lineidprefix))
             yield {
                 'parity': next(parity),
                 'blockno': blockno,
                 'lines': l,
             }
 
 def diffs(web, ctx, basectx, files, style, linerange=None, lineidprefix=''):
     args = (web.repo, ctx, basectx, files, style, web.stripecount,
             linerange, lineidprefix)
     return templateutil.mappinggenerator(_diffsgen, args=args, name='diffblock')
 
 def _compline(type, leftlineno, leftline, rightlineno, rightline):
     lineid = leftlineno and ("l%d" % leftlineno) or ''
     lineid += rightlineno and ("r%d" % rightlineno) or ''
     llno = '%d' % leftlineno if leftlineno else ''
     rlno = '%d' % rightlineno if rightlineno else ''
     return {
         'type': type,
         'lineid': lineid,
         'leftlineno': leftlineno,
         'leftlinenumber': "% 6s" % llno,
         'leftline': leftline or '',
         'rightlineno': rightlineno,
         'rightlinenumber': "% 6s" % rlno,
         'rightline': rightline or '',
     }
 
 def _getcompblockgen(context, leftlines, rightlines, opcodes):
     for type, llo, lhi, rlo, rhi in opcodes:
         len1 = lhi - llo
         len2 = rhi - rlo
         count = min(len1, len2)
         for i in xrange(count):
             yield _compline(type=type,
                             leftlineno=llo + i + 1,
                             leftline=leftlines[llo + i],
                             rightlineno=rlo + i + 1,
                             rightline=rightlines[rlo + i])
         if len1 > len2:
             for i in xrange(llo + count, lhi):
                 yield _compline(type=type,
                                 leftlineno=i + 1,
                                 leftline=leftlines[i],
                                 rightlineno=None,
                                 rightline=None)
         elif len2 > len1:
             for i in xrange(rlo + count, rhi):
                 yield _compline(type=type,
                                 leftlineno=None,
                                 leftline=None,
                                 rightlineno=i + 1,
                                 rightline=rightlines[i])
 
 def _getcompblock(leftlines, rightlines, opcodes):
     args = (leftlines, rightlines, opcodes)
     return templateutil.mappinggenerator(_getcompblockgen, args=args,
                                          name='comparisonline')
 
 def _comparegen(context, contextnum, leftlines, rightlines):
     '''Generator function that provides side-by-side comparison data.'''
     s = difflib.SequenceMatcher(None, leftlines, rightlines)
     if contextnum < 0:
         l = _getcompblock(leftlines, rightlines, s.get_opcodes())
         yield {'lines': l}
     else:
         for oc in s.get_grouped_opcodes(n=contextnum):
             l = _getcompblock(leftlines, rightlines, oc)
             yield {'lines': l}
 
 def compare(contextnum, leftlines, rightlines):
     args = (contextnum, leftlines, rightlines)
     return templateutil.mappinggenerator(_comparegen, args=args,
                                          name='comparisonblock')
 
 def diffstatgen(ctx, basectx):
     '''Generator function that provides the diffstat data.'''
 
     stats = patch.diffstatdata(
         util.iterlines(ctx.diff(basectx, noprefix=False)))
     maxname, maxtotal, addtotal, removetotal, binary = patch.diffstatsum(stats)
     while True:
         yield stats, maxname, maxtotal, addtotal, removetotal, binary
 
 def diffsummary(statgen):
     '''Return a short summary of the diff.'''
 
     stats, maxname, maxtotal, addtotal, removetotal, binary = next(statgen)
     return _(' %d files changed, %d insertions(+), %d deletions(-)\n') % (
              len(stats), addtotal, removetotal)
 
 def _diffstattmplgen(context, ctx, statgen, parity):
     stats, maxname, maxtotal, addtotal, removetotal, binary = next(statgen)
     files = ctx.files()
 
     def pct(i):
         if maxtotal == 0:
             return 0
         return (float(i) / maxtotal) * 100
 
     fileno = 0
     for filename, adds, removes, isbinary in stats:
         template = 'diffstatlink' if filename in files else 'diffstatnolink'
         total = adds + removes
         fileno += 1
         yield context.process(template, {
             'node': ctx.hex(),
             'file': filename,
             'fileno': fileno,
             'total': total,
             'addpct': pct(adds),
             'removepct': pct(removes),
             'parity': next(parity),
         })
 
 def diffstat(ctx, statgen, parity):
     '''Return a diffstat template for each file in the diff.'''
     args = (ctx, statgen, parity)
     return templateutil.mappedgenerator(_diffstattmplgen, args=args)
 
 class sessionvars(templateutil.wrapped):
     def __init__(self, vars, start='?'):
         self._start = start
         self._vars = vars
 
     def __getitem__(self, key):
         return self._vars[key]
 
     def __setitem__(self, key, value):
         self._vars[key] = value
 
     def __copy__(self):
         return sessionvars(copy.copy(self._vars), self._start)
 
+    def contains(self, context, mapping, item):
+        item = templateutil.unwrapvalue(context, mapping, item)
+        return item in self._vars
+
     def getmember(self, context, mapping, key):
         key = templateutil.unwrapvalue(context, mapping, key)
         return self._vars.get(key)
 
     def getmin(self, context, mapping):
         raise error.ParseError(_('not comparable'))
 
     def getmax(self, context, mapping):
         raise error.ParseError(_('not comparable'))
 
     def itermaps(self, context):
         separator = self._start
         for key, value in sorted(self._vars.iteritems()):
             yield {'name': key,
                    'value': pycompat.bytestr(value),
                    'separator': separator,
             }
             separator = '&'
 
     def join(self, context, mapping, sep):
         # could be '{separator}{name}={value|urlescape}'
         raise error.ParseError(_('not displayable without template'))
 
     def show(self, context, mapping):
         return self.join(context, '')
 
     def tovalue(self, context, mapping):
         return self._vars
 
 class wsgiui(uimod.ui):
     # default termwidth breaks under mod_wsgi
     def termwidth(self):
         return 80
 
 def getwebsubs(repo):
     websubtable = []
     websubdefs = repo.ui.configitems('websub')
     # we must maintain interhg backwards compatibility
     websubdefs += repo.ui.configitems('interhg')
     for key, pattern in websubdefs:
         # grab the delimiter from the character after the "s"
         unesc = pattern[1:2]
         delim = re.escape(unesc)
 
         # identify portions of the pattern, taking care to avoid escaped
         # delimiters. the replace format and flags are optional, but
         # delimiters are required.
         match = re.match(
             br'^s%s(.+)(?:(?<=\\\\)|(?<!\\))%s(.*)%s([ilmsux])*$'
             % (delim, delim, delim), pattern)
         if not match:
             repo.ui.warn(_("websub: invalid pattern for %s: %s\n")
                               % (key, pattern))
             continue
 
         # we need to unescape the delimiter for regexp and format
         delim_re = re.compile(br'(?<!\\)\\%s' % delim)
         regexp = delim_re.sub(unesc, match.group(1))
         format = delim_re.sub(unesc, match.group(2))
 
         # the pattern allows for 6 regexp flags, so set them if necessary
         flagin = match.group(3)
         flags = 0
         if flagin:
             for flag in flagin.upper():
                 flags |= re.__dict__[flag]
 
         try:
             regexp = re.compile(regexp, flags)
             websubtable.append((regexp, format))
         except re.error:
             repo.ui.warn(_("websub: invalid regexp for %s: %s\n")
                          % (key, regexp))
     return websubtable
 
 def getgraphnode(repo, ctx):
     return (templatekw.getgraphnodecurrent(repo, ctx) +
             templatekw.getgraphnodesymbol(ctx))

mercurial/templatefuncs.py

@@ -1,701 +1,698 b''
 # templatefuncs.py - common template functions
 #
 # Copyright 2005, 2006 Matt Mackall <[e-mail]>
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 from __future__ import absolute_import
 
 import re
 
 from .i18n import _
 from .node import (
     bin,
     wdirid,
 )
 from . import (
     color,
     encoding,
     error,
     minirst,
     obsutil,
     registrar,
     revset as revsetmod,
     revsetlang,
     scmutil,
     templatefilters,
     templatekw,
     templateutil,
     util,
 )
 from .utils import (
     dateutil,
     stringutil,
 )
 
 evalrawexp = templateutil.evalrawexp
 evalwrapped = templateutil.evalwrapped
 evalfuncarg = templateutil.evalfuncarg
 evalboolean = templateutil.evalboolean
 evaldate = templateutil.evaldate
 evalinteger = templateutil.evalinteger
 evalstring = templateutil.evalstring
 evalstringliteral = templateutil.evalstringliteral
 
 # dict of template built-in functions
 funcs = {}
 templatefunc = registrar.templatefunc(funcs)
 
 @templatefunc('date(date[, fmt])')
 def date(context, mapping, args):
     """Format a date. See :hg:`help dates` for formatting
     strings. The default is a Unix date format, including the timezone:
     "Mon Sep 04 15:13:13 2006 0700"."""
     if not (1 <= len(args) <= 2):
         # i18n: "date" is a keyword
         raise error.ParseError(_("date expects one or two arguments"))
 
     date = evaldate(context, mapping, args[0],
                     # i18n: "date" is a keyword
                     _("date expects a date information"))
     fmt = None
     if len(args) == 2:
         fmt = evalstring(context, mapping, args[1])
     if fmt is None:
         return dateutil.datestr(date)
     else:
         return dateutil.datestr(date, fmt)
 
 @templatefunc('dict([[key=]value...])', argspec='*args **kwargs')
 def dict_(context, mapping, args):
     """Construct a dict from key-value pairs. A key may be omitted if
     a value expression can provide an unambiguous name."""
     data = util.sortdict()
 
     for v in args['args']:
         k = templateutil.findsymbolicname(v)
         if not k:
             raise error.ParseError(_('dict key cannot be inferred'))
         if k in data or k in args['kwargs']:
             raise error.ParseError(_("duplicated dict key '%s' inferred") % k)
         data[k] = evalfuncarg(context, mapping, v)
 
     data.update((k, evalfuncarg(context, mapping, v))
                 for k, v in args['kwargs'].iteritems())
     return templateutil.hybriddict(data)
 
 @templatefunc('diff([includepattern [, excludepattern]])')
 def diff(context, mapping, args):
     """Show a diff, optionally
     specifying files to include or exclude."""
     if len(args) > 2:
         # i18n: "diff" is a keyword
         raise error.ParseError(_("diff expects zero, one, or two arguments"))
 
     def getpatterns(i):
         if i < len(args):
             s = evalstring(context, mapping, args[i]).strip()
             if s:
                 return [s]
         return []
 
     ctx = context.resource(mapping, 'ctx')
     chunks = ctx.diff(match=ctx.match([], getpatterns(0), getpatterns(1)))
 
     return ''.join(chunks)
 
 @templatefunc('extdata(source)', argspec='source')
 def extdata(context, mapping, args):
     """Show a text read from the specified extdata source. (EXPERIMENTAL)"""
     if 'source' not in args:
         # i18n: "extdata" is a keyword
         raise error.ParseError(_('extdata expects one argument'))
 
     source = evalstring(context, mapping, args['source'])
     if not source:
         sym = templateutil.findsymbolicname(args['source'])
         if sym:
             raise error.ParseError(_('empty data source specified'),
                                    hint=_("did you mean extdata('%s')?") % sym)
         else:
             raise error.ParseError(_('empty data source specified'))
     cache = context.resource(mapping, 'cache').setdefault('extdata', {})
     ctx = context.resource(mapping, 'ctx')
     if source in cache:
         data = cache[source]
     else:
         data = cache[source] = scmutil.extdatasource(ctx.repo(), source)
     return data.get(ctx.rev(), '')
 
 @templatefunc('files(pattern)')
 def files(context, mapping, args):
     """All files of the current changeset matching the pattern. See
     :hg:`help patterns`."""
     if not len(args) == 1:
         # i18n: "files" is a keyword
         raise error.ParseError(_("files expects one argument"))
 
     raw = evalstring(context, mapping, args[0])
     ctx = context.resource(mapping, 'ctx')
     m = ctx.match([raw])
     files = list(ctx.matches(m))
     return templateutil.compatlist(context, mapping, "file", files)
 
 @templatefunc('fill(text[, width[, initialident[, hangindent]]])')
 def fill(context, mapping, args):
     """Fill many
     paragraphs with optional indentation. See the "fill" filter."""
     if not (1 <= len(args) <= 4):
         # i18n: "fill" is a keyword
         raise error.ParseError(_("fill expects one to four arguments"))
 
     text = evalstring(context, mapping, args[0])
     width = 76
     initindent = ''
     hangindent = ''
     if 2 <= len(args) <= 4:
         width = evalinteger(context, mapping, args[1],
                             # i18n: "fill" is a keyword
                             _("fill expects an integer width"))
         try:
             initindent = evalstring(context, mapping, args[2])
             hangindent = evalstring(context, mapping, args[3])
         except IndexError:
             pass
 
     return templatefilters.fill(text, width, initindent, hangindent)
 
 @templatefunc('formatnode(node)')
 def formatnode(context, mapping, args):
     """Obtain the preferred form of a changeset hash. (DEPRECATED)"""
     if len(args) != 1:
         # i18n: "formatnode" is a keyword
         raise error.ParseError(_("formatnode expects one argument"))
 
     ui = context.resource(mapping, 'ui')
     node = evalstring(context, mapping, args[0])
     if ui.debugflag:
         return node
     return templatefilters.short(node)
 
 @templatefunc('mailmap(author)')
 def mailmap(context, mapping, args):
     """Return the author, updated according to the value
     set in the .mailmap file"""
     if len(args) != 1:
         raise error.ParseError(_("mailmap expects one argument"))
 
     author = evalstring(context, mapping, args[0])
 
     cache = context.resource(mapping, 'cache')
     repo = context.resource(mapping, 'repo')
 
     if 'mailmap' not in cache:
         data = repo.wvfs.tryread('.mailmap')
         cache['mailmap'] = stringutil.parsemailmap(data)
 
     return stringutil.mapname(cache['mailmap'], author)
 
 @templatefunc('pad(text, width[, fillchar=\' \'[, left=False]])',
               argspec='text width fillchar left')
 def pad(context, mapping, args):
     """Pad text with a
     fill character."""
     if 'text' not in args or 'width' not in args:
         # i18n: "pad" is a keyword
         raise error.ParseError(_("pad() expects two to four arguments"))
 
     width = evalinteger(context, mapping, args['width'],
                         # i18n: "pad" is a keyword
                         _("pad() expects an integer width"))
 
     text = evalstring(context, mapping, args['text'])
 
     left = False
     fillchar = ' '
     if 'fillchar' in args:
         fillchar = evalstring(context, mapping, args['fillchar'])
         if len(color.stripeffects(fillchar)) != 1:
             # i18n: "pad" is a keyword
             raise error.ParseError(_("pad() expects a single fill character"))
     if 'left' in args:
         left = evalboolean(context, mapping, args['left'])
 
     fillwidth = width - encoding.colwidth(color.stripeffects(text))
     if fillwidth <= 0:
         return text
     if left:
         return fillchar * fillwidth + text
     else:
         return text + fillchar * fillwidth
 
 @templatefunc('indent(text, indentchars[, firstline])')
 def indent(context, mapping, args):
     """Indents all non-empty lines
     with the characters given in the indentchars string. An optional
     third parameter will override the indent for the first line only
     if present."""
     if not (2 <= len(args) <= 3):
         # i18n: "indent" is a keyword
         raise error.ParseError(_("indent() expects two or three arguments"))
 
     text = evalstring(context, mapping, args[0])
     indent = evalstring(context, mapping, args[1])
 
     if len(args) == 3:
         firstline = evalstring(context, mapping, args[2])
     else:
         firstline = indent
 
     # the indent function doesn't indent the first line, so we do it here
     return templatefilters.indent(firstline + text, indent)
 
 @templatefunc('get(dict, key)')
 def get(context, mapping, args):
     """Get an attribute/key from an object. Some keywords
     are complex types. This function allows you to obtain the value of an
     attribute on these types."""
     if len(args) != 2:
         # i18n: "get" is a keyword
         raise error.ParseError(_("get() expects two arguments"))
 
     dictarg = evalwrapped(context, mapping, args[0])
     key = evalrawexp(context, mapping, args[1])
     try:
         return dictarg.getmember(context, mapping, key)
     except error.ParseError as err:
         # i18n: "get" is a keyword
         hint = _("get() expects a dict as first argument")
         raise error.ParseError(bytes(err), hint=hint)
 
 @templatefunc('if(expr, then[, else])')
 def if_(context, mapping, args):
     """Conditionally execute based on the result of
     an expression."""
     if not (2 <= len(args) <= 3):
         # i18n: "if" is a keyword
         raise error.ParseError(_("if expects two or three arguments"))
 
     test = evalboolean(context, mapping, args[0])
     if test:
         return evalrawexp(context, mapping, args[1])
     elif len(args) == 3:
         return evalrawexp(context, mapping, args[2])
 
 @templatefunc('ifcontains(needle, haystack, then[, else])')
 def ifcontains(context, mapping, args):
     """Conditionally execute based
     on whether the item "needle" is in "haystack"."""
     if not (3 <= len(args) <= 4):
         # i18n: "ifcontains" is a keyword
         raise error.ParseError(_("ifcontains expects three or four arguments"))
 
-    haystack = evalfuncarg(context, mapping, args[1])
-    keytype = getattr(haystack, 'keytype', None)
+    haystack = evalwrapped(context, mapping, args[1])
     try:
         needle = evalrawexp(context, mapping, args[0])
-        needle = templateutil.unwrapastype(context, mapping, needle,
-                                           keytype or bytes)
-        found = (needle in haystack)
+        found = haystack.contains(context, mapping, needle)
     except error.ParseError:
         found = False
 
     if found:
         return evalrawexp(context, mapping, args[2])
     elif len(args) == 4:
         return evalrawexp(context, mapping, args[3])
 
 @templatefunc('ifeq(expr1, expr2, then[, else])')
 def ifeq(context, mapping, args):
     """Conditionally execute based on
     whether 2 items are equivalent."""
     if not (3 <= len(args) <= 4):
         # i18n: "ifeq" is a keyword
         raise error.ParseError(_("ifeq expects three or four arguments"))
 
     test = evalstring(context, mapping, args[0])
     match = evalstring(context, mapping, args[1])
     if test == match:
         return evalrawexp(context, mapping, args[2])
     elif len(args) == 4:
         return evalrawexp(context, mapping, args[3])
 
 @templatefunc('join(list, sep)')
 def join(context, mapping, args):
     """Join items in a list with a delimiter."""
     if not (1 <= len(args) <= 2):
         # i18n: "join" is a keyword
         raise error.ParseError(_("join expects one or two arguments"))
 
     joinset = evalwrapped(context, mapping, args[0])
     joiner = " "
     if len(args) > 1:
         joiner = evalstring(context, mapping, args[1])
     return joinset.join(context, mapping, joiner)
 
 @templatefunc('label(label, expr)')
 def label(context, mapping, args):
     """Apply a label to generated content. Content with
     a label applied can result in additional post-processing, such as
     automatic colorization."""
     if len(args) != 2:
         # i18n: "label" is a keyword
         raise error.ParseError(_("label expects two arguments"))
 
     ui = context.resource(mapping, 'ui')
     thing = evalstring(context, mapping, args[1])
     # preserve unknown symbol as literal so effects like 'red', 'bold',
     # etc. don't need to be quoted
     label = evalstringliteral(context, mapping, args[0])
 
     return ui.label(thing, label)
 
 @templatefunc('latesttag([pattern])')
 def latesttag(context, mapping, args):
     """The global tags matching the given pattern on the
     most recent globally tagged ancestor of this changeset.
     If no such tags exist, the "{tag}" template resolves to
     the string "null". See :hg:`help revisions.patterns` for the pattern
     syntax.
     """
     if len(args) > 1:
         # i18n: "latesttag" is a keyword
         raise error.ParseError(_("latesttag expects at most one argument"))
 
     pattern = None
     if len(args) == 1:
         pattern = evalstring(context, mapping, args[0])
     return templatekw.showlatesttags(context, mapping, pattern)
 
 @templatefunc('localdate(date[, tz])')
 def localdate(context, mapping, args):
     """Converts a date to the specified timezone.
     The default is local date."""
     if not (1 <= len(args) <= 2):
         # i18n: "localdate" is a keyword
         raise error.ParseError(_("localdate expects one or two arguments"))
 
     date = evaldate(context, mapping, args[0],
                     # i18n: "localdate" is a keyword
                     _("localdate expects a date information"))
     if len(args) >= 2:
         tzoffset = None
         tz = evalfuncarg(context, mapping, args[1])
         if isinstance(tz, bytes):
             tzoffset, remainder = dateutil.parsetimezone(tz)
             if remainder:
                 tzoffset = None
         if tzoffset is None:
             try:
                 tzoffset = int(tz)
             except (TypeError, ValueError):
                 # i18n: "localdate" is a keyword
                 raise error.ParseError(_("localdate expects a timezone"))
     else:
         tzoffset = dateutil.makedate()[1]
     return (date[0], tzoffset)
 
 @templatefunc('max(iterable)')
 def max_(context, mapping, args, **kwargs):
     """Return the max of an iterable"""
     if len(args) != 1:
         # i18n: "max" is a keyword
         raise error.ParseError(_("max expects one argument"))
 
     iterable = evalwrapped(context, mapping, args[0])
     try:
         return iterable.getmax(context, mapping)
     except error.ParseError as err:
         # i18n: "max" is a keyword
         hint = _("max first argument should be an iterable")
         raise error.ParseError(bytes(err), hint=hint)
 
 @templatefunc('min(iterable)')
 def min_(context, mapping, args, **kwargs):
     """Return the min of an iterable"""
     if len(args) != 1:
         # i18n: "min" is a keyword
         raise error.ParseError(_("min expects one argument"))
 
     iterable = evalwrapped(context, mapping, args[0])
     try:
         return iterable.getmin(context, mapping)
     except error.ParseError as err:
         # i18n: "min" is a keyword
         hint = _("min first argument should be an iterable")
         raise error.ParseError(bytes(err), hint=hint)
 
 @templatefunc('mod(a, b)')
 def mod(context, mapping, args):
     """Calculate a mod b such that a / b + a mod b == a"""
     if not len(args) == 2:
         # i18n: "mod" is a keyword
         raise error.ParseError(_("mod expects two arguments"))
 
     func = lambda a, b: a % b
     return templateutil.runarithmetic(context, mapping,
                                       (func, args[0], args[1]))
 
 @templatefunc('obsfateoperations(markers)')
 def obsfateoperations(context, mapping, args):
     """Compute obsfate related information based on markers (EXPERIMENTAL)"""
     if len(args) != 1:
         # i18n: "obsfateoperations" is a keyword
         raise error.ParseError(_("obsfateoperations expects one argument"))
 
     markers = evalfuncarg(context, mapping, args[0])
 
     try:
         data = obsutil.markersoperations(markers)
         return templateutil.hybridlist(data, name='operation')
     except (TypeError, KeyError):
         # i18n: "obsfateoperations" is a keyword
         errmsg = _("obsfateoperations first argument should be an iterable")
         raise error.ParseError(errmsg)
 
 @templatefunc('obsfatedate(markers)')
 def obsfatedate(context, mapping, args):
     """Compute obsfate related information based on markers (EXPERIMENTAL)"""
     if len(args) != 1:
         # i18n: "obsfatedate" is a keyword
         raise error.ParseError(_("obsfatedate expects one argument"))
 
     markers = evalfuncarg(context, mapping, args[0])
 
     try:
         data = obsutil.markersdates(markers)
         return templateutil.hybridlist(data, name='date', fmt='%d %d')
     except (TypeError, KeyError):
         # i18n: "obsfatedate" is a keyword
         errmsg = _("obsfatedate first argument should be an iterable")
         raise error.ParseError(errmsg)
 
 @templatefunc('obsfateusers(markers)')
 def obsfateusers(context, mapping, args):
     """Compute obsfate related information based on markers (EXPERIMENTAL)"""
     if len(args) != 1:
         # i18n: "obsfateusers" is a keyword
         raise error.ParseError(_("obsfateusers expects one argument"))
 
     markers = evalfuncarg(context, mapping, args[0])
 
     try:
         data = obsutil.markersusers(markers)
         return templateutil.hybridlist(data, name='user')
     except (TypeError, KeyError, ValueError):
         # i18n: "obsfateusers" is a keyword
         msg = _("obsfateusers first argument should be an iterable of "
                 "obsmakers")
         raise error.ParseError(msg)
 
 @templatefunc('obsfateverb(successors, markers)')
 def obsfateverb(context, mapping, args):
     """Compute obsfate related information based on successors (EXPERIMENTAL)"""
     if len(args) != 2:
         # i18n: "obsfateverb" is a keyword
         raise error.ParseError(_("obsfateverb expects two arguments"))
 
     successors = evalfuncarg(context, mapping, args[0])
     markers = evalfuncarg(context, mapping, args[1])
 
     try:
         return obsutil.obsfateverb(successors, markers)
     except TypeError:
         # i18n: "obsfateverb" is a keyword
         errmsg = _("obsfateverb first argument should be countable")
         raise error.ParseError(errmsg)
 
 @templatefunc('relpath(path)')
 def relpath(context, mapping, args):
     """Convert a repository-absolute path into a filesystem path relative to
     the current working directory."""
     if len(args) != 1:
         # i18n: "relpath" is a keyword
         raise error.ParseError(_("relpath expects one argument"))
 
     repo = context.resource(mapping, 'ctx').repo()
     path = evalstring(context, mapping, args[0])
     return repo.pathto(path)
 
 @templatefunc('revset(query[, formatargs...])')
 def revset(context, mapping, args):
     """Execute a revision set query. See
     :hg:`help revset`."""
     if not len(args) > 0:
         # i18n: "revset" is a keyword
         raise error.ParseError(_("revset expects one or more arguments"))
 
     raw = evalstring(context, mapping, args[0])
     ctx = context.resource(mapping, 'ctx')
     repo = ctx.repo()
 
     def query(expr):
         m = revsetmod.match(repo.ui, expr, lookup=revsetmod.lookupfn(repo))
         return m(repo)
 
     if len(args) > 1:
         formatargs = [evalfuncarg(context, mapping, a) for a in args[1:]]
         revs = query(revsetlang.formatspec(raw, *formatargs))
         revs = list(revs)
     else:
         cache = context.resource(mapping, 'cache')
         revsetcache = cache.setdefault("revsetcache", {})
         if raw in revsetcache:
             revs = revsetcache[raw]
         else:
             revs = query(raw)
             revs = list(revs)
             revsetcache[raw] = revs
     return templatekw.showrevslist(context, mapping, "revision", revs)
 
 @templatefunc('rstdoc(text, style)')
 def rstdoc(context, mapping, args):
     """Format reStructuredText."""
     if len(args) != 2:
         # i18n: "rstdoc" is a keyword
         raise error.ParseError(_("rstdoc expects two arguments"))
 
     text = evalstring(context, mapping, args[0])
     style = evalstring(context, mapping, args[1])
 
     return minirst.format(text, style=style, keep=['verbose'])[0]
 
 @templatefunc('separate(sep, args...)', argspec='sep *args')
 def separate(context, mapping, args):
     """Add a separator between non-empty arguments."""
     if 'sep' not in args:
         # i18n: "separate" is a keyword
         raise error.ParseError(_("separate expects at least one argument"))
 
     sep = evalstring(context, mapping, args['sep'])
     first = True
     for arg in args['args']:
         argstr = evalstring(context, mapping, arg)
         if not argstr:
             continue
         if first:
             first = False
         else:
             yield sep
         yield argstr
 
 @templatefunc('shortest(node, minlength=4)')
 def shortest(context, mapping, args):
     """Obtain the shortest representation of
     a node."""
     if not (1 <= len(args) <= 2):
         # i18n: "shortest" is a keyword
         raise error.ParseError(_("shortest() expects one or two arguments"))
 
     hexnode = evalstring(context, mapping, args[0])
 
     minlength = 4
     if len(args) > 1:
         minlength = evalinteger(context, mapping, args[1],
                                 # i18n: "shortest" is a keyword
                                 _("shortest() expects an integer minlength"))
 
     repo = context.resource(mapping, 'ctx')._repo
     if len(hexnode) > 40:
         return hexnode
     elif len(hexnode) == 40:
         try:
             node = bin(hexnode)
         except TypeError:
             return hexnode
     else:
         try:
             node = scmutil.resolvehexnodeidprefix(repo, hexnode)
         except error.WdirUnsupported:
             node = wdirid
         except error.LookupError:
             return hexnode
         if not node:
             return hexnode
     try:
         return scmutil.shortesthexnodeidprefix(repo, node, minlength)
     except error.RepoLookupError:
         return hexnode
 
 @templatefunc('strip(text[, chars])')
 def strip(context, mapping, args):
     """Strip characters from a string. By default,
     strips all leading and trailing whitespace."""
     if not (1 <= len(args) <= 2):
         # i18n: "strip" is a keyword
         raise error.ParseError(_("strip expects one or two arguments"))
 
     text = evalstring(context, mapping, args[0])
     if len(args) == 2:
         chars = evalstring(context, mapping, args[1])
         return text.strip(chars)
     return text.strip()
 
 @templatefunc('sub(pattern, replacement, expression)')
 def sub(context, mapping, args):
     """Perform text substitution
     using regular expressions."""
     if len(args) != 3:
         # i18n: "sub" is a keyword
         raise error.ParseError(_("sub expects three arguments"))
 
     pat = evalstring(context, mapping, args[0])
     rpl = evalstring(context, mapping, args[1])
     src = evalstring(context, mapping, args[2])
     try:
         patre = re.compile(pat)
     except re.error:
         # i18n: "sub" is a keyword
         raise error.ParseError(_("sub got an invalid pattern: %s") % pat)
     try:
         yield patre.sub(rpl, src)
     except re.error:
         # i18n: "sub" is a keyword
         raise error.ParseError(_("sub got an invalid replacement: %s") % rpl)
 
 @templatefunc('startswith(pattern, text)')
 def startswith(context, mapping, args):
     """Returns the value from the "text" argument
     if it begins with the content from the "pattern" argument."""
     if len(args) != 2:
         # i18n: "startswith" is a keyword
         raise error.ParseError(_("startswith expects two arguments"))
 
     patn = evalstring(context, mapping, args[0])
     text = evalstring(context, mapping, args[1])
     if text.startswith(patn):
         return text
     return ''
 
 @templatefunc('word(number, text[, separator])')
 def word(context, mapping, args):
     """Return the nth word from a string."""
     if not (2 <= len(args) <= 3):
         # i18n: "word" is a keyword
         raise error.ParseError(_("word expects two or three arguments, got %d")
                                % len(args))
 
     num = evalinteger(context, mapping, args[0],
                       # i18n: "word" is a keyword
                       _("word expects an integer index"))
     text = evalstring(context, mapping, args[1])
     if len(args) == 3:
         splitter = evalstring(context, mapping, args[2])
     else:
         splitter = None
 
     tokens = text.split(splitter)
     if num >= len(tokens) or num < -len(tokens):
         return ''
     else:
         return tokens[num]
 
 def loadfunction(ui, extname, registrarobj):
     """Load template function from specified registrarobj
     """
     for name, func in registrarobj._table.iteritems():
         funcs[name] = func
 
 # tell hggettext to extract docstrings from these functions:
 i18nfunctions = funcs.values()

mercurial/templateutil.py

@@ -1,794 +1,823 b''
 # templateutil.py - utility for template evaluation
 #
 # Copyright 2005, 2006 Matt Mackall <[e-mail]>
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 from __future__ import absolute_import
 
 import abc
 import types
 
 from .i18n import _
 from . import (
     error,
     pycompat,
     util,
 )
 from .utils import (
     dateutil,
     stringutil,
 )
 
 class ResourceUnavailable(error.Abort):
     pass
 
 class TemplateNotFound(error.Abort):
     pass
 
 class wrapped(object):
     """Object requiring extra conversion prior to displaying or processing
     as value
 
     Use unwrapvalue(), unwrapastype(), or unwraphybrid() to obtain the inner
     object.
     """
 
     __metaclass__ = abc.ABCMeta
 
     @abc.abstractmethod
+    def contains(self, context, mapping, item):
+        """Test if the specified item is in self
+
+        The item argument may be a wrapped object.
+        """
+
+    @abc.abstractmethod
     def getmember(self, context, mapping, key):
         """Return a member item for the specified key
 
         The key argument may be a wrapped object.
         A returned object may be either a wrapped object or a pure value
         depending on the self type.
         """
 
     @abc.abstractmethod
     def getmin(self, context, mapping):
         """Return the smallest item, which may be either a wrapped or a pure
         value depending on the self type"""
 
     @abc.abstractmethod
     def getmax(self, context, mapping):
         """Return the largest item, which may be either a wrapped or a pure
         value depending on the self type"""
 
     @abc.abstractmethod
     def itermaps(self, context):
         """Yield each template mapping"""
 
     @abc.abstractmethod
     def join(self, context, mapping, sep):
         """Join items with the separator; Returns a bytes or (possibly nested)
         generator of bytes
 
         A pre-configured template may be rendered per item if this container
         holds unprintable items.
         """
 
     @abc.abstractmethod
     def show(self, context, mapping):
         """Return a bytes or (possibly nested) generator of bytes representing
         the underlying object
 
         A pre-configured template may be rendered if the underlying object is
         not printable.
         """
 
     @abc.abstractmethod
     def tovalue(self, context, mapping):
         """Move the inner value object out or create a value representation
 
         A returned value must be serializable by templaterfilters.json().
         """
 
 class wrappedbytes(wrapped):
     """Wrapper for byte string"""
 
     def __init__(self, value):
         self._value = value
 
+    def contains(self, context, mapping, item):
+        item = stringify(context, mapping, item)
+        return item in self._value
+
     def getmember(self, context, mapping, key):
         raise error.ParseError(_('%r is not a dictionary')
                                % pycompat.bytestr(self._value))
 
     def getmin(self, context, mapping):
         return self._getby(context, mapping, min)
 
     def getmax(self, context, mapping):
         return self._getby(context, mapping, max)
 
     def _getby(self, context, mapping, func):
         if not self._value:
             raise error.ParseError(_('empty string'))
         return func(pycompat.iterbytestr(self._value))
 
     def itermaps(self, context):
         raise error.ParseError(_('%r is not iterable of mappings')
                                % pycompat.bytestr(self._value))
 
     def join(self, context, mapping, sep):
         return joinitems(pycompat.iterbytestr(self._value), sep)
 
     def show(self, context, mapping):
         return self._value
 
     def tovalue(self, context, mapping):
         return self._value
 
 class wrappedvalue(wrapped):
     """Generic wrapper for pure non-list/dict/bytes value"""
 
     def __init__(self, value):
         self._value = value
 
+    def contains(self, context, mapping, item):
+        raise error.ParseError(_("%r is not iterable") % self._value)
+
     def getmember(self, context, mapping, key):
         raise error.ParseError(_('%r is not a dictionary') % self._value)
 
     def getmin(self, context, mapping):
         raise error.ParseError(_("%r is not iterable") % self._value)
 
     def getmax(self, context, mapping):
         raise error.ParseError(_("%r is not iterable") % self._value)
 
     def itermaps(self, context):
         raise error.ParseError(_('%r is not iterable of mappings')
                                % self._value)
 
     def join(self, context, mapping, sep):
         raise error.ParseError(_('%r is not iterable') % self._value)
 
     def show(self, context, mapping):
         return pycompat.bytestr(self._value)
 
     def tovalue(self, context, mapping):
         return self._value
 
 # stub for representing a date type; may be a real date type that can
 # provide a readable string value
 class date(object):
     pass
 
 class hybrid(wrapped):
     """Wrapper for list or dict to support legacy template
 
     This class allows us to handle both:
     - "{files}" (legacy command-line-specific list hack) and
     - "{files % '{file}\n'}" (hgweb-style with inlining and function support)
     and to access raw values:
     - "{ifcontains(file, files, ...)}", "{ifcontains(key, extras, ...)}"
     - "{get(extras, key)}"
     - "{files|json}"
     """
 
     def __init__(self, gen, values, makemap, joinfmt, keytype=None):
         self._gen = gen  # generator or function returning generator
         self._values = values
         self._makemap = makemap
         self._joinfmt = joinfmt
         self.keytype = keytype  # hint for 'x in y' where type(x) is unresolved
 
+    def contains(self, context, mapping, item):
+        item = unwrapastype(context, mapping, item, self.keytype)
+        return item in self._values
+
     def getmember(self, context, mapping, key):
         # TODO: maybe split hybrid list/dict types?
         if not util.safehasattr(self._values, 'get'):
             raise error.ParseError(_('not a dictionary'))
         key = unwrapastype(context, mapping, key, self.keytype)
         return self._wrapvalue(key, self._values.get(key))
 
     def getmin(self, context, mapping):
         return self._getby(context, mapping, min)
 
     def getmax(self, context, mapping):
         return self._getby(context, mapping, max)
 
     def _getby(self, context, mapping, func):
         if not self._values:
             raise error.ParseError(_('empty sequence'))
         val = func(self._values)
         return self._wrapvalue(val, val)
 
     def _wrapvalue(self, key, val):
         if val is None:
             return
         if util.safehasattr(val, '_makemap'):
             # a nested hybrid list/dict, which has its own way of map operation
             return val
         return mappable(None, key, val, self._makemap)
 
     def itermaps(self, context):
         makemap = self._makemap
         for x in self._values:
             yield makemap(x)
 
     def join(self, context, mapping, sep):
         # TODO: switch gen to (context, mapping) API?
         return joinitems((self._joinfmt(x) for x in self._values), sep)
 
     def show(self, context, mapping):
         # TODO: switch gen to (context, mapping) API?
         gen = self._gen
         if gen is None:
             return self.join(context, mapping, ' ')
         if callable(gen):
             return gen()
         return gen
 
     def tovalue(self, context, mapping):
         # TODO: return self._values and get rid of proxy methods
         return self
 
     def __contains__(self, x):
         return x in self._values
     def __getitem__(self, key):
         return self._values[key]
     def __len__(self):
         return len(self._values)
     def __iter__(self):
         return iter(self._values)
     def __getattr__(self, name):
         if name not in (r'get', r'items', r'iteritems', r'iterkeys',
                         r'itervalues', r'keys', r'values'):
             raise AttributeError(name)
         return getattr(self._values, name)
 
 class mappable(wrapped):
     """Wrapper for non-list/dict object to support map operation
 
     This class allows us to handle both:
     - "{manifest}"
     - "{manifest % '{rev}:{node}'}"
     - "{manifest.rev}"
 
     Unlike a hybrid, this does not simulate the behavior of the underling
     value.
     """
 
     def __init__(self, gen, key, value, makemap):
         self._gen = gen  # generator or function returning generator
         self._key = key
         self._value = value  # may be generator of strings
         self._makemap = makemap
 
     def tomap(self):
         return self._makemap(self._key)
 
+    def contains(self, context, mapping, item):
+        w = makewrapped(context, mapping, self._value)
+        return w.contains(context, mapping, item)
+
     def getmember(self, context, mapping, key):
         w = makewrapped(context, mapping, self._value)
         return w.getmember(context, mapping, key)
 
     def getmin(self, context, mapping):
         w = makewrapped(context, mapping, self._value)
         return w.getmin(context, mapping)
 
     def getmax(self, context, mapping):
         w = makewrapped(context, mapping, self._value)
         return w.getmax(context, mapping)
 
     def itermaps(self, context):
         yield self.tomap()
 
     def join(self, context, mapping, sep):
         w = makewrapped(context, mapping, self._value)
         return w.join(context, mapping, sep)
 
     def show(self, context, mapping):
         # TODO: switch gen to (context, mapping) API?
         gen = self._gen
         if gen is None:
             return pycompat.bytestr(self._value)
         if callable(gen):
             return gen()
         return gen
 
     def tovalue(self, context, mapping):
         return _unthunk(context, mapping, self._value)
 
 class _mappingsequence(wrapped):
     """Wrapper for sequence of template mappings
 
     This represents an inner template structure (i.e. a list of dicts),
     which can also be rendered by the specified named/literal template.
 
     Template mappings may be nested.
     """
 
     def __init__(self, name=None, tmpl=None, sep=''):
         if name is not None and tmpl is not None:
             raise error.ProgrammingError('name and tmpl are mutually exclusive')
         self._name = name
         self._tmpl = tmpl
         self._defaultsep = sep
 
+    def contains(self, context, mapping, item):
+        raise error.ParseError(_('not comparable'))
+
     def getmember(self, context, mapping, key):
         raise error.ParseError(_('not a dictionary'))
 
     def getmin(self, context, mapping):
         raise error.ParseError(_('not comparable'))
 
     def getmax(self, context, mapping):
         raise error.ParseError(_('not comparable'))
 
     def join(self, context, mapping, sep):
         mapsiter = _iteroverlaymaps(context, mapping, self.itermaps(context))
         if self._name:
             itemiter = (context.process(self._name, m) for m in mapsiter)
         elif self._tmpl:
             itemiter = (context.expand(self._tmpl, m) for m in mapsiter)
         else:
             raise error.ParseError(_('not displayable without template'))
         return joinitems(itemiter, sep)
 
     def show(self, context, mapping):
         return self.join(context, mapping, self._defaultsep)
 
     def tovalue(self, context, mapping):
         knownres = context.knownresourcekeys()
         items = []
         for nm in self.itermaps(context):
             # drop internal resources (recursively) which shouldn't be displayed
             lm = context.overlaymap(mapping, nm)
             items.append({k: unwrapvalue(context, lm, v)
                           for k, v in nm.iteritems() if k not in knownres})
         return items
 
 class mappinggenerator(_mappingsequence):
     """Wrapper for generator of template mappings
 
     The function ``make(context, *args)`` should return a generator of
     mapping dicts.
     """
 
     def __init__(self, make, args=(), name=None, tmpl=None, sep=''):
         super(mappinggenerator, self).__init__(name, tmpl, sep)
         self._make = make
         self._args = args
 
     def itermaps(self, context):
         return self._make(context, *self._args)
 
 class mappinglist(_mappingsequence):
     """Wrapper for list of template mappings"""
 
     def __init__(self, mappings, name=None, tmpl=None, sep=''):
         super(mappinglist, self).__init__(name, tmpl, sep)
         self._mappings = mappings
 
     def itermaps(self, context):
         return iter(self._mappings)
 
 class mappedgenerator(wrapped):
     """Wrapper for generator of strings which acts as a list
 
     The function ``make(context, *args)`` should return a generator of
     byte strings, or a generator of (possibly nested) generators of byte
     strings (i.e. a generator for a list of byte strings.)
     """
 
     def __init__(self, make, args=()):
         self._make = make
         self._args = args
 
+    def contains(self, context, mapping, item):
+        item = stringify(context, mapping, item)
+        return item in self.tovalue(context, mapping)
+
     def _gen(self, context):
         return self._make(context, *self._args)
 
     def getmember(self, context, mapping, key):
         raise error.ParseError(_('not a dictionary'))
 
     def getmin(self, context, mapping):
         return self._getby(context, mapping, min)
 
     def getmax(self, context, mapping):
         return self._getby(context, mapping, max)
 
     def _getby(self, context, mapping, func):
         xs = self.tovalue(context, mapping)
         if not xs:
             raise error.ParseError(_('empty sequence'))
         return func(xs)
 
     def itermaps(self, context):
         raise error.ParseError(_('list of strings is not mappable'))
 
     def join(self, context, mapping, sep):
         return joinitems(self._gen(context), sep)
 
     def show(self, context, mapping):
         return self.join(context, mapping, '')
 
     def tovalue(self, context, mapping):
         return [stringify(context, mapping, x) for x in self._gen(context)]
 
 def hybriddict(data, key='key', value='value', fmt=None, gen=None):
     """Wrap data to support both dict-like and string-like operations"""
     prefmt = pycompat.identity
     if fmt is None:
         fmt = '%s=%s'
         prefmt = pycompat.bytestr
     return hybrid(gen, data, lambda k: {key: k, value: data[k]},
                   lambda k: fmt % (prefmt(k), prefmt(data[k])))
 
 def hybridlist(data, name, fmt=None, gen=None):
     """Wrap data to support both list-like and string-like operations"""
     prefmt = pycompat.identity
     if fmt is None:
         fmt = '%s'
         prefmt = pycompat.bytestr
     return hybrid(gen, data, lambda x: {name: x}, lambda x: fmt % prefmt(x))
 
 def unwraphybrid(context, mapping, thing):
     """Return an object which can be stringified possibly by using a legacy
     template"""
     if not isinstance(thing, wrapped):
         return thing
     return thing.show(context, mapping)
 
 def compatdict(context, mapping, name, data, key='key', value='value',
                fmt=None, plural=None, separator=' '):
     """Wrap data like hybriddict(), but also supports old-style list template
 
     This exists for backward compatibility with the old-style template. Use
     hybriddict() for new template keywords.
     """
     c = [{key: k, value: v} for k, v in data.iteritems()]
     f = _showcompatlist(context, mapping, name, c, plural, separator)
     return hybriddict(data, key=key, value=value, fmt=fmt, gen=f)
 
 def compatlist(context, mapping, name, data, element=None, fmt=None,
                plural=None, separator=' '):
     """Wrap data like hybridlist(), but also supports old-style list template
 
     This exists for backward compatibility with the old-style template. Use
     hybridlist() for new template keywords.
     """
     f = _showcompatlist(context, mapping, name, data, plural, separator)
     return hybridlist(data, name=element or name, fmt=fmt, gen=f)
 
 def _showcompatlist(context, mapping, name, values, plural=None, separator=' '):
     """Return a generator that renders old-style list template
 
     name is name of key in template map.
     values is list of strings or dicts.
     plural is plural of name, if not simply name + 's'.
     separator is used to join values as a string
 
     expansion works like this, given name 'foo'.
 
     if values is empty, expand 'no_foos'.
 
     if 'foo' not in template map, return values as a string,
     joined by 'separator'.
 
     expand 'start_foos'.
 
     for each value, expand 'foo'. if 'last_foo' in template
     map, expand it instead of 'foo' for last key.
 
     expand 'end_foos'.
     """
     if not plural:
         plural = name + 's'
     if not values:
         noname = 'no_' + plural
         if context.preload(noname):
             yield context.process(noname, mapping)
         return
     if not context.preload(name):
         if isinstance(values[0], bytes):
             yield separator.join(values)
         else:
             for v in values:
                 r = dict(v)
                 r.update(mapping)
                 yield r
         return
     startname = 'start_' + plural
     if context.preload(startname):
         yield context.process(startname, mapping)
     def one(v, tag=name):
         vmapping = {}
         try:
             vmapping.update(v)
         # Python 2 raises ValueError if the type of v is wrong. Python
         # 3 raises TypeError.
         except (AttributeError, TypeError, ValueError):
             try:
                 # Python 2 raises ValueError trying to destructure an e.g.
                 # bytes. Python 3 raises TypeError.
                 for a, b in v:
                     vmapping[a] = b
             except (TypeError, ValueError):
                 vmapping[name] = v
         vmapping = context.overlaymap(mapping, vmapping)
         return context.process(tag, vmapping)
     lastname = 'last_' + name
     if context.preload(lastname):
         last = values.pop()
     else:
         last = None
     for v in values:
         yield one(v)
     if last is not None:
         yield one(last, tag=lastname)
     endname = 'end_' + plural
     if context.preload(endname):
         yield context.process(endname, mapping)
 
 def flatten(context, mapping, thing):
     """Yield a single stream from a possibly nested set of iterators"""
     thing = unwraphybrid(context, mapping, thing)
     if isinstance(thing, bytes):
         yield thing
     elif isinstance(thing, str):
         # We can only hit this on Python 3, and it's here to guard
         # against infinite recursion.
         raise error.ProgrammingError('Mercurial IO including templates is done'
                                      ' with bytes, not strings, got %r' % thing)
     elif thing is None:
         pass
     elif not util.safehasattr(thing, '__iter__'):
         yield pycompat.bytestr(thing)
     else:
         for i in thing:
             i = unwraphybrid(context, mapping, i)
             if isinstance(i, bytes):
                 yield i
             elif i is None:
                 pass
             elif not util.safehasattr(i, '__iter__'):
                 yield pycompat.bytestr(i)
             else:
                 for j in flatten(context, mapping, i):
                     yield j
 
 def stringify(context, mapping, thing):
     """Turn values into bytes by converting into text and concatenating them"""
     if isinstance(thing, bytes):
         return thing  # retain localstr to be round-tripped
     return b''.join(flatten(context, mapping, thing))
 
 def findsymbolicname(arg):
     """Find symbolic name for the given compiled expression; returns None
     if nothing found reliably"""
     while True:
         func, data = arg
         if func is runsymbol:
             return data
         elif func is runfilter:
             arg = data[0]
         else:
             return None
 
 def _unthunk(context, mapping, thing):
     """Evaluate a lazy byte string into value"""
     if not isinstance(thing, types.GeneratorType):
         return thing
     return stringify(context, mapping, thing)
 
 def evalrawexp(context, mapping, arg):
     """Evaluate given argument as a bare template object which may require
     further processing (such as folding generator of strings)"""
     func, data = arg
     return func(context, mapping, data)
 
 def evalwrapped(context, mapping, arg):
     """Evaluate given argument to wrapped object"""
     thing = evalrawexp(context, mapping, arg)
     return makewrapped(context, mapping, thing)
 
 def makewrapped(context, mapping, thing):
     """Lift object to a wrapped type"""
     if isinstance(thing, wrapped):
         return thing
     thing = _unthunk(context, mapping, thing)
     if isinstance(thing, bytes):
         return wrappedbytes(thing)
     return wrappedvalue(thing)
 
 def evalfuncarg(context, mapping, arg):
     """Evaluate given argument as value type"""
     return unwrapvalue(context, mapping, evalrawexp(context, mapping, arg))
 
 def unwrapvalue(context, mapping, thing):
     """Move the inner value object out of the wrapper"""
     if isinstance(thing, wrapped):
         return thing.tovalue(context, mapping)
     # evalrawexp() may return string, generator of strings or arbitrary object
     # such as date tuple, but filter does not want generator.
     return _unthunk(context, mapping, thing)
 
 def evalboolean(context, mapping, arg):
     """Evaluate given argument as boolean, but also takes boolean literals"""
     func, data = arg
     if func is runsymbol:
         thing = func(context, mapping, data, default=None)
         if thing is None:
             # not a template keyword, takes as a boolean literal
             thing = stringutil.parsebool(data)
     else:
         thing = func(context, mapping, data)
     if isinstance(thing, wrapped):
         thing = thing.tovalue(context, mapping)
     if isinstance(thing, bool):
         return thing
     # other objects are evaluated as strings, which means 0 is True, but
     # empty dict/list should be False as they are expected to be ''
     return bool(stringify(context, mapping, thing))
 
 def evaldate(context, mapping, arg, err=None):
     """Evaluate given argument as a date tuple or a date string; returns
     a (unixtime, offset) tuple"""
     thing = evalrawexp(context, mapping, arg)
     return unwrapdate(context, mapping, thing, err)
 
 def unwrapdate(context, mapping, thing, err=None):
     thing = unwrapvalue(context, mapping, thing)
     try:
         return dateutil.parsedate(thing)
     except AttributeError:
         raise error.ParseError(err or _('not a date tuple nor a string'))
     except error.ParseError:
         if not err:
             raise
         raise error.ParseError(err)
 
 def evalinteger(context, mapping, arg, err=None):
     thing = evalrawexp(context, mapping, arg)
     return unwrapinteger(context, mapping, thing, err)
 
 def unwrapinteger(context, mapping, thing, err=None):
     thing = unwrapvalue(context, mapping, thing)
     try:
         return int(thing)
     except (TypeError, ValueError):
         raise error.ParseError(err or _('not an integer'))
 
 def evalstring(context, mapping, arg):
     return stringify(context, mapping, evalrawexp(context, mapping, arg))
 
 def evalstringliteral(context, mapping, arg):
     """Evaluate given argument as string template, but returns symbol name
     if it is unknown"""
     func, data = arg
     if func is runsymbol:
         thing = func(context, mapping, data, default=data)
     else:
         thing = func(context, mapping, data)
     return stringify(context, mapping, thing)
 
 _unwrapfuncbytype = {
     None: unwrapvalue,
     bytes: stringify,
     date: unwrapdate,
     int: unwrapinteger,
 }
 
 def unwrapastype(context, mapping, thing, typ):
     """Move the inner value object out of the wrapper and coerce its type"""
     try:
         f = _unwrapfuncbytype[typ]
     except KeyError:
         raise error.ProgrammingError('invalid type specified: %r' % typ)
     return f(context, mapping, thing)
 
 def runinteger(context, mapping, data):
     return int(data)
 
 def runstring(context, mapping, data):
     return data
 
 def _recursivesymbolblocker(key):
     def showrecursion(**args):
         raise error.Abort(_("recursive reference '%s' in template") % key)
     return showrecursion
 
 def runsymbol(context, mapping, key, default=''):
     v = context.symbol(mapping, key)
     if v is None:
         # put poison to cut recursion. we can't move this to parsing phase
         # because "x = {x}" is allowed if "x" is a keyword. (issue4758)
         safemapping = mapping.copy()
         safemapping[key] = _recursivesymbolblocker(key)
         try:
             v = context.process(key, safemapping)
         except TemplateNotFound:
             v = default
     if callable(v) and getattr(v, '_requires', None) is None:
         # old templatekw: expand all keywords and resources
         # (TODO: deprecate this after porting web template keywords to new API)
         props = {k: context._resources.lookup(context, mapping, k)
                  for k in context._resources.knownkeys()}
         # pass context to _showcompatlist() through templatekw._showlist()
         props['templ'] = context
         props.update(mapping)
         return v(**pycompat.strkwargs(props))
     if callable(v):
         # new templatekw
         try:
             return v(context, mapping)
         except ResourceUnavailable:
             # unsupported keyword is mapped to empty just like unknown keyword
             return None
     return v
 
 def runtemplate(context, mapping, template):
     for arg in template:
         yield evalrawexp(context, mapping, arg)
 
 def runfilter(context, mapping, data):
     arg, filt = data
     thing = evalrawexp(context, mapping, arg)
     intype = getattr(filt, '_intype', None)
     try:
         thing = unwrapastype(context, mapping, thing, intype)
         return filt(thing)
     except error.ParseError as e:
         raise error.ParseError(bytes(e), hint=_formatfiltererror(arg, filt))
 
 def _formatfiltererror(arg, filt):
     fn = pycompat.sysbytes(filt.__name__)
     sym = findsymbolicname(arg)
     if not sym:
         return _("incompatible use of template filter '%s'") % fn
     return (_("template filter '%s' is not compatible with keyword '%s'")
             % (fn, sym))
 
 def _iteroverlaymaps(context, origmapping, newmappings):
     """Generate combined mappings from the original mapping and an iterable
     of partial mappings to override the original"""
     for i, nm in enumerate(newmappings):
         lm = context.overlaymap(origmapping, nm)
         lm['index'] = i
         yield lm
 
 def _applymap(context, mapping, d, targ):
     for lm in _iteroverlaymaps(context, mapping, d.itermaps(context)):
         yield evalrawexp(context, lm, targ)
 
 def runmap(context, mapping, data):
     darg, targ = data
     d = evalwrapped(context, mapping, darg)
     return mappedgenerator(_applymap, args=(mapping, d, targ))
 
 def runmember(context, mapping, data):
     darg, memb = data
     d = evalwrapped(context, mapping, darg)
     if util.safehasattr(d, 'tomap'):
         lm = context.overlaymap(mapping, d.tomap())
         return runsymbol(context, lm, memb)
     try:
         return d.getmember(context, mapping, memb)
     except error.ParseError as err:
         sym = findsymbolicname(darg)
         if not sym:
             raise
         hint = _("keyword '%s' does not support member operation") % sym
         raise error.ParseError(bytes(err), hint=hint)
 
 def runnegate(context, mapping, data):
     data = evalinteger(context, mapping, data,
                        _('negation needs an integer argument'))
     return -data
 
 def runarithmetic(context, mapping, data):
     func, left, right = data
     left = evalinteger(context, mapping, left,
                        _('arithmetic only defined on integers'))
     right = evalinteger(context, mapping, right,
                         _('arithmetic only defined on integers'))
     try:
         return func(left, right)
     except ZeroDivisionError:
         raise error.Abort(_('division by zero is not defined'))
 
 def joinitems(itemiter, sep):
     """Join items with the separator; Returns generator of bytes"""
     first = True
     for x in itemiter:
         if first:
             first = False
         elif sep:
             yield sep
         yield x

tests/test-command-template.t

@@ -1,4958 +1,4967 b''
   $ hg init a
   $ cd a
   $ echo a > a
   $ hg add a
   $ echo line 1 > b
   $ echo line 2 >> b
   $ hg commit -l b -d '1000000 0' -u 'User Name <user@hostname>'
 
   $ hg add b
   $ echo other 1 > c
   $ echo other 2 >> c
   $ echo >> c
   $ echo other 3 >> c
   $ hg commit -l c -d '1100000 0' -u 'A. N. Other <other@place>'
 
   $ hg add c
   $ hg commit -m 'no person' -d '1200000 0' -u 'other@place'
   $ echo c >> c
   $ hg commit -m 'no user, no domain' -d '1300000 0' -u 'person'
 
   $ echo foo > .hg/branch
   $ hg commit -m 'new branch' -d '1400000 0' -u 'person'
 
   $ hg co -q 3
   $ echo other 4 >> d
   $ hg add d
   $ hg commit -m 'new head' -d '1500000 0' -u 'person'
 
   $ hg merge -q foo
   $ hg commit -m 'merge' -d '1500001 0' -u 'person'
 
 Test arithmetic operators have the right precedence:
 
   $ hg log -l 1 -T '{date(date, "%Y") + 5 * 10} {date(date, "%Y") - 2 * 3}\n'
   2020 1964
   $ hg log -l 1 -T '{date(date, "%Y") * 5 + 10} {date(date, "%Y") * 3 - 2}\n'
   9860 5908
 
 Test division:
 
   $ hg debugtemplate -r0 -v '{5 / 2} {mod(5, 2)}\n'
   (template
     (/
       (integer '5')
       (integer '2'))
     (string ' ')
     (func
       (symbol 'mod')
       (list
         (integer '5')
         (integer '2')))
     (string '\n'))
   2 1
   $ hg debugtemplate -r0 -v '{5 / -2} {mod(5, -2)}\n'
   (template
     (/
       (integer '5')
       (negate
         (integer '2')))
     (string ' ')
     (func
       (symbol 'mod')
       (list
         (integer '5')
         (negate
           (integer '2'))))
     (string '\n'))
   -3 -1
   $ hg debugtemplate -r0 -v '{-5 / 2} {mod(-5, 2)}\n'
   (template
     (/
       (negate
         (integer '5'))
       (integer '2'))
     (string ' ')
     (func
       (symbol 'mod')
       (list
         (negate
           (integer '5'))
         (integer '2')))
     (string '\n'))
   -3 1
   $ hg debugtemplate -r0 -v '{-5 / -2} {mod(-5, -2)}\n'
   (template
     (/
       (negate
         (integer '5'))
       (negate
         (integer '2')))
     (string ' ')
     (func
       (symbol 'mod')
       (list
         (negate
           (integer '5'))
         (negate
           (integer '2'))))
     (string '\n'))
   2 -1
 
 Filters bind closer than arithmetic:
 
   $ hg debugtemplate -r0 -v '{revset(".")|count - 1}\n'
   (template
     (-
       (|
         (func
           (symbol 'revset')
           (string '.'))
         (symbol 'count'))
       (integer '1'))
     (string '\n'))
   0
 
 But negate binds closer still:
 
   $ hg debugtemplate -r0 -v '{1-3|stringify}\n'
   (template
     (-
       (integer '1')
       (|
         (integer '3')
         (symbol 'stringify')))
     (string '\n'))
   hg: parse error: arithmetic only defined on integers
   [255]
   $ hg debugtemplate -r0 -v '{-3|stringify}\n'
   (template
     (|
       (negate
         (integer '3'))
       (symbol 'stringify'))
     (string '\n'))
   -3
 
 Filters bind as close as map operator:
 
   $ hg debugtemplate -r0 -v '{desc|splitlines % "{line}\n"}'
   (template
     (%
       (|
         (symbol 'desc')
         (symbol 'splitlines'))
       (template
         (symbol 'line')
         (string '\n'))))
   line 1
   line 2
 
 Keyword arguments:
 
   $ hg debugtemplate -r0 -v '{foo=bar|baz}'
   (template
     (keyvalue
       (symbol 'foo')
       (|
         (symbol 'bar')
         (symbol 'baz'))))
   hg: parse error: can't use a key-value pair in this context
   [255]
 
   $ hg debugtemplate '{pad("foo", width=10, left=true)}\n'
          foo
 
 Call function which takes named arguments by filter syntax:
 
   $ hg debugtemplate '{" "|separate}'
   $ hg debugtemplate '{("not", "an", "argument", "list")|separate}'
   hg: parse error: unknown method 'list'
   [255]
 
 Second branch starting at nullrev:
 
   $ hg update null
   0 files updated, 0 files merged, 4 files removed, 0 files unresolved
   $ echo second > second
   $ hg add second
   $ hg commit -m second -d '1000000 0' -u 'User Name <user@hostname>'
   created new head
 
   $ echo third > third
   $ hg add third
   $ hg mv second fourth
   $ hg commit -m third -d "2020-01-01 10:01"
 
   $ hg log --template '{join(file_copies, ",\n")}\n' -r .
   fourth (second)
   $ hg log -T '{file_copies % "{source} -> {name}\n"}' -r .
   second -> fourth
   $ hg log -T '{rev} {ifcontains("fourth", file_copies, "t", "f")}\n' -r .:7
   8 t
   7 f
 
 Working-directory revision has special identifiers, though they are still
 experimental:
 
   $ hg log -r 'wdir()' -T '{rev}:{node}\n'
   2147483647:ffffffffffffffffffffffffffffffffffffffff
 
 Some keywords are invalid for working-directory revision, but they should
 never cause crash:
 
   $ hg log -r 'wdir()' -T '{manifest}\n'
   
 
 Internal resources shouldn't be exposed (issue5699):
 
   $ hg log -r. -T '{cache}{ctx}{repo}{revcache}{templ}{ui}'
 
 Never crash on internal resource not available:
 
   $ hg --cwd .. debugtemplate '{"c0bebeef"|shortest}\n'
   abort: template resource not available: ctx
   [255]
 
   $ hg config -T '{author}'
 
 Quoting for ui.logtemplate
 
   $ hg tip --config "ui.logtemplate={rev}\n"
   8
   $ hg tip --config "ui.logtemplate='{rev}\n'"
   8
   $ hg tip --config 'ui.logtemplate="{rev}\n"'
   8
   $ hg tip --config 'ui.logtemplate=n{rev}\n'
   n8
 
 Make sure user/global hgrc does not affect tests
 
   $ echo '[ui]' > .hg/hgrc
   $ echo 'logtemplate =' >> .hg/hgrc
   $ echo 'style =' >> .hg/hgrc
 
 Add some simple styles to settings
 
   $ 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 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 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>"
    }
   ]
 
 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 missing key:
 
   $ echo 'q = q' > t
   $ hg log --style ./t
   abort: "changeset" not in template map
   [255]
 
 Error if style missing value:
 
   $ echo 'changeset =' > t
   $ hg log --style t
   hg: parse error at t:1: missing value
   [255]
 
 Error if include fails:
 
   $ echo 'changeset = q' >> t
 #if unix-permissions no-root
   $ hg log --style ./t
   abort: template file ./q: Permission denied
   [255]
   $ rm -f q
 #endif
 
 Include works:
 
   $ echo '{rev}' > q
   $ hg log --style ./t
   8
   7
   6
   5
   4
   3
   2
   1
   0
 
 Check that recursive reference does not fall into RuntimeError (issue4758):
 
  common mistake:
 
   $ cat << EOF > issue4758
   > changeset = '{changeset}\n'
   > EOF
   $ hg log --style ./issue4758
   abort: recursive reference 'changeset' in template
   [255]
 
  circular reference:
 
   $ cat << EOF > issue4758
   > changeset = '{foo}'
   > foo = '{changeset}'
   > EOF
   $ hg log --style ./issue4758
   abort: recursive reference 'foo' in template
   [255]
 
  buildmap() -> gettemplate(), where no thunk was made:
 
   $ cat << EOF > issue4758
   > changeset = '{files % changeset}\n'
   > EOF
   $ hg log --style ./issue4758
   abort: recursive reference 'changeset' in template
   [255]
 
  not a recursion if a keyword of the same name exists:
 
   $ cat << EOF > issue4758
   > changeset = '{tags % rev}'
   > rev = '{rev} {tag}\n'
   > EOF
   $ hg log --style ./issue4758 -r tip
   8 tip
 
 Check that {phase} works correctly on parents:
 
   $ cat << EOF > parentphase
   > changeset_debug = '{rev} ({phase}):{parents}\n'
   > parent = ' {rev} ({phase})'
   > EOF
   $ hg phase -r 5 --public
   $ hg phase -r 7 --secret --force
   $ hg log --debug -G --style ./parentphase
   @  8 (secret): 7 (secret) -1 (public)
   |
   o  7 (secret): -1 (public) -1 (public)
   
   o    6 (draft): 5 (public) 4 (draft)
   |\
   | o  5 (public): 3 (public) -1 (public)
   | |
   o |  4 (draft): 3 (public) -1 (public)
   |/
   o  3 (public): 2 (public) -1 (public)
   |
   o  2 (public): 1 (public) -1 (public)
   |
   o  1 (public): 0 (public) -1 (public)
   |
   o  0 (public): -1 (public) -1 (public)
   
 
 Missing non-standard names give no error (backward compatibility):
 
   $ echo "changeset = '{c}'" > t
   $ hg log --style ./t
 
 Defining non-standard name works:
 
   $ cat <<EOF > t
   > changeset = '{c}'
   > c = q
   > EOF
   $ hg log --style ./t
   8
   7
   6
   5
   4
   3
   2
   1
   0
 
 ui.style works:
 
   $ echo '[ui]' > .hg/hgrc
   $ echo 'style = t' >> .hg/hgrc
   $ hg log
   8
   7
   6
   5
   4
   3
   2
   1
   0
 
 
 Issue338:
 
   $ hg log --style=changelog > changelog
 
   $ cat changelog
   2020-01-01  test  <test>
   
   	* fourth, second, third:
   	third
   	[95c24699272e] [tip]
   
   1970-01-12  User Name  <user@hostname>
   
   	* second:
   	second
   	[29114dbae42b]
   
   1970-01-18  person  <person>
   
   	* merge
   	[d41e714fe50d]
   
   	* d:
   	new head
   	[13207e5a10d9]
   
   1970-01-17  person  <person>
   
   	* new branch
   	[bbe44766e73d] <foo>
   
   1970-01-16  person  <person>
   
   	* c:
   	no user, no domain
   	[10e46f2dcbf4]
   
   1970-01-14  other  <other@place>
   
   	* c:
   	no person
   	[97054abb4ab8]
   
   1970-01-13  A. N. Other  <other@place>
   
   	* b:
   	other 1 other 2
   
   	other 3
   	[b608e9d1a3f0]
   
   1970-01-12  User Name  <user@hostname>
   
   	* a:
   	line 1 line 2
   	[1e4e1b8f71e0]
   
 
 Issue2130: xml output for 'hg heads' is malformed
 
   $ hg heads --style changelog
   2020-01-01  test  <test>
   
   	* fourth, second, third:
   	third
   	[95c24699272e] [tip]
   
   1970-01-18  person  <person>
   
   	* merge
   	[d41e714fe50d]
   
   1970-01-17  person  <person>
   
   	* new branch
   	[bbe44766e73d] <foo>
   
 
 Keys work:
 
   $ for key in author branch branches date desc file_adds file_dels file_mods \
   >         file_copies file_copies_switch files \
   >         manifest node parents rev tags diffstat extras \
   >         p1rev p2rev p1node p2node; do
   >     for mode in '' --verbose --debug; do
   >         hg log $mode --template "$key$mode: {$key}\n"
   >     done
   > done
   author: test
   author: User Name <user@hostname>
   author: person
   author: person
   author: person
   author: person
   author: other@place
   author: A. N. Other <other@place>
   author: User Name <user@hostname>
   author--verbose: test
   author--verbose: User Name <user@hostname>
   author--verbose: person
   author--verbose: person
   author--verbose: person
   author--verbose: person
   author--verbose: other@place
   author--verbose: A. N. Other <other@place>
   author--verbose: User Name <user@hostname>
   author--debug: test
   author--debug: User Name <user@hostname>
   author--debug: person
   author--debug: person
   author--debug: person
   author--debug: person
   author--debug: other@place
   author--debug: A. N. Other <other@place>
   author--debug: User Name <user@hostname>
   branch: default
   branch: default
   branch: default
   branch: default
   branch: foo
   branch: default
   branch: default
   branch: default
   branch: default
   branch--verbose: default
   branch--verbose: default
   branch--verbose: default
   branch--verbose: default
   branch--verbose: foo
   branch--verbose: default
   branch--verbose: default
   branch--verbose: default
   branch--verbose: default
   branch--debug: default
   branch--debug: default
   branch--debug: default
   branch--debug: default
   branch--debug: foo
   branch--debug: default
   branch--debug: default
   branch--debug: default
   branch--debug: default
   branches: 
   branches: 
   branches: 
   branches: 
   branches: foo
   branches: 
   branches: 
   branches: 
   branches: 
   branches--verbose: 
   branches--verbose: 
   branches--verbose: 
   branches--verbose: 
   branches--verbose: foo
   branches--verbose: 
   branches--verbose: 
   branches--verbose: 
   branches--verbose: 
   branches--debug: 
   branches--debug: 
   branches--debug: 
   branches--debug: 
   branches--debug: foo
   branches--debug: 
   branches--debug: 
   branches--debug: 
   branches--debug: 
   date: 1577872860.00
   date: 1000000.00
   date: 1500001.00
   date: 1500000.00
   date: 1400000.00
   date: 1300000.00
   date: 1200000.00
   date: 1100000.00
   date: 1000000.00
   date--verbose: 1577872860.00
   date--verbose: 1000000.00
   date--verbose: 1500001.00
   date--verbose: 1500000.00
   date--verbose: 1400000.00
   date--verbose: 1300000.00
   date--verbose: 1200000.00
   date--verbose: 1100000.00
   date--verbose: 1000000.00
   date--debug: 1577872860.00
   date--debug: 1000000.00
   date--debug: 1500001.00
   date--debug: 1500000.00
   date--debug: 1400000.00
   date--debug: 1300000.00
   date--debug: 1200000.00
   date--debug: 1100000.00
   date--debug: 1000000.00
   desc: third
   desc: second
   desc: merge
   desc: new head
   desc: new branch
   desc: no user, no domain
   desc: no person
   desc: other 1
   other 2
   
   other 3
   desc: line 1
   line 2
   desc--verbose: third
   desc--verbose: second
   desc--verbose: merge
   desc--verbose: new head
   desc--verbose: new branch
   desc--verbose: no user, no domain
   desc--verbose: no person
   desc--verbose: other 1
   other 2
   
   other 3
   desc--verbose: line 1
   line 2
   desc--debug: third
   desc--debug: second
   desc--debug: merge
   desc--debug: new head
   desc--debug: new branch
   desc--debug: no user, no domain
   desc--debug: no person
   desc--debug: other 1
   other 2
   
   other 3
   desc--debug: line 1
   line 2
   file_adds: fourth third
   file_adds: second
   file_adds: 
   file_adds: d
   file_adds: 
   file_adds: 
   file_adds: c
   file_adds: b
   file_adds: a
   file_adds--verbose: fourth third
   file_adds--verbose: second
   file_adds--verbose: 
   file_adds--verbose: d
   file_adds--verbose: 
   file_adds--verbose: 
   file_adds--verbose: c
   file_adds--verbose: b
   file_adds--verbose: a
   file_adds--debug: fourth third
   file_adds--debug: second
   file_adds--debug: 
   file_adds--debug: d
   file_adds--debug: 
   file_adds--debug: 
   file_adds--debug: c
   file_adds--debug: b
   file_adds--debug: a
   file_dels: second
   file_dels: 
   file_dels: 
   file_dels: 
   file_dels: 
   file_dels: 
   file_dels: 
   file_dels: 
   file_dels: 
   file_dels--verbose: second
   file_dels--verbose: 
   file_dels--verbose: 
   file_dels--verbose: 
   file_dels--verbose: 
   file_dels--verbose: 
   file_dels--verbose: 
   file_dels--verbose: 
   file_dels--verbose: 
   file_dels--debug: second
   file_dels--debug: 
   file_dels--debug: 
   file_dels--debug: 
   file_dels--debug: 
   file_dels--debug: 
   file_dels--debug: 
   file_dels--debug: 
   file_dels--debug: 
   file_mods: 
   file_mods: 
   file_mods: 
   file_mods: 
   file_mods: 
   file_mods: c
   file_mods: 
   file_mods: 
   file_mods: 
   file_mods--verbose: 
   file_mods--verbose: 
   file_mods--verbose: 
   file_mods--verbose: 
   file_mods--verbose: 
   file_mods--verbose: c
   file_mods--verbose: 
   file_mods--verbose: 
   file_mods--verbose: 
   file_mods--debug: 
   file_mods--debug: 
   file_mods--debug: 
   file_mods--debug: 
   file_mods--debug: 
   file_mods--debug: c
   file_mods--debug: 
   file_mods--debug: 
   file_mods--debug: 
   file_copies: fourth (second)
   file_copies: 
   file_copies: 
   file_copies: 
   file_copies: 
   file_copies: 
   file_copies: 
   file_copies: 
   file_copies: 
   file_copies--verbose: fourth (second)
   file_copies--verbose: 
   file_copies--verbose: 
   file_copies--verbose: 
   file_copies--verbose: 
   file_copies--verbose: 
   file_copies--verbose: 
   file_copies--verbose: 
   file_copies--verbose: 
   file_copies--debug: fourth (second)
   file_copies--debug: 
   file_copies--debug: 
   file_copies--debug: 
   file_copies--debug: 
   file_copies--debug: 
   file_copies--debug: 
   file_copies--debug: 
   file_copies--debug: 
   file_copies_switch: 
   file_copies_switch: 
   file_copies_switch: 
   file_copies_switch: 
   file_copies_switch: 
   file_copies_switch: 
   file_copies_switch: 
   file_copies_switch: 
   file_copies_switch: 
   file_copies_switch--verbose: 
   file_copies_switch--verbose: 
   file_copies_switch--verbose: 
   file_copies_switch--verbose: 
   file_copies_switch--verbose: 
   file_copies_switch--verbose: 
   file_copies_switch--verbose: 
   file_copies_switch--verbose: 
   file_copies_switch--verbose: 
   file_copies_switch--debug: 
   file_copies_switch--debug: 
   file_copies_switch--debug: 
   file_copies_switch--debug: 
   file_copies_switch--debug: 
   file_copies_switch--debug: 
   file_copies_switch--debug: 
   file_copies_switch--debug: 
   file_copies_switch--debug: 
   files: fourth second third
   files: second
   files: 
   files: d
   files: 
   files: c
   files: c
   files: b
   files: a
   files--verbose: fourth second third
   files--verbose: second
   files--verbose: 
   files--verbose: d
   files--verbose: 
   files--verbose: c
   files--verbose: c
   files--verbose: b
   files--verbose: a
   files--debug: fourth second third
   files--debug: second
   files--debug: 
   files--debug: d
   files--debug: 
   files--debug: c
   files--debug: c
   files--debug: b
   files--debug: a
   manifest: 6:94961b75a2da
   manifest: 5:f2dbc354b94e
   manifest: 4:4dc3def4f9b4
   manifest: 4:4dc3def4f9b4
   manifest: 3:cb5a1327723b
   manifest: 3:cb5a1327723b
   manifest: 2:6e0e82995c35
   manifest: 1:4e8d705b1e53
   manifest: 0:a0c8bcbbb45c
   manifest--verbose: 6:94961b75a2da
   manifest--verbose: 5:f2dbc354b94e
   manifest--verbose: 4:4dc3def4f9b4
   manifest--verbose: 4:4dc3def4f9b4
   manifest--verbose: 3:cb5a1327723b
   manifest--verbose: 3:cb5a1327723b
   manifest--verbose: 2:6e0e82995c35
   manifest--verbose: 1:4e8d705b1e53
   manifest--verbose: 0:a0c8bcbbb45c
   manifest--debug: 6:94961b75a2da554b4df6fb599e5bfc7d48de0c64
   manifest--debug: 5:f2dbc354b94e5ec0b4f10680ee0cee816101d0bf
   manifest--debug: 4:4dc3def4f9b4c6e8de820f6ee74737f91e96a216
   manifest--debug: 4:4dc3def4f9b4c6e8de820f6ee74737f91e96a216
   manifest--debug: 3:cb5a1327723bada42f117e4c55a303246eaf9ccc
   manifest--debug: 3:cb5a1327723bada42f117e4c55a303246eaf9ccc
   manifest--debug: 2:6e0e82995c35d0d57a52aca8da4e56139e06b4b1
   manifest--debug: 1:4e8d705b1e53e3f9375e0e60dc7b525d8211fe55
   manifest--debug: 0:a0c8bcbbb45c63b90b70ad007bf38961f64f2af0
   node: 95c24699272ef57d062b8bccc32c878bf841784a
   node: 29114dbae42b9f078cf2714dbe3a86bba8ec7453
   node: d41e714fe50d9e4a5f11b4d595d543481b5f980b
   node: 13207e5a10d9fd28ec424934298e176197f2c67f
   node: bbe44766e73d5f11ed2177f1838de10c53ef3e74
   node: 10e46f2dcbf4823578cf180f33ecf0b957964c47
   node: 97054abb4ab824450e9164180baf491ae0078465
   node: b608e9d1a3f0273ccf70fb85fd6866b3482bf965
   node: 1e4e1b8f71e05681d422154f5421e385fec3454f
   node--verbose: 95c24699272ef57d062b8bccc32c878bf841784a
   node--verbose: 29114dbae42b9f078cf2714dbe3a86bba8ec7453
   node--verbose: d41e714fe50d9e4a5f11b4d595d543481b5f980b
   node--verbose: 13207e5a10d9fd28ec424934298e176197f2c67f
   node--verbose: bbe44766e73d5f11ed2177f1838de10c53ef3e74
   node--verbose: 10e46f2dcbf4823578cf180f33ecf0b957964c47
   node--verbose: 97054abb4ab824450e9164180baf491ae0078465
   node--verbose: b608e9d1a3f0273ccf70fb85fd6866b3482bf965
   node--verbose: 1e4e1b8f71e05681d422154f5421e385fec3454f
   node--debug: 95c24699272ef57d062b8bccc32c878bf841784a
   node--debug: 29114dbae42b9f078cf2714dbe3a86bba8ec7453
   node--debug: d41e714fe50d9e4a5f11b4d595d543481b5f980b
   node--debug: 13207e5a10d9fd28ec424934298e176197f2c67f
   node--debug: bbe44766e73d5f11ed2177f1838de10c53ef3e74
   node--debug: 10e46f2dcbf4823578cf180f33ecf0b957964c47
   node--debug: 97054abb4ab824450e9164180baf491ae0078465
   node--debug: b608e9d1a3f0273ccf70fb85fd6866b3482bf965
   node--debug: 1e4e1b8f71e05681d422154f5421e385fec3454f
   parents: 
   parents: -1:000000000000 
   parents: 5:13207e5a10d9 4:bbe44766e73d 
   parents: 3:10e46f2dcbf4 
   parents: 
   parents: 
   parents: 
   parents: 
   parents: 
   parents--verbose: 
   parents--verbose: -1:000000000000 
   parents--verbose: 5:13207e5a10d9 4:bbe44766e73d 
   parents--verbose: 3:10e46f2dcbf4 
   parents--verbose: 
   parents--verbose: 
   parents--verbose: 
   parents--verbose: 
   parents--verbose: 
   parents--debug: 7:29114dbae42b9f078cf2714dbe3a86bba8ec7453 -1:0000000000000000000000000000000000000000 
   parents--debug: -1:0000000000000000000000000000000000000000 -1:0000000000000000000000000000000000000000 
   parents--debug: 5:13207e5a10d9fd28ec424934298e176197f2c67f 4:bbe44766e73d5f11ed2177f1838de10c53ef3e74 
   parents--debug: 3:10e46f2dcbf4823578cf180f33ecf0b957964c47 -1:0000000000000000000000000000000000000000 
   parents--debug: 3:10e46f2dcbf4823578cf180f33ecf0b957964c47 -1:0000000000000000000000000000000000000000 
   parents--debug: 2:97054abb4ab824450e9164180baf491ae0078465 -1:0000000000000000000000000000000000000000 
   parents--debug: 1:b608e9d1a3f0273ccf70fb85fd6866b3482bf965 -1:0000000000000000000000000000000000000000 
   parents--debug: 0:1e4e1b8f71e05681d422154f5421e385fec3454f -1:0000000000000000000000000000000000000000 
   parents--debug: -1:0000000000000000000000000000000000000000 -1:0000000000000000000000000000000000000000 
   rev: 8
   rev: 7
   rev: 6
   rev: 5
   rev: 4
   rev: 3
   rev: 2
   rev: 1
   rev: 0
   rev--verbose: 8
   rev--verbose: 7
   rev--verbose: 6
   rev--verbose: 5
   rev--verbose: 4
   rev--verbose: 3
   rev--verbose: 2
   rev--verbose: 1
   rev--verbose: 0
   rev--debug: 8
   rev--debug: 7
   rev--debug: 6
   rev--debug: 5
   rev--debug: 4
   rev--debug: 3
   rev--debug: 2
   rev--debug: 1
   rev--debug: 0
   tags: tip
   tags: 
   tags: 
   tags: 
   tags: 
   tags: 
   tags: 
   tags: 
   tags: 
   tags--verbose: tip
   tags--verbose: 
   tags--verbose: 
   tags--verbose: 
   tags--verbose: 
   tags--verbose: 
   tags--verbose: 
   tags--verbose: 
   tags--verbose: 
   tags--debug: tip
   tags--debug: 
   tags--debug: 
   tags--debug: 
   tags--debug: 
   tags--debug: 
   tags--debug: 
   tags--debug: 
   tags--debug: 
   diffstat: 3: +2/-1
   diffstat: 1: +1/-0
   diffstat: 0: +0/-0
   diffstat: 1: +1/-0
   diffstat: 0: +0/-0
   diffstat: 1: +1/-0
   diffstat: 1: +4/-0
   diffstat: 1: +2/-0
   diffstat: 1: +1/-0
   diffstat--verbose: 3: +2/-1
   diffstat--verbose: 1: +1/-0
   diffstat--verbose: 0: +0/-0
   diffstat--verbose: 1: +1/-0
   diffstat--verbose: 0: +0/-0
   diffstat--verbose: 1: +1/-0
   diffstat--verbose: 1: +4/-0
   diffstat--verbose: 1: +2/-0
   diffstat--verbose: 1: +1/-0
   diffstat--debug: 3: +2/-1
   diffstat--debug: 1: +1/-0
   diffstat--debug: 0: +0/-0
   diffstat--debug: 1: +1/-0
   diffstat--debug: 0: +0/-0
   diffstat--debug: 1: +1/-0
   diffstat--debug: 1: +4/-0
   diffstat--debug: 1: +2/-0
   diffstat--debug: 1: +1/-0
   extras: branch=default
   extras: branch=default
   extras: branch=default
   extras: branch=default
   extras: branch=foo
   extras: branch=default
   extras: branch=default
   extras: branch=default
   extras: branch=default
   extras--verbose: branch=default
   extras--verbose: branch=default
   extras--verbose: branch=default
   extras--verbose: branch=default
   extras--verbose: branch=foo
   extras--verbose: branch=default
   extras--verbose: branch=default
   extras--verbose: branch=default
   extras--verbose: branch=default
   extras--debug: branch=default
   extras--debug: branch=default
   extras--debug: branch=default
   extras--debug: branch=default
   extras--debug: branch=foo
   extras--debug: branch=default
   extras--debug: branch=default
   extras--debug: branch=default
   extras--debug: branch=default
   p1rev: 7
   p1rev: -1
   p1rev: 5
   p1rev: 3
   p1rev: 3
   p1rev: 2
   p1rev: 1
   p1rev: 0
   p1rev: -1
   p1rev--verbose: 7
   p1rev--verbose: -1
   p1rev--verbose: 5
   p1rev--verbose: 3
   p1rev--verbose: 3
   p1rev--verbose: 2
   p1rev--verbose: 1
   p1rev--verbose: 0
   p1rev--verbose: -1
   p1rev--debug: 7
   p1rev--debug: -1
   p1rev--debug: 5
   p1rev--debug: 3
   p1rev--debug: 3
   p1rev--debug: 2
   p1rev--debug: 1
   p1rev--debug: 0
   p1rev--debug: -1
   p2rev: -1
   p2rev: -1
   p2rev: 4
   p2rev: -1
   p2rev: -1
   p2rev: -1
   p2rev: -1
   p2rev: -1
   p2rev: -1
   p2rev--verbose: -1
   p2rev--verbose: -1
   p2rev--verbose: 4
   p2rev--verbose: -1
   p2rev--verbose: -1
   p2rev--verbose: -1
   p2rev--verbose: -1
   p2rev--verbose: -1
   p2rev--verbose: -1
   p2rev--debug: -1
   p2rev--debug: -1
   p2rev--debug: 4
   p2rev--debug: -1
   p2rev--debug: -1
   p2rev--debug: -1
   p2rev--debug: -1
   p2rev--debug: -1
   p2rev--debug: -1
   p1node: 29114dbae42b9f078cf2714dbe3a86bba8ec7453
   p1node: 0000000000000000000000000000000000000000
   p1node: 13207e5a10d9fd28ec424934298e176197f2c67f
   p1node: 10e46f2dcbf4823578cf180f33ecf0b957964c47
   p1node: 10e46f2dcbf4823578cf180f33ecf0b957964c47
   p1node: 97054abb4ab824450e9164180baf491ae0078465
   p1node: b608e9d1a3f0273ccf70fb85fd6866b3482bf965
   p1node: 1e4e1b8f71e05681d422154f5421e385fec3454f
   p1node: 0000000000000000000000000000000000000000
   p1node--verbose: 29114dbae42b9f078cf2714dbe3a86bba8ec7453
   p1node--verbose: 0000000000000000000000000000000000000000
   p1node--verbose: 13207e5a10d9fd28ec424934298e176197f2c67f
   p1node--verbose: 10e46f2dcbf4823578cf180f33ecf0b957964c47
   p1node--verbose: 10e46f2dcbf4823578cf180f33ecf0b957964c47
   p1node--verbose: 97054abb4ab824450e9164180baf491ae0078465
   p1node--verbose: b608e9d1a3f0273ccf70fb85fd6866b3482bf965
   p1node--verbose: 1e4e1b8f71e05681d422154f5421e385fec3454f
   p1node--verbose: 0000000000000000000000000000000000000000
   p1node--debug: 29114dbae42b9f078cf2714dbe3a86bba8ec7453
   p1node--debug: 0000000000000000000000000000000000000000
   p1node--debug: 13207e5a10d9fd28ec424934298e176197f2c67f
   p1node--debug: 10e46f2dcbf4823578cf180f33ecf0b957964c47
   p1node--debug: 10e46f2dcbf4823578cf180f33ecf0b957964c47
   p1node--debug: 97054abb4ab824450e9164180baf491ae0078465
   p1node--debug: b608e9d1a3f0273ccf70fb85fd6866b3482bf965
   p1node--debug: 1e4e1b8f71e05681d422154f5421e385fec3454f
   p1node--debug: 0000000000000000000000000000000000000000
   p2node: 0000000000000000000000000000000000000000
   p2node: 0000000000000000000000000000000000000000
   p2node: bbe44766e73d5f11ed2177f1838de10c53ef3e74
   p2node: 0000000000000000000000000000000000000000
   p2node: 0000000000000000000000000000000000000000
   p2node: 0000000000000000000000000000000000000000
   p2node: 0000000000000000000000000000000000000000
   p2node: 0000000000000000000000000000000000000000
   p2node: 0000000000000000000000000000000000000000
   p2node--verbose: 0000000000000000000000000000000000000000
   p2node--verbose: 0000000000000000000000000000000000000000
   p2node--verbose: bbe44766e73d5f11ed2177f1838de10c53ef3e74
   p2node--verbose: 0000000000000000000000000000000000000000
   p2node--verbose: 0000000000000000000000000000000000000000
   p2node--verbose: 0000000000000000000000000000000000000000
   p2node--verbose: 0000000000000000000000000000000000000000
   p2node--verbose: 0000000000000000000000000000000000000000
   p2node--verbose: 0000000000000000000000000000000000000000
   p2node--debug: 0000000000000000000000000000000000000000
   p2node--debug: 0000000000000000000000000000000000000000
   p2node--debug: bbe44766e73d5f11ed2177f1838de10c53ef3e74
   p2node--debug: 0000000000000000000000000000000000000000
   p2node--debug: 0000000000000000000000000000000000000000
   p2node--debug: 0000000000000000000000000000000000000000
   p2node--debug: 0000000000000000000000000000000000000000
   p2node--debug: 0000000000000000000000000000000000000000
   p2node--debug: 0000000000000000000000000000000000000000
 
 Filters work:
 
   $ hg log --template '{author|domain}\n'
   
   hostname
   
   
   
   
   place
   place
   hostname
 
   $ hg log --template '{author|person}\n'
   test
   User Name
   person
   person
   person
   person
   other
   A. N. Other
   User Name
 
   $ hg log --template '{author|user}\n'
   test
   user
   person
   person
   person
   person
   other
   other
   user
 
   $ hg log --template '{date|date}\n'
   Wed Jan 01 10:01:00 2020 +0000
   Mon Jan 12 13:46:40 1970 +0000
   Sun Jan 18 08:40:01 1970 +0000
   Sun Jan 18 08:40:00 1970 +0000
   Sat Jan 17 04:53:20 1970 +0000
   Fri Jan 16 01:06:40 1970 +0000
   Wed Jan 14 21:20:00 1970 +0000
   Tue Jan 13 17:33:20 1970 +0000
   Mon Jan 12 13:46:40 1970 +0000
 
   $ hg log --template '{date|isodate}\n'
   2020-01-01 10:01 +0000
   1970-01-12 13:46 +0000
   1970-01-18 08:40 +0000
   1970-01-18 08:40 +0000
   1970-01-17 04:53 +0000
   1970-01-16 01:06 +0000
   1970-01-14 21:20 +0000
   1970-01-13 17:33 +0000
   1970-01-12 13:46 +0000
 
   $ hg log --template '{date|isodatesec}\n'
   2020-01-01 10:01:00 +0000
   1970-01-12 13:46:40 +0000
   1970-01-18 08:40:01 +0000
   1970-01-18 08:40:00 +0000
   1970-01-17 04:53:20 +0000
   1970-01-16 01:06:40 +0000
   1970-01-14 21:20:00 +0000
   1970-01-13 17:33:20 +0000
   1970-01-12 13:46:40 +0000
 
   $ hg log --template '{date|rfc822date}\n'
   Wed, 01 Jan 2020 10:01:00 +0000
   Mon, 12 Jan 1970 13:46:40 +0000
   Sun, 18 Jan 1970 08:40:01 +0000
   Sun, 18 Jan 1970 08:40:00 +0000
   Sat, 17 Jan 1970 04:53:20 +0000
   Fri, 16 Jan 1970 01:06:40 +0000
   Wed, 14 Jan 1970 21:20:00 +0000
   Tue, 13 Jan 1970 17:33:20 +0000
   Mon, 12 Jan 1970 13:46:40 +0000
 
   $ hg log --template '{desc|firstline}\n'
   third
   second
   merge
   new head
   new branch
   no user, no domain
   no person
   other 1
   line 1
 
   $ hg log --template '{node|short}\n'
   95c24699272e
   29114dbae42b
   d41e714fe50d
   13207e5a10d9
   bbe44766e73d
   10e46f2dcbf4
   97054abb4ab8
   b608e9d1a3f0
   1e4e1b8f71e0
 
   $ hg log --template '<changeset author="{author|xmlescape}"/>\n'
   <changeset author="test"/>
   <changeset author="User Name &lt;user@hostname&gt;"/>
   <changeset author="person"/>
   <changeset author="person"/>
   <changeset author="person"/>
   <changeset author="person"/>
   <changeset author="other@place"/>
   <changeset author="A. N. Other &lt;other@place&gt;"/>
   <changeset author="User Name &lt;user@hostname&gt;"/>
 
   $ hg log --template '{rev}: {children}\n'
   8: 
   7: 8:95c24699272e
   6: 
   5: 6:d41e714fe50d
   4: 6:d41e714fe50d
   3: 4:bbe44766e73d 5:13207e5a10d9
   2: 3:10e46f2dcbf4
   1: 2:97054abb4ab8
   0: 1:b608e9d1a3f0
 
 Formatnode filter works:
 
   $ hg -q log -r 0 --template '{node|formatnode}\n'
   1e4e1b8f71e0
 
   $ hg log -r 0 --template '{node|formatnode}\n'
   1e4e1b8f71e0
 
   $ hg -v log -r 0 --template '{node|formatnode}\n'
   1e4e1b8f71e0
 
   $ hg --debug log -r 0 --template '{node|formatnode}\n'
   1e4e1b8f71e05681d422154f5421e385fec3454f
 
 Age filter:
 
   $ hg init unstable-hash
   $ cd unstable-hash
   $ hg log --template '{date|age}\n' > /dev/null || exit 1
 
   >>> from __future__ import absolute_import
   >>> import datetime
   >>> fp = open('a', 'wb')
   >>> n = datetime.datetime.now() + datetime.timedelta(366 * 7)
   >>> fp.write(b'%d-%d-%d 00:00' % (n.year, n.month, n.day)) and None
   >>> fp.close()
   $ hg add a
   $ hg commit -m future -d "`cat a`"
 
   $ hg log -l1 --template '{date|age}\n'
   7 years from now
 
   $ cd ..
   $ rm -rf unstable-hash
 
 Filename filters:
 
   $ hg debugtemplate '{"foo/bar"|basename}|{"foo/"|basename}|{"foo"|basename}|\n'
   bar||foo|
   $ hg debugtemplate '{"foo/bar"|dirname}|{"foo/"|dirname}|{"foo"|dirname}|\n'
   foo|foo||
   $ hg debugtemplate '{"foo/bar"|stripdir}|{"foo/"|stripdir}|{"foo"|stripdir}|\n'
   foo|foo|foo|
 
 Add a dummy commit to make up for the instability of the above:
 
   $ echo a > a
   $ hg add a
   $ hg ci -m future
 
 Count filter:
 
   $ hg log -l1 --template '{node|count} {node|short|count}\n'
   40 12
 
   $ hg log -l1 --template '{revset("null^")|count} {revset(".")|count} {revset("0::3")|count}\n'
   0 1 4
 
   $ hg log -G --template '{rev}: children: {children|count}, \
   > tags: {tags|count}, file_adds: {file_adds|count}, \
   > ancestors: {revset("ancestors(%s)", rev)|count}'
   @  9: children: 0, tags: 1, file_adds: 1, ancestors: 3
   |
   o  8: children: 1, tags: 0, file_adds: 2, ancestors: 2
   |
   o  7: children: 1, tags: 0, file_adds: 1, ancestors: 1
   
   o    6: children: 0, tags: 0, file_adds: 0, ancestors: 7
   |\
   | o  5: children: 1, tags: 0, file_adds: 1, ancestors: 5
   | |
   o |  4: children: 1, tags: 0, file_adds: 0, ancestors: 5
   |/
   o  3: children: 2, tags: 0, file_adds: 0, ancestors: 4
   |
   o  2: children: 1, tags: 0, file_adds: 1, ancestors: 3
   |
   o  1: children: 1, tags: 0, file_adds: 1, ancestors: 2
   |
   o  0: children: 1, tags: 0, file_adds: 1, ancestors: 1
   
 
   $ hg log -l1 -T '{termwidth|count}\n'
   hg: parse error: not countable
   (template filter 'count' is not compatible with keyword 'termwidth')
   [255]
 
 Upper/lower filters:
 
   $ hg log -r0 --template '{branch|upper}\n'
   DEFAULT
   $ hg log -r0 --template '{author|lower}\n'
   user name <user@hostname>
   $ hg log -r0 --template '{date|upper}\n'
   1000000.00
 
 Add a commit that does all possible modifications at once
 
   $ echo modify >> third
   $ touch b
   $ hg add b
   $ hg mv fourth fifth
   $ hg rm a
   $ hg ci -m "Modify, add, remove, rename"
 
 Check the status template
 
   $ cat <<EOF >> $HGRCPATH
   > [extensions]
   > color=
   > EOF
 
   $ hg log -T status -r 10
   changeset:   10:0f9759ec227a
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     Modify, add, remove, rename
   files:
   M third
   A b
   A fifth
   R a
   R fourth
   
   $ hg log -T status -C -r 10
   changeset:   10:0f9759ec227a
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     Modify, add, remove, rename
   files:
   M third
   A b
   A fifth
     fourth
   R a
   R fourth
   
   $ hg log -T status -C -r 10 -v
   changeset:   10:0f9759ec227a
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   description:
   Modify, add, remove, rename
   
   files:
   M third
   A b
   A fifth
     fourth
   R a
   R fourth
   
   $ hg log -T status -C -r 10 --debug
   changeset:   10:0f9759ec227a4859c2014a345cd8a859022b7c6c
   tag:         tip
   phase:       secret
   parent:      9:bf9dfba36635106d6a73ccc01e28b762da60e066
   parent:      -1:0000000000000000000000000000000000000000
   manifest:    8:89dd546f2de0a9d6d664f58d86097eb97baba567
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   extra:       branch=default
   description:
   Modify, add, remove, rename
   
   files:
   M third
   A b
   A fifth
     fourth
   R a
   R fourth
   
   $ hg log -T status -C -r 10 --quiet
   10:0f9759ec227a
   $ hg --color=debug log -T status -r 10
   [log.changeset changeset.secret|changeset:   10:0f9759ec227a]
   [log.tag|tag:         tip]
   [log.user|user:        test]
   [log.date|date:        Thu Jan 01 00:00:00 1970 +0000]
   [log.summary|summary:     Modify, add, remove, rename]
   [ui.note log.files|files:]
   [status.modified|M third]
   [status.added|A b]
   [status.added|A fifth]
   [status.removed|R a]
   [status.removed|R fourth]
   
   $ hg --color=debug log -T status -C -r 10
   [log.changeset changeset.secret|changeset:   10:0f9759ec227a]
   [log.tag|tag:         tip]
   [log.user|user:        test]
   [log.date|date:        Thu Jan 01 00:00:00 1970 +0000]
   [log.summary|summary:     Modify, add, remove, rename]
   [ui.note log.files|files:]
   [status.modified|M third]
   [status.added|A b]
   [status.added|A fifth]
   [status.copied|  fourth]
   [status.removed|R a]
   [status.removed|R fourth]
   
   $ hg --color=debug log -T status -C -r 10 -v
   [log.changeset changeset.secret|changeset:   10:0f9759ec227a]
   [log.tag|tag:         tip]
   [log.user|user:        test]
   [log.date|date:        Thu Jan 01 00:00:00 1970 +0000]
   [ui.note log.description|description:]
   [ui.note log.description|Modify, add, remove, rename]
   
   [ui.note log.files|files:]
   [status.modified|M third]
   [status.added|A b]
   [status.added|A fifth]
   [status.copied|  fourth]
   [status.removed|R a]
   [status.removed|R fourth]
   
   $ hg --color=debug log -T status -C -r 10 --debug
   [log.changeset changeset.secret|changeset:   10:0f9759ec227a4859c2014a345cd8a859022b7c6c]
   [log.tag|tag:         tip]
   [log.phase|phase:       secret]
   [log.parent changeset.secret|parent:      9:bf9dfba36635106d6a73ccc01e28b762da60e066]
   [log.parent changeset.public|parent:      -1:0000000000000000000000000000000000000000]
   [ui.debug log.manifest|manifest:    8:89dd546f2de0a9d6d664f58d86097eb97baba567]
   [log.user|user:        test]
   [log.date|date:        Thu Jan 01 00:00:00 1970 +0000]
   [ui.debug log.extra|extra:       branch=default]
   [ui.note log.description|description:]
   [ui.note log.description|Modify, add, remove, rename]
   
   [ui.note log.files|files:]
   [status.modified|M third]
   [status.added|A b]
   [status.added|A fifth]
   [status.copied|  fourth]
   [status.removed|R a]
   [status.removed|R fourth]
   
   $ hg --color=debug log -T status -C -r 10 --quiet
   [log.node|10:0f9759ec227a]
 
 Check the bisect template
 
   $ hg bisect -g 1
   $ hg bisect -b 3 --noupdate
   Testing changeset 2:97054abb4ab8 (2 changesets remaining, ~1 tests)
   $ hg log -T bisect -r 0:4
   changeset:   0:1e4e1b8f71e0
   bisect:      good (implicit)
   user:        User Name <user@hostname>
   date:        Mon Jan 12 13:46:40 1970 +0000
   summary:     line 1
   
   changeset:   1:b608e9d1a3f0
   bisect:      good
   user:        A. N. Other <other@place>
   date:        Tue Jan 13 17:33:20 1970 +0000
   summary:     other 1
   
   changeset:   2:97054abb4ab8
   bisect:      untested
   user:        other@place
   date:        Wed Jan 14 21:20:00 1970 +0000
   summary:     no person
   
   changeset:   3:10e46f2dcbf4
   bisect:      bad
   user:        person
   date:        Fri Jan 16 01:06:40 1970 +0000
   summary:     no user, no domain
   
   changeset:   4:bbe44766e73d
   bisect:      bad (implicit)
   branch:      foo
   user:        person
   date:        Sat Jan 17 04:53:20 1970 +0000
   summary:     new branch
   
   $ hg log --debug -T bisect -r 0:4
   changeset:   0:1e4e1b8f71e05681d422154f5421e385fec3454f
   bisect:      good (implicit)
   phase:       public
   parent:      -1:0000000000000000000000000000000000000000
   parent:      -1:0000000000000000000000000000000000000000
   manifest:    0:a0c8bcbbb45c63b90b70ad007bf38961f64f2af0
   user:        User Name <user@hostname>
   date:        Mon Jan 12 13:46:40 1970 +0000
   files+:      a
   extra:       branch=default
   description:
   line 1
   line 2
   
   
   changeset:   1:b608e9d1a3f0273ccf70fb85fd6866b3482bf965
   bisect:      good
   phase:       public
   parent:      0:1e4e1b8f71e05681d422154f5421e385fec3454f
   parent:      -1:0000000000000000000000000000000000000000
   manifest:    1:4e8d705b1e53e3f9375e0e60dc7b525d8211fe55
   user:        A. N. Other <other@place>
   date:        Tue Jan 13 17:33:20 1970 +0000
   files+:      b
   extra:       branch=default
   description:
   other 1
   other 2
   
   other 3
   
   
   changeset:   2:97054abb4ab824450e9164180baf491ae0078465
   bisect:      untested
   phase:       public
   parent:      1:b608e9d1a3f0273ccf70fb85fd6866b3482bf965
   parent:      -1:0000000000000000000000000000000000000000
   manifest:    2:6e0e82995c35d0d57a52aca8da4e56139e06b4b1
   user:        other@place
   date:        Wed Jan 14 21:20:00 1970 +0000
   files+:      c
   extra:       branch=default
   description:
   no person
   
   
   changeset:   3:10e46f2dcbf4823578cf180f33ecf0b957964c47
   bisect:      bad
   phase:       public
   parent:      2:97054abb4ab824450e9164180baf491ae0078465
   parent:      -1:0000000000000000000000000000000000000000
   manifest:    3:cb5a1327723bada42f117e4c55a303246eaf9ccc
   user:        person
   date:        Fri Jan 16 01:06:40 1970 +0000
   files:       c
   extra:       branch=default
   description:
   no user, no domain
   
   
   changeset:   4:bbe44766e73d5f11ed2177f1838de10c53ef3e74
   bisect:      bad (implicit)
   branch:      foo
   phase:       draft
   parent:      3:10e46f2dcbf4823578cf180f33ecf0b957964c47
   parent:      -1:0000000000000000000000000000000000000000
   manifest:    3:cb5a1327723bada42f117e4c55a303246eaf9ccc
   user:        person
   date:        Sat Jan 17 04:53:20 1970 +0000
   extra:       branch=foo
   description:
   new branch
   
   
   $ hg log -v -T bisect -r 0:4
   changeset:   0:1e4e1b8f71e0
   bisect:      good (implicit)
   user:        User Name <user@hostname>
   date:        Mon Jan 12 13:46:40 1970 +0000
   files:       a
   description:
   line 1
   line 2
   
   
   changeset:   1:b608e9d1a3f0
   bisect:      good
   user:        A. N. Other <other@place>
   date:        Tue Jan 13 17:33:20 1970 +0000
   files:       b
   description:
   other 1
   other 2
   
   other 3
   
   
   changeset:   2:97054abb4ab8
   bisect:      untested
   user:        other@place
   date:        Wed Jan 14 21:20:00 1970 +0000
   files:       c
   description:
   no person
   
   
   changeset:   3:10e46f2dcbf4
   bisect:      bad
   user:        person
   date:        Fri Jan 16 01:06:40 1970 +0000
   files:       c
   description:
   no user, no domain
   
   
   changeset:   4:bbe44766e73d
   bisect:      bad (implicit)
   branch:      foo
   user:        person
   date:        Sat Jan 17 04:53:20 1970 +0000
   description:
   new branch
   
   
   $ hg --color=debug log -T bisect -r 0:4
   [log.changeset changeset.public|changeset:   0:1e4e1b8f71e0]
   [log.bisect bisect.good|bisect:      good (implicit)]
   [log.user|user:        User Name <user@hostname>]
   [log.date|date:        Mon Jan 12 13:46:40 1970 +0000]
   [log.summary|summary:     line 1]
   
   [log.changeset changeset.public|changeset:   1:b608e9d1a3f0]
   [log.bisect bisect.good|bisect:      good]
   [log.user|user:        A. N. Other <other@place>]
   [log.date|date:        Tue Jan 13 17:33:20 1970 +0000]
   [log.summary|summary:     other 1]
   
   [log.changeset changeset.public|changeset:   2:97054abb4ab8]
   [log.bisect bisect.untested|bisect:      untested]
   [log.user|user:        other@place]
   [log.date|date:        Wed Jan 14 21:20:00 1970 +0000]
   [log.summary|summary:     no person]
   
   [log.changeset changeset.public|changeset:   3:10e46f2dcbf4]
   [log.bisect bisect.bad|bisect:      bad]
   [log.user|user:        person]
   [log.date|date:        Fri Jan 16 01:06:40 1970 +0000]
   [log.summary|summary:     no user, no domain]
   
   [log.changeset changeset.draft|changeset:   4:bbe44766e73d]
   [log.bisect bisect.bad|bisect:      bad (implicit)]
   [log.branch|branch:      foo]
   [log.user|user:        person]
   [log.date|date:        Sat Jan 17 04:53:20 1970 +0000]
   [log.summary|summary:     new branch]
   
   $ hg --color=debug log --debug -T bisect -r 0:4
   [log.changeset changeset.public|changeset:   0:1e4e1b8f71e05681d422154f5421e385fec3454f]
   [log.bisect bisect.good|bisect:      good (implicit)]
   [log.phase|phase:       public]
   [log.parent changeset.public|parent:      -1:0000000000000000000000000000000000000000]
   [log.parent changeset.public|parent:      -1:0000000000000000000000000000000000000000]
   [ui.debug log.manifest|manifest:    0:a0c8bcbbb45c63b90b70ad007bf38961f64f2af0]
   [log.user|user:        User Name <user@hostname>]
   [log.date|date:        Mon Jan 12 13:46:40 1970 +0000]
   [ui.debug log.files|files+:      a]
   [ui.debug log.extra|extra:       branch=default]
   [ui.note log.description|description:]
   [ui.note log.description|line 1
   line 2]
   
   
   [log.changeset changeset.public|changeset:   1:b608e9d1a3f0273ccf70fb85fd6866b3482bf965]
   [log.bisect bisect.good|bisect:      good]
   [log.phase|phase:       public]
   [log.parent changeset.public|parent:      0:1e4e1b8f71e05681d422154f5421e385fec3454f]
   [log.parent changeset.public|parent:      -1:0000000000000000000000000000000000000000]
   [ui.debug log.manifest|manifest:    1:4e8d705b1e53e3f9375e0e60dc7b525d8211fe55]
   [log.user|user:        A. N. Other <other@place>]
   [log.date|date:        Tue Jan 13 17:33:20 1970 +0000]
   [ui.debug log.files|files+:      b]
   [ui.debug log.extra|extra:       branch=default]
   [ui.note log.description|description:]
   [ui.note log.description|other 1
   other 2
   
   other 3]
   
   
   [log.changeset changeset.public|changeset:   2:97054abb4ab824450e9164180baf491ae0078465]
   [log.bisect bisect.untested|bisect:      untested]
   [log.phase|phase:       public]
   [log.parent changeset.public|parent:      1:b608e9d1a3f0273ccf70fb85fd6866b3482bf965]
   [log.parent changeset.public|parent:      -1:0000000000000000000000000000000000000000]
   [ui.debug log.manifest|manifest:    2:6e0e82995c35d0d57a52aca8da4e56139e06b4b1]
   [log.user|user:        other@place]
   [log.date|date:        Wed Jan 14 21:20:00 1970 +0000]
   [ui.debug log.files|files+:      c]
   [ui.debug log.extra|extra:       branch=default]
   [ui.note log.description|description:]
   [ui.note log.description|no person]
   
   
   [log.changeset changeset.public|changeset:   3:10e46f2dcbf4823578cf180f33ecf0b957964c47]
   [log.bisect bisect.bad|bisect:      bad]
   [log.phase|phase:       public]
   [log.parent changeset.public|parent:      2:97054abb4ab824450e9164180baf491ae0078465]
   [log.parent changeset.public|parent:      -1:0000000000000000000000000000000000000000]
   [ui.debug log.manifest|manifest:    3:cb5a1327723bada42f117e4c55a303246eaf9ccc]
   [log.user|user:        person]
   [log.date|date:        Fri Jan 16 01:06:40 1970 +0000]
   [ui.debug log.files|files:       c]
   [ui.debug log.extra|extra:       branch=default]
   [ui.note log.description|description:]
   [ui.note log.description|no user, no domain]
   
   
   [log.changeset changeset.draft|changeset:   4:bbe44766e73d5f11ed2177f1838de10c53ef3e74]
   [log.bisect bisect.bad|bisect:      bad (implicit)]
   [log.branch|branch:      foo]
   [log.phase|phase:       draft]
   [log.parent changeset.public|parent:      3:10e46f2dcbf4823578cf180f33ecf0b957964c47]
   [log.parent changeset.public|parent:      -1:0000000000000000000000000000000000000000]
   [ui.debug log.manifest|manifest:    3:cb5a1327723bada42f117e4c55a303246eaf9ccc]
   [log.user|user:        person]
   [log.date|date:        Sat Jan 17 04:53:20 1970 +0000]
   [ui.debug log.extra|extra:       branch=foo]
   [ui.note log.description|description:]
   [ui.note log.description|new branch]
   
   
   $ hg --color=debug log -v -T bisect -r 0:4
   [log.changeset changeset.public|changeset:   0:1e4e1b8f71e0]
   [log.bisect bisect.good|bisect:      good (implicit)]
   [log.user|user:        User Name <user@hostname>]
   [log.date|date:        Mon Jan 12 13:46:40 1970 +0000]
   [ui.note log.files|files:       a]
   [ui.note log.description|description:]
   [ui.note log.description|line 1
   line 2]
   
   
   [log.changeset changeset.public|changeset:   1:b608e9d1a3f0]
   [log.bisect bisect.good|bisect:      good]
   [log.user|user:        A. N. Other <other@place>]
   [log.date|date:        Tue Jan 13 17:33:20 1970 +0000]
   [ui.note log.files|files:       b]
   [ui.note log.description|description:]
   [ui.note log.description|other 1
   other 2
   
   other 3]
   
   
   [log.changeset changeset.public|changeset:   2:97054abb4ab8]
   [log.bisect bisect.untested|bisect:      untested]
   [log.user|user:        other@place]
   [log.date|date:        Wed Jan 14 21:20:00 1970 +0000]
   [ui.note log.files|files:       c]
   [ui.note log.description|description:]
   [ui.note log.description|no person]
   
   
   [log.changeset changeset.public|changeset:   3:10e46f2dcbf4]
   [log.bisect bisect.bad|bisect:      bad]
   [log.user|user:        person]
   [log.date|date:        Fri Jan 16 01:06:40 1970 +0000]
   [ui.note log.files|files:       c]
   [ui.note log.description|description:]
   [ui.note log.description|no user, no domain]
   
   
   [log.changeset changeset.draft|changeset:   4:bbe44766e73d]
   [log.bisect bisect.bad|bisect:      bad (implicit)]
   [log.branch|branch:      foo]
   [log.user|user:        person]
   [log.date|date:        Sat Jan 17 04:53:20 1970 +0000]
   [ui.note log.description|description:]
   [ui.note log.description|new branch]
   
   
   $ hg bisect --reset
 
 Error on syntax:
 
   $ echo 'x = "f' >> t
   $ hg log
   hg: parse error at t:3: unmatched quotes
   [255]
 
   $ hg log -T '{date'
   hg: parse error at 1: unterminated template expansion
   ({date
     ^ here)
   [255]
   $ hg log -T '{date(}'
   hg: parse error at 6: not a prefix: end
   ({date(}
          ^ here)
   [255]
   $ hg log -T '{date)}'
   hg: parse error at 5: invalid token
   ({date)}
         ^ here)
   [255]
   $ hg log -T '{date date}'
   hg: parse error at 6: invalid token
   ({date date}
          ^ here)
   [255]
 
   $ hg log -T '{}'
   hg: parse error at 1: not a prefix: end
   ({}
     ^ here)
   [255]
   $ hg debugtemplate -v '{()}'
   (template
     (group
       None))
   hg: parse error: missing argument
   [255]
 
 Behind the scenes, this would throw TypeError without intype=bytes
 
   $ hg log -l 3 --template '{date|obfuscate}\n'
   &#48;&#46;&#48;&#48;
   &#48;&#46;&#48;&#48;
   &#49;&#53;&#55;&#55;&#56;&#55;&#50;&#56;&#54;&#48;&#46;&#48;&#48;
 
 Behind the scenes, this will throw a ValueError
 
   $ hg log -l 3 --template 'line: {desc|shortdate}\n'
   hg: parse error: invalid date: 'Modify, add, remove, rename'
   (template filter 'shortdate' is not compatible with keyword 'desc')
   [255]
 
 Behind the scenes, this would throw AttributeError without intype=bytes
 
   $ hg log -l 3 --template 'line: {date|escape}\n'
   line: 0.00
   line: 0.00
   line: 1577872860.00
 
   $ hg log -l 3 --template 'line: {extras|localdate}\n'
   hg: parse error: localdate expects a date information
   [255]
 
 Behind the scenes, this will throw ValueError
 
   $ hg tip --template '{author|email|date}\n'
   hg: parse error: date expects a date information
   [255]
 
   $ hg tip -T '{author|email|shortdate}\n'
   hg: parse error: invalid date: 'test'
   (template filter 'shortdate' is not compatible with keyword 'author')
   [255]
 
   $ hg tip -T '{get(extras, "branch")|shortdate}\n'
   hg: parse error: invalid date: 'default'
   (incompatible use of template filter 'shortdate')
   [255]
 
 Error in nested template:
 
   $ hg log -T '{"date'
   hg: parse error at 2: unterminated string
   ({"date
      ^ here)
   [255]
 
   $ hg log -T '{"foo{date|?}"}'
   hg: parse error at 11: syntax error
   ({"foo{date|?}"}
               ^ here)
   [255]
 
 Thrown an error if a template function doesn't exist
 
   $ hg tip --template '{foo()}\n'
   hg: parse error: unknown function 'foo'
   [255]
 
 Pass generator object created by template function to filter
 
   $ hg log -l 1 --template '{if(author, author)|user}\n'
   test
 
 Test index keyword:
 
   $ hg log -l 2 -T '{index + 10}{files % " {index}:{file}"}\n'
   10 0:a 1:b 2:fifth 3:fourth 4:third
   11 0:a
 
   $ hg branches -T '{index} {branch}\n'
   0 default
   1 foo
 
 Test diff function:
 
   $ hg diff -c 8
   diff -r 29114dbae42b -r 95c24699272e fourth
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/fourth	Wed Jan 01 10:01:00 2020 +0000
   @@ -0,0 +1,1 @@
   +second
   diff -r 29114dbae42b -r 95c24699272e second
   --- a/second	Mon Jan 12 13:46:40 1970 +0000
   +++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
   @@ -1,1 +0,0 @@
   -second
   diff -r 29114dbae42b -r 95c24699272e third
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/third	Wed Jan 01 10:01:00 2020 +0000
   @@ -0,0 +1,1 @@
   +third
 
   $ hg log -r 8 -T "{diff()}"
   diff -r 29114dbae42b -r 95c24699272e fourth
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/fourth	Wed Jan 01 10:01:00 2020 +0000
   @@ -0,0 +1,1 @@
   +second
   diff -r 29114dbae42b -r 95c24699272e second
   --- a/second	Mon Jan 12 13:46:40 1970 +0000
   +++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
   @@ -1,1 +0,0 @@
   -second
   diff -r 29114dbae42b -r 95c24699272e third
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/third	Wed Jan 01 10:01:00 2020 +0000
   @@ -0,0 +1,1 @@
   +third
 
   $ hg log -r 8 -T "{diff('glob:f*')}"
   diff -r 29114dbae42b -r 95c24699272e fourth
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/fourth	Wed Jan 01 10:01:00 2020 +0000
   @@ -0,0 +1,1 @@
   +second
 
   $ hg log -r 8 -T "{diff('', 'glob:f*')}"
   diff -r 29114dbae42b -r 95c24699272e second
   --- a/second	Mon Jan 12 13:46:40 1970 +0000
   +++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
   @@ -1,1 +0,0 @@
   -second
   diff -r 29114dbae42b -r 95c24699272e third
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/third	Wed Jan 01 10:01:00 2020 +0000
   @@ -0,0 +1,1 @@
   +third
 
   $ hg log -r 8 -T "{diff('FOURTH'|lower)}"
   diff -r 29114dbae42b -r 95c24699272e fourth
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/fourth	Wed Jan 01 10:01:00 2020 +0000
   @@ -0,0 +1,1 @@
   +second
 
 ui verbosity:
 
   $ hg log -l1 -T '{verbosity}\n'
   
   $ hg log -l1 -T '{verbosity}\n' --debug
   debug
   $ hg log -l1 -T '{verbosity}\n' --quiet
   quiet
   $ hg log -l1 -T '{verbosity}\n' --verbose
   verbose
 
   $ cd ..
 
 
 latesttag:
 
   $ hg init latesttag
   $ cd latesttag
 
   $ echo a > file
   $ hg ci -Am a -d '0 0'
   adding file
 
   $ echo b >> file
   $ hg ci -m b -d '1 0'
 
   $ echo c >> head1
   $ hg ci -Am h1c -d '2 0'
   adding head1
 
   $ hg update -q 1
   $ echo d >> head2
   $ hg ci -Am h2d -d '3 0'
   adding head2
   created new head
 
   $ echo e >> head2
   $ hg ci -m h2e -d '4 0'
 
   $ hg merge -q
   $ hg ci -m merge -d '5 -3600'
 
 No tag set:
 
   $ hg log -G --template '{rev}: {latesttag}+{latesttagdistance}\n'
   @    5: null+5
   |\
   | o  4: null+4
   | |
   | o  3: null+3
   | |
   o |  2: null+3
   |/
   o  1: null+2
   |
   o  0: null+1
   
 
 One common tag: longest path wins for {latesttagdistance}:
 
   $ hg tag -r 1 -m t1 -d '6 0' t1
   $ hg log -G --template '{rev}: {latesttag}+{latesttagdistance}\n'
   @  6: t1+4
   |
   o    5: t1+3
   |\
   | o  4: t1+2
   | |
   | o  3: t1+1
   | |
   o |  2: t1+1
   |/
   o  1: t1+0
   |
   o  0: null+1
   
 
 One ancestor tag: closest wins:
 
   $ hg tag -r 2 -m t2 -d '7 0' t2
   $ hg log -G --template '{rev}: {latesttag}+{latesttagdistance}\n'
   @  7: t2+3
   |
   o  6: t2+2
   |
   o    5: t2+1
   |\
   | o  4: t1+2
   | |
   | o  3: t1+1
   | |
   o |  2: t2+0
   |/
   o  1: t1+0
   |
   o  0: null+1
   
 
 Two branch tags: more recent wins if same number of changes:
 
   $ hg tag -r 3 -m t3 -d '8 0' t3
   $ hg log -G --template '{rev}: {latesttag}+{latesttagdistance}\n'
   @  8: t3+5
   |
   o  7: t3+4
   |
   o  6: t3+3
   |
   o    5: t3+2
   |\
   | o  4: t3+1
   | |
   | o  3: t3+0
   | |
   o |  2: t2+0
   |/
   o  1: t1+0
   |
   o  0: null+1
   
 
 Two branch tags: fewest changes wins:
 
   $ hg tag -r 4 -m t4 -d '4 0' t4 # older than t2, but should not matter
   $ hg log -G --template "{rev}: {latesttag % '{tag}+{distance},{changes} '}\n"
   @  9: t4+5,6
   |
   o  8: t4+4,5
   |
   o  7: t4+3,4
   |
   o  6: t4+2,3
   |
   o    5: t4+1,2
   |\
   | o  4: t4+0,0
   | |
   | o  3: t3+0,0
   | |
   o |  2: t2+0,0
   |/
   o  1: t1+0,0
   |
   o  0: null+1,1
   
 
 Merged tag overrides:
 
   $ hg tag -r 5 -m t5 -d '9 0' t5
   $ hg tag -r 3 -m at3 -d '10 0' at3
   $ hg log -G --template '{rev}: {latesttag}+{latesttagdistance}\n'
   @  11: t5+6
   |
   o  10: t5+5
   |
   o  9: t5+4
   |
   o  8: t5+3
   |
   o  7: t5+2
   |
   o  6: t5+1
   |
   o    5: t5+0
   |\
   | o  4: t4+0
   | |
   | o  3: at3:t3+0
   | |
   o |  2: t2+0
   |/
   o  1: t1+0
   |
   o  0: null+1
   
 
   $ hg log -G --template "{rev}: {latesttag % '{tag}+{distance},{changes} '}\n"
   @  11: t5+6,6
   |
   o  10: t5+5,5
   |
   o  9: t5+4,4
   |
   o  8: t5+3,3
   |
   o  7: t5+2,2
   |
   o  6: t5+1,1
   |
   o    5: t5+0,0
   |\
   | o  4: t4+0,0
   | |
   | o  3: at3+0,0 t3+0,0
   | |
   o |  2: t2+0,0
   |/
   o  1: t1+0,0
   |
   o  0: null+1,1
   
 
   $ hg log -G --template "{rev}: {latesttag('re:^t[13]$') % '{tag}, C: {changes}, D: {distance}'}\n"
   @  11: t3, C: 9, D: 8
   |
   o  10: t3, C: 8, D: 7
   |
   o  9: t3, C: 7, D: 6
   |
   o  8: t3, C: 6, D: 5
   |
   o  7: t3, C: 5, D: 4
   |
   o  6: t3, C: 4, D: 3
   |
   o    5: t3, C: 3, D: 2
   |\
   | o  4: t3, C: 1, D: 1
   | |
   | o  3: t3, C: 0, D: 0
   | |
   o |  2: t1, C: 1, D: 1
   |/
   o  1: t1, C: 0, D: 0
   |
   o  0: null, C: 1, D: 1
   
 
   $ cd ..
 
 
 Style path expansion: issue1948 - ui.style option doesn't work on OSX
 if it is a relative path
 
   $ mkdir -p home/styles
 
   $ cat > home/styles/teststyle <<EOF
   > changeset = 'test {rev}:{node|short}\n'
   > EOF
 
   $ HOME=`pwd`/home; export HOME
 
   $ cat > latesttag/.hg/hgrc <<EOF
   > [ui]
   > style = ~/styles/teststyle
   > EOF
 
   $ hg -R latesttag tip
   test 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,test
   branch: test
 
 Test new-style inline templating:
 
   $ hg log -R latesttag -r tip --template 'modified files: {file_mods % " {file}\n"}\n'
   modified files:  .hgtags
   
 
   $ hg log -R latesttag -r tip -T '{rev % "a"}\n'
   hg: parse error: 11 is not iterable of mappings
   [255]
   $ hg log -R latesttag -r tip -T '{get(extras, "unknown") % "a"}\n'
   hg: parse error: None is not iterable of mappings
   [255]
   $ hg log -R latesttag -r tip -T '{extras % "{key}\n" % "{key}\n"}'
   hg: parse error: list of strings is not mappable
   [255]
 
 Test new-style inline templating of non-list/dict type:
 
   $ hg log -R latesttag -r tip -T '{manifest}\n'
   11:2bc6e9006ce2
   $ hg log -R latesttag -r tip -T 'string length: {manifest|count}\n'
   string length: 15
   $ hg log -R latesttag -r tip -T '{manifest % "{rev}:{node}"}\n'
   11:2bc6e9006ce29882383a22d39fd1f4e66dd3e2fc
 
   $ hg log -R latesttag -r tip -T '{get(extras, "branch") % "{key}: {value}\n"}'
   branch: default
   $ hg log -R latesttag -r tip -T '{get(extras, "unknown") % "{key}\n"}'
   hg: parse error: None is not iterable of mappings
   [255]
   $ hg log -R latesttag -r tip -T '{min(extras) % "{key}: {value}\n"}'
   branch: default
   $ hg log -R latesttag -l1 -T '{min(revset("0:9")) % "{rev}:{node|short}\n"}'
   0:ce3cec86e6c2
   $ hg log -R latesttag -l1 -T '{max(revset("0:9")) % "{rev}:{node|short}\n"}'
   9:fbc7cd862e9c
 
 Test manifest/get() can be join()-ed as string, though it's silly:
 
   $ hg log -R latesttag -r tip -T '{join(manifest, ".")}\n'
   1.1.:.2.b.c.6.e.9.0.0.6.c.e.2
   $ hg log -R latesttag -r tip -T '{join(get(extras, "branch"), ".")}\n'
   d.e.f.a.u.l.t
 
 Test join() over string
 
   $ hg log -R latesttag -r tip -T '{join(rev|stringify, ".")}\n'
   1.1
 
 Test join() over uniterable
 
   $ hg log -R latesttag -r tip -T '{join(rev, "")}\n'
   hg: parse error: 11 is not iterable
   [255]
 
 Test min/max of integers
 
   $ hg log -R latesttag -l1 -T '{min(revset("9:10"))}\n'
   9
   $ hg log -R latesttag -l1 -T '{max(revset("9:10"))}\n'
   10
 
 Test min/max over map operation:
 
   $ hg log -R latesttag -r3 -T '{min(tags % "{tag}")}\n'
   at3
   $ hg log -R latesttag -r3 -T '{max(tags % "{tag}")}\n'
   t3
 
 Test min/max of strings:
 
   $ hg log -R latesttag -l1 -T '{min(desc)}\n'
   3
   $ hg log -R latesttag -l1 -T '{max(desc)}\n'
   t
 
 Test min/max of non-iterable:
 
   $ hg debugtemplate '{min(1)}'
   hg: parse error: 1 is not iterable
   (min first argument should be an iterable)
   [255]
   $ hg debugtemplate '{max(2)}'
   hg: parse error: 2 is not iterable
   (max first argument should be an iterable)
   [255]
 
 Test min/max of empty sequence:
 
   $ hg debugtemplate '{min("")}'
   hg: parse error: empty string
   (min first argument should be an iterable)
   [255]
   $ hg debugtemplate '{max("")}'
   hg: parse error: empty string
   (max first argument should be an iterable)
   [255]
   $ hg debugtemplate '{min(dict())}'
   hg: parse error: empty sequence
   (min first argument should be an iterable)
   [255]
   $ hg debugtemplate '{max(dict())}'
   hg: parse error: empty sequence
   (max first argument should be an iterable)
   [255]
   $ hg debugtemplate '{min(dict() % "")}'
   hg: parse error: empty sequence
   (min first argument should be an iterable)
   [255]
   $ hg debugtemplate '{max(dict() % "")}'
   hg: parse error: empty sequence
   (max first argument should be an iterable)
   [255]
 
 Test min/max of if() result
 
   $ cd latesttag
   $ hg log -l1 -T '{min(if(true, revset("9:10"), ""))}\n'
   9
   $ hg log -l1 -T '{max(if(false, "", revset("9:10")))}\n'
   10
   $ hg log -l1 -T '{min(ifcontains("a", "aa", revset("9:10"), ""))}\n'
   9
   $ hg log -l1 -T '{max(ifcontains("a", "bb", "", revset("9:10")))}\n'
   10
   $ hg log -l1 -T '{min(ifeq(0, 0, revset("9:10"), ""))}\n'
   9
   $ hg log -l1 -T '{max(ifeq(0, 1, "", revset("9:10")))}\n'
   10
   $ cd ..
 
 Test laziness of if() then/else clause
 
   $ hg debugtemplate '{count(0)}'
   hg: parse error: not countable
   (incompatible use of template filter 'count')
   [255]
   $ hg debugtemplate '{if(true, "", count(0))}'
   $ hg debugtemplate '{if(false, count(0), "")}'
   $ hg debugtemplate '{ifcontains("a", "aa", "", count(0))}'
   $ hg debugtemplate '{ifcontains("a", "bb", count(0), "")}'
   $ hg debugtemplate '{ifeq(0, 0, "", count(0))}'
   $ hg debugtemplate '{ifeq(0, 1, count(0), "")}'
 
 Test dot operator precedence:
 
   $ hg debugtemplate -R latesttag -r0 -v '{manifest.node|short}\n'
   (template
     (|
       (.
         (symbol 'manifest')
         (symbol 'node'))
       (symbol 'short'))
     (string '\n'))
   89f4071fec70
 
  (the following examples are invalid, but seem natural in parsing POV)
 
   $ hg debugtemplate -R latesttag -r0 -v '{foo|bar.baz}\n' 2> /dev/null
   (template
     (|
       (symbol 'foo')
       (.
         (symbol 'bar')
         (symbol 'baz')))
     (string '\n'))
   [255]
   $ hg debugtemplate -R latesttag -r0 -v '{foo.bar()}\n' 2> /dev/null
   (template
     (.
       (symbol 'foo')
       (func
         (symbol 'bar')
         None))
     (string '\n'))
   [255]
 
 Test evaluation of dot operator:
 
   $ hg log -R latesttag -l1 -T '{min(revset("0:9")).node}\n'
   ce3cec86e6c26bd9bdfc590a6b92abc9680f1796
   $ hg log -R latesttag -r0 -T '{extras.branch}\n'
   default
 
   $ hg log -R latesttag -l1 -T '{author.invalid}\n'
   hg: parse error: 'test' is not a dictionary
   (keyword 'author' does not support member operation)
   [255]
   $ hg log -R latesttag -l1 -T '{min("abc").invalid}\n'
   hg: parse error: 'a' is not a dictionary
   [255]
 
 Test the sub function of templating for expansion:
 
   $ hg log -R latesttag -r 10 --template '{sub("[0-9]", "x", "{rev}")}\n'
   xx
 
   $ hg log -R latesttag -r 10 -T '{sub("[", "x", rev)}\n'
   hg: parse error: sub got an invalid pattern: [
   [255]
   $ hg log -R latesttag -r 10 -T '{sub("[0-9]", r"\1", rev)}\n'
   hg: parse error: sub got an invalid replacement: \1
   [255]
 
 Test the strip function with chars specified:
 
   $ hg log -R latesttag --template '{desc}\n'
   at3
   t5
   t4
   t3
   t2
   t1
   merge
   h2e
   h2d
   h1c
   b
   a
 
   $ hg log -R latesttag --template '{strip(desc, "te")}\n'
   at3
   5
   4
   3
   2
   1
   merg
   h2
   h2d
   h1c
   b
   a
 
 Test date format:
 
   $ hg log -R latesttag --template 'date: {date(date, "%y %m %d %S %z")}\n'
   date: 70 01 01 10 +0000
   date: 70 01 01 09 +0000
   date: 70 01 01 04 +0000
   date: 70 01 01 08 +0000
   date: 70 01 01 07 +0000
   date: 70 01 01 06 +0000
   date: 70 01 01 05 +0100
   date: 70 01 01 04 +0000
   date: 70 01 01 03 +0000
   date: 70 01 01 02 +0000
   date: 70 01 01 01 +0000
   date: 70 01 01 00 +0000
 
 Test invalid date:
 
   $ hg log -R latesttag -T '{date(rev)}\n'
   hg: parse error: date expects a date information
   [255]
 
 Test integer literal:
 
   $ hg debugtemplate -v '{(0)}\n'
   (template
     (group
       (integer '0'))
     (string '\n'))
   0
   $ hg debugtemplate -v '{(123)}\n'
   (template
     (group
       (integer '123'))
     (string '\n'))
   123
   $ hg debugtemplate -v '{(-4)}\n'
   (template
     (group
       (negate
         (integer '4')))
     (string '\n'))
   -4
   $ hg debugtemplate '{(-)}\n'
   hg: parse error at 3: not a prefix: )
   ({(-)}\n
       ^ here)
   [255]
   $ hg debugtemplate '{(-a)}\n'
   hg: parse error: negation needs an integer argument
   [255]
 
 top-level integer literal is interpreted as symbol (i.e. variable name):
 
   $ hg debugtemplate -D 1=one -v '{1}\n'
   (template
     (integer '1')
     (string '\n'))
   one
   $ hg debugtemplate -D 1=one -v '{if("t", "{1}")}\n'
   (template
     (func
       (symbol 'if')
       (list
         (string 't')
         (template
           (integer '1'))))
     (string '\n'))
   one
   $ hg debugtemplate -D 1=one -v '{1|stringify}\n'
   (template
     (|
       (integer '1')
       (symbol 'stringify'))
     (string '\n'))
   one
 
 unless explicit symbol is expected:
 
   $ hg log -Ra -r0 -T '{desc|1}\n'
   hg: parse error: expected a symbol, got 'integer'
   [255]
   $ hg log -Ra -r0 -T '{1()}\n'
   hg: parse error: expected a symbol, got 'integer'
   [255]
 
 Test string literal:
 
   $ hg debugtemplate -Ra -r0 -v '{"string with no template fragment"}\n'
   (template
     (string 'string with no template fragment')
     (string '\n'))
   string with no template fragment
   $ hg debugtemplate -Ra -r0 -v '{"template: {rev}"}\n'
   (template
     (template
       (string 'template: ')
       (symbol 'rev'))
     (string '\n'))
   template: 0
   $ hg debugtemplate -Ra -r0 -v '{r"rawstring: {rev}"}\n'
   (template
     (string 'rawstring: {rev}')
     (string '\n'))
   rawstring: {rev}
   $ hg debugtemplate -Ra -r0 -v '{files % r"rawstring: {file}"}\n'
   (template
     (%
       (symbol 'files')
       (string 'rawstring: {file}'))
     (string '\n'))
   rawstring: {file}
 
 Test string escaping:
 
   $ hg log -R latesttag -r 0 --template '>\n<>\\n<{if(rev, "[>\n<>\\n<]")}>\n<>\\n<\n'
   >
   <>\n<[>
   <>\n<]>
   <>\n<
 
   $ hg log -R latesttag -r 0 \
   > --config ui.logtemplate='>\n<>\\n<{if(rev, "[>\n<>\\n<]")}>\n<>\\n<\n'
   >
   <>\n<[>
   <>\n<]>
   <>\n<
 
   $ hg log -R latesttag -r 0 -T esc \
   > --config templates.esc='>\n<>\\n<{if(rev, "[>\n<>\\n<]")}>\n<>\\n<\n'
   >
   <>\n<[>
   <>\n<]>
   <>\n<
 
   $ cat <<'EOF' > esctmpl
   > changeset = '>\n<>\\n<{if(rev, "[>\n<>\\n<]")}>\n<>\\n<\n'
   > EOF
   $ hg log -R latesttag -r 0 --style ./esctmpl
   >
   <>\n<[>
   <>\n<]>
   <>\n<
 
 Test string escaping of quotes:
 
   $ hg log -Ra -r0 -T '{"\""}\n'
   "
   $ hg log -Ra -r0 -T '{"\\\""}\n'
   \"
   $ hg log -Ra -r0 -T '{r"\""}\n'
   \"
   $ hg log -Ra -r0 -T '{r"\\\""}\n'
   \\\"
 
 
   $ hg log -Ra -r0 -T '{"\""}\n'
   "
   $ hg log -Ra -r0 -T '{"\\\""}\n'
   \"
   $ hg log -Ra -r0 -T '{r"\""}\n'
   \"
   $ hg log -Ra -r0 -T '{r"\\\""}\n'
   \\\"
 
 Test exception in quoted template. single backslash before quotation mark is
 stripped before parsing:
 
   $ cat <<'EOF' > escquotetmpl
   > changeset = "\" \\" \\\" \\\\" {files % \"{file}\"}\n"
   > EOF
   $ cd latesttag
   $ hg log -r 2 --style ../escquotetmpl
   " \" \" \\" head1
 
   $ hg log -r 2 -T esc --config templates.esc='"{\"valid\"}\n"'
   valid
   $ hg log -r 2 -T esc --config templates.esc="'"'{\'"'"'valid\'"'"'}\n'"'"
   valid
 
 Test compatibility with 2.9.2-3.4 of escaped quoted strings in nested
 _evalifliteral() templates (issue4733):
 
   $ hg log -r 2 -T '{if(rev, "\"{rev}")}\n'
   "2
   $ hg log -r 2 -T '{if(rev, "{if(rev, \"\\\"{rev}\")}")}\n'
   "2
   $ hg log -r 2 -T '{if(rev, "{if(rev, \"{if(rev, \\\"\\\\\\\"{rev}\\\")}\")}")}\n'
   "2
 
   $ hg log -r 2 -T '{if(rev, "\\\"")}\n'
   \"
   $ hg log -r 2 -T '{if(rev, "{if(rev, \"\\\\\\\"\")}")}\n'
   \"
   $ hg log -r 2 -T '{if(rev, "{if(rev, \"{if(rev, \\\"\\\\\\\\\\\\\\\"\\\")}\")}")}\n'
   \"
 
   $ hg log -r 2 -T '{if(rev, r"\\\"")}\n'
   \\\"
   $ hg log -r 2 -T '{if(rev, "{if(rev, r\"\\\\\\\"\")}")}\n'
   \\\"
   $ hg log -r 2 -T '{if(rev, "{if(rev, \"{if(rev, r\\\"\\\\\\\\\\\\\\\"\\\")}\")}")}\n'
   \\\"
 
 escaped single quotes and errors:
 
   $ hg log -r 2 -T "{if(rev, '{if(rev, \'foo\')}')}"'\n'
   foo
   $ hg log -r 2 -T "{if(rev, '{if(rev, r\'foo\')}')}"'\n'
   foo
   $ hg log -r 2 -T '{if(rev, "{if(rev, \")}")}\n'
   hg: parse error at 21: unterminated string
   ({if(rev, "{if(rev, \")}")}\n
                         ^ here)
   [255]
   $ hg log -r 2 -T '{if(rev, \"\\"")}\n'
   hg: parse error: trailing \ in string
   [255]
   $ hg log -r 2 -T '{if(rev, r\"\\"")}\n'
   hg: parse error: trailing \ in string
   [255]
 
   $ cd ..
 
 Test leading backslashes:
 
   $ cd latesttag
   $ hg log -r 2 -T '\{rev} {files % "\{file}"}\n'
   {rev} {file}
   $ hg log -r 2 -T '\\{rev} {files % "\\{file}"}\n'
   \2 \head1
   $ hg log -r 2 -T '\\\{rev} {files % "\\\{file}"}\n'
   \{rev} \{file}
   $ cd ..
 
 Test leading backslashes in "if" expression (issue4714):
 
   $ cd latesttag
   $ hg log -r 2 -T '{if("1", "\{rev}")} {if("1", r"\{rev}")}\n'
   {rev} \{rev}
   $ hg log -r 2 -T '{if("1", "\\{rev}")} {if("1", r"\\{rev}")}\n'
   \2 \\{rev}
   $ hg log -r 2 -T '{if("1", "\\\{rev}")} {if("1", r"\\\{rev}")}\n'
   \{rev} \\\{rev}
   $ cd ..
 
 "string-escape"-ed "\x5c\x786e" becomes r"\x6e" (once) or r"n" (twice)
 
   $ hg log -R a -r 0 --template '{if("1", "\x5c\x786e", "NG")}\n'
   \x6e
   $ hg log -R a -r 0 --template '{if("1", r"\x5c\x786e", "NG")}\n'
   \x5c\x786e
   $ hg log -R a -r 0 --template '{if("", "NG", "\x5c\x786e")}\n'
   \x6e
   $ hg log -R a -r 0 --template '{if("", "NG", r"\x5c\x786e")}\n'
   \x5c\x786e
 
   $ hg log -R a -r 2 --template '{ifeq("no perso\x6e", desc, "\x5c\x786e", "NG")}\n'
   \x6e
   $ hg log -R a -r 2 --template '{ifeq(r"no perso\x6e", desc, "NG", r"\x5c\x786e")}\n'
   \x5c\x786e
   $ hg log -R a -r 2 --template '{ifeq(desc, "no perso\x6e", "\x5c\x786e", "NG")}\n'
   \x6e
   $ hg log -R a -r 2 --template '{ifeq(desc, r"no perso\x6e", "NG", r"\x5c\x786e")}\n'
   \x5c\x786e
 
   $ hg log -R a -r 8 --template '{join(files, "\n")}\n'
   fourth
   second
   third
   $ hg log -R a -r 8 --template '{join(files, r"\n")}\n'
   fourth\nsecond\nthird
 
   $ hg log -R a -r 2 --template '{rstdoc("1st\n\n2nd", "htm\x6c")}'
   <p>
   1st
   </p>
   <p>
   2nd
   </p>
   $ hg log -R a -r 2 --template '{rstdoc(r"1st\n\n2nd", "html")}'
   <p>
   1st\n\n2nd
   </p>
   $ hg log -R a -r 2 --template '{rstdoc("1st\n\n2nd", r"htm\x6c")}'
   1st
   
   2nd
 
   $ hg log -R a -r 2 --template '{strip(desc, "\x6e")}\n'
   o perso
   $ hg log -R a -r 2 --template '{strip(desc, r"\x6e")}\n'
   no person
   $ hg log -R a -r 2 --template '{strip("no perso\x6e", "\x6e")}\n'
   o perso
   $ hg log -R a -r 2 --template '{strip(r"no perso\x6e", r"\x6e")}\n'
   no perso
 
   $ hg log -R a -r 2 --template '{sub("\\x6e", "\x2d", desc)}\n'
   -o perso-
   $ hg log -R a -r 2 --template '{sub(r"\\x6e", "-", desc)}\n'
   no person
   $ hg log -R a -r 2 --template '{sub("n", r"\x2d", desc)}\n'
   \x2do perso\x2d
   $ hg log -R a -r 2 --template '{sub("n", "\x2d", "no perso\x6e")}\n'
   -o perso-
   $ hg log -R a -r 2 --template '{sub("n", r"\x2d", r"no perso\x6e")}\n'
   \x2do perso\x6e
 
   $ hg log -R a -r 8 --template '{files % "{file}\n"}'
   fourth
   second
   third
 
 Test string escaping in nested expression:
 
   $ hg log -R a -r 8 --template '{ifeq(r"\x6e", if("1", "\x5c\x786e"), join(files, "\x5c\x786e"))}\n'
   fourth\x6esecond\x6ethird
   $ hg log -R a -r 8 --template '{ifeq(if("1", r"\x6e"), "\x5c\x786e", join(files, "\x5c\x786e"))}\n'
   fourth\x6esecond\x6ethird
 
   $ hg log -R a -r 8 --template '{join(files, ifeq(branch, "default", "\x5c\x786e"))}\n'
   fourth\x6esecond\x6ethird
   $ hg log -R a -r 8 --template '{join(files, ifeq(branch, "default", r"\x5c\x786e"))}\n'
   fourth\x5c\x786esecond\x5c\x786ethird
 
   $ hg log -R a -r 3:4 --template '{rev}:{sub(if("1", "\x6e"), ifeq(branch, "foo", r"\x5c\x786e", "\x5c\x786e"), desc)}\n'
   3:\x6eo user, \x6eo domai\x6e
   4:\x5c\x786eew bra\x5c\x786ech
 
 Test quotes in nested expression are evaluated just like a $(command)
 substitution in POSIX shells:
 
   $ hg log -R a -r 8 -T '{"{"{rev}:{node|short}"}"}\n'
   8:95c24699272e
   $ hg log -R a -r 8 -T '{"{"\{{rev}} \"{node|short}\""}"}\n'
   {8} "95c24699272e"
 
 Test recursive evaluation:
 
   $ hg init r
   $ cd r
   $ echo a > a
   $ hg ci -Am '{rev}'
   adding a
   $ hg log -r 0 --template '{if(rev, desc)}\n'
   {rev}
   $ hg log -r 0 --template '{if(rev, "{author} {rev}")}\n'
   test 0
 
   $ hg branch -q 'text.{rev}'
   $ echo aa >> aa
   $ hg ci -u '{node|short}' -m 'desc to be wrapped desc to be wrapped'
 
   $ hg log -l1 --template '{fill(desc, "20", author, branch)}'
   {node|short}desc to
   text.{rev}be wrapped
   text.{rev}desc to be
   text.{rev}wrapped (no-eol)
   $ hg log -l1 --template '{fill(desc, "20", "{node|short}:", "text.{rev}:")}'
   bcc7ff960b8e:desc to
   text.1:be wrapped
   text.1:desc to be
   text.1:wrapped (no-eol)
   $ hg log -l1 -T '{fill(desc, date, "", "")}\n'
   hg: parse error: fill expects an integer width
   [255]
 
   $ COLUMNS=25 hg log -l1 --template '{fill(desc, termwidth, "{node|short}:", "termwidth.{rev}:")}'
   bcc7ff960b8e:desc to be
   termwidth.1:wrapped desc
   termwidth.1:to be wrapped (no-eol)
 
   $ hg log -l 1 --template '{sub(r"[0-9]", "-", author)}'
   {node|short} (no-eol)
   $ hg log -l 1 --template '{sub(r"[0-9]", "-", "{node|short}")}'
   bcc-ff---b-e (no-eol)
 
   $ cat >> .hg/hgrc <<EOF
   > [extensions]
   > color=
   > [color]
   > mode=ansi
   > text.{rev} = red
   > text.1 = green
   > EOF
   $ hg log --color=always -l 1 --template '{label(branch, "text\n")}'
   \x1b[0;31mtext\x1b[0m (esc)
   $ hg log --color=always -l 1 --template '{label("text.{rev}", "text\n")}'
   \x1b[0;32mtext\x1b[0m (esc)
 
 color effect can be specified without quoting:
 
   $ hg log --color=always -l 1 --template '{label(red, "text\n")}'
   \x1b[0;31mtext\x1b[0m (esc)
 
 color effects can be nested (issue5413)
 
   $ hg debugtemplate --color=always \
   > '{label(red, "red{label(magenta, "ma{label(cyan, "cyan")}{label(yellow, "yellow")}genta")}")}\n'
   \x1b[0;31mred\x1b[0;35mma\x1b[0;36mcyan\x1b[0m\x1b[0;31m\x1b[0;35m\x1b[0;33myellow\x1b[0m\x1b[0;31m\x1b[0;35mgenta\x1b[0m (esc)
 
 pad() should interact well with color codes (issue5416)
 
   $ hg debugtemplate --color=always \
   > '{pad(label(red, "red"), 5, label(cyan, "-"))}\n'
   \x1b[0;31mred\x1b[0m\x1b[0;36m-\x1b[0m\x1b[0;36m-\x1b[0m (esc)
 
 label should be no-op if color is disabled:
 
   $ hg log --color=never -l 1 --template '{label(red, "text\n")}'
   text
   $ hg log --config extensions.color=! -l 1 --template '{label(red, "text\n")}'
   text
 
 Test branches inside if statement:
 
   $ hg log -r 0 --template '{if(branches, "yes", "no")}\n'
   no
 
 Test dict constructor:
 
   $ hg log -r 0 -T '{dict(y=node|short, x=rev)}\n'
   y=f7769ec2ab97 x=0
   $ hg log -r 0 -T '{dict(x=rev, y=node|short) % "{key}={value}\n"}'
   x=0
   y=f7769ec2ab97
   $ hg log -r 0 -T '{dict(x=rev, y=node|short)|json}\n'
   {"x": 0, "y": "f7769ec2ab97"}
   $ hg log -r 0 -T '{dict()|json}\n'
   {}
 
   $ hg log -r 0 -T '{dict(rev, node=node|short)}\n'
   rev=0 node=f7769ec2ab97
   $ hg log -r 0 -T '{dict(rev, node|short)}\n'
   rev=0 node=f7769ec2ab97
 
   $ hg log -r 0 -T '{dict(rev, rev=rev)}\n'
   hg: parse error: duplicated dict key 'rev' inferred
   [255]
   $ hg log -r 0 -T '{dict(node, node|short)}\n'
   hg: parse error: duplicated dict key 'node' inferred
   [255]
   $ hg log -r 0 -T '{dict(1 + 2)}'
   hg: parse error: dict key cannot be inferred
   [255]
 
   $ hg log -r 0 -T '{dict(x=rev, x=node)}'
   hg: parse error: dict got multiple values for keyword argument 'x'
   [255]
 
 Test get function:
 
   $ hg log -r 0 --template '{get(extras, "branch")}\n'
   default
   $ hg log -r 0 --template '{get(extras, "br{"anch"}")}\n'
   default
   $ hg log -r 0 --template '{get(files, "should_fail")}\n'
   hg: parse error: not a dictionary
   (get() expects a dict as first argument)
   [255]
 
 Test json filter applied to hybrid object:
 
   $ hg log -r0 -T '{files|json}\n'
   ["a"]
   $ hg log -r0 -T '{extras|json}\n'
   {"branch": "default"}
 
 Test json filter applied to map result:
 
   $ hg log -r0 -T '{json(extras % "{key}")}\n'
   ["branch"]
 
 Test localdate(date, tz) function:
 
   $ TZ=JST-09 hg log -r0 -T '{date|localdate|isodate}\n'
   1970-01-01 09:00 +0900
   $ TZ=JST-09 hg log -r0 -T '{localdate(date, "UTC")|isodate}\n'
   1970-01-01 00:00 +0000
   $ TZ=JST-09 hg log -r0 -T '{localdate(date, "blahUTC")|isodate}\n'
   hg: parse error: localdate expects a timezone
   [255]
   $ TZ=JST-09 hg log -r0 -T '{localdate(date, "+0200")|isodate}\n'
   1970-01-01 02:00 +0200
   $ TZ=JST-09 hg log -r0 -T '{localdate(date, "0")|isodate}\n'
   1970-01-01 00:00 +0000
   $ TZ=JST-09 hg log -r0 -T '{localdate(date, 0)|isodate}\n'
   1970-01-01 00:00 +0000
   $ hg log -r0 -T '{localdate(date, "invalid")|isodate}\n'
   hg: parse error: localdate expects a timezone
   [255]
   $ hg log -r0 -T '{localdate(date, date)|isodate}\n'
   hg: parse error: localdate expects a timezone
   [255]
 
 Test shortest(node) function:
 
   $ echo b > b
   $ hg ci -qAm b
   $ hg log --template '{shortest(node)}\n'
   e777
   bcc7
   f776
   $ hg log --template '{shortest(node, 10)}\n'
   e777603221
   bcc7ff960b
   f7769ec2ab
   $ hg log --template '{node|shortest}\n' -l1
   e777
 
   $ hg log -r 0 -T '{shortest(node, "1{"0"}")}\n'
   f7769ec2ab
   $ hg log -r 0 -T '{shortest(node, "not an int")}\n'
   hg: parse error: shortest() expects an integer minlength
   [255]
 
   $ hg log -r 'wdir()' -T '{node|shortest}\n'
   ffff
 
   $ hg log --template '{shortest("f")}\n' -l1
   f
 
   $ hg log --template '{shortest("0123456789012345678901234567890123456789")}\n' -l1
   0123456789012345678901234567890123456789
 
   $ hg log --template '{shortest("01234567890123456789012345678901234567890123456789")}\n' -l1
   01234567890123456789012345678901234567890123456789
 
   $ hg log --template '{shortest("not a hex string")}\n' -l1
   not a hex string
 
   $ hg log --template '{shortest("not a hex string, but it'\''s 40 bytes long")}\n' -l1
   not a hex string, but it's 40 bytes long
 
   $ hg log --template '{shortest("ffffffffffffffffffffffffffffffffffffffff")}\n' -l1
   ffff
 
   $ hg log --template '{shortest("fffffff")}\n' -l1
   ffff
 
   $ hg log --template '{shortest("ff")}\n' -l1
   ffff
 
   $ cd ..
 
 Test shortest(node) with the repo having short hash collision:
 
   $ hg init hashcollision
   $ cd hashcollision
   $ cat <<EOF >> .hg/hgrc
   > [experimental]
   > evolution.createmarkers=True
   > EOF
   $ echo 0 > a
   $ hg ci -qAm 0
   $ for i in 17 129 248 242 480 580 617 1057 2857 4025; do
   >   hg up -q 0
   >   echo $i > a
   >   hg ci -qm $i
   > done
   $ hg up -q null
   $ hg log -r0: -T '{rev}:{node}\n'
   0:b4e73ffab476aa0ee32ed81ca51e07169844bc6a
   1:11424df6dc1dd4ea255eae2b58eaca7831973bbc
   2:11407b3f1b9c3e76a79c1ec5373924df096f0499
   3:11dd92fe0f39dfdaacdaa5f3997edc533875cfc4
   4:10776689e627b465361ad5c296a20a487e153ca4
   5:a00be79088084cb3aff086ab799f8790e01a976b
   6:a0b0acd79b4498d0052993d35a6a748dd51d13e6
   7:a0457b3450b8e1b778f1163b31a435802987fe5d
   8:c56256a09cd28e5764f32e8e2810d0f01e2e357a
   9:c5623987d205cd6d9d8389bfc40fff9dbb670b48
   10:c562ddd9c94164376c20b86b0b4991636a3bf84f
   $ hg debugobsolete a00be79088084cb3aff086ab799f8790e01a976b
   obsoleted 1 changesets
   $ hg debugobsolete c5623987d205cd6d9d8389bfc40fff9dbb670b48
   obsoleted 1 changesets
   $ hg debugobsolete c562ddd9c94164376c20b86b0b4991636a3bf84f
   obsoleted 1 changesets
 
  nodes starting with '11' (we don't have the revision number '11' though)
 
   $ hg log -r 1:3 -T '{rev}:{shortest(node, 0)}\n'
   1:1142
   2:1140
   3:11d
 
  '5:a00' is hidden, but still we have two nodes starting with 'a0'
 
   $ hg log -r 6:7 -T '{rev}:{shortest(node, 0)}\n'
   6:a0b
   7:a04
 
  node '10' conflicts with the revision number '10' even if it is hidden
  (we could exclude hidden revision numbers, but currently we don't)
 
   $ hg log -r 4 -T '{rev}:{shortest(node, 0)}\n'
   4:107
   $ hg log -r 4 -T '{rev}:{shortest(node, 0)}\n' --hidden
   4:107
 
  node 'c562' should be unique if the other 'c562' nodes are hidden
  (but we don't try the slow path to filter out hidden nodes for now)
 
   $ hg log -r 8 -T '{rev}:{node|shortest}\n'
   8:c5625
   $ hg log -r 8:10 -T '{rev}:{node|shortest}\n' --hidden
   8:c5625
   9:c5623
   10:c562d
 
   $ cd ..
 
 Test pad function
 
   $ cd r
 
   $ hg log --template '{pad(rev, 20)} {author|user}\n'
   2                    test
   1                    {node|short}
   0                    test
 
   $ hg log --template '{pad(rev, 20, " ", True)} {author|user}\n'
                      2 test
                      1 {node|short}
                      0 test
 
   $ hg log --template '{pad(rev, 20, "-", False)} {author|user}\n'
   2------------------- test
   1------------------- {node|short}
   0------------------- test
 
 Test template string in pad function
 
   $ hg log -r 0 -T '{pad("\{{rev}}", 10)} {author|user}\n'
   {0}        test
 
   $ hg log -r 0 -T '{pad(r"\{rev}", 10)} {author|user}\n'
   \{rev}     test
 
 Test width argument passed to pad function
 
   $ hg log -r 0 -T '{pad(rev, "1{"0"}")} {author|user}\n'
   0          test
   $ hg log -r 0 -T '{pad(rev, "not an int")}\n'
   hg: parse error: pad() expects an integer width
   [255]
 
 Test invalid fillchar passed to pad function
 
   $ hg log -r 0 -T '{pad(rev, 10, "")}\n'
   hg: parse error: pad() expects a single fill character
   [255]
   $ hg log -r 0 -T '{pad(rev, 10, "--")}\n'
   hg: parse error: pad() expects a single fill character
   [255]
 
 Test boolean argument passed to pad function
 
  no crash
 
   $ hg log -r 0 -T '{pad(rev, 10, "-", "f{"oo"}")}\n'
   ---------0
 
  string/literal
 
   $ hg log -r 0 -T '{pad(rev, 10, "-", "false")}\n'
   ---------0
   $ hg log -r 0 -T '{pad(rev, 10, "-", false)}\n'
   0---------
   $ hg log -r 0 -T '{pad(rev, 10, "-", "")}\n'
   0---------
 
  unknown keyword is evaluated to ''
 
   $ hg log -r 0 -T '{pad(rev, 10, "-", unknownkeyword)}\n'
   0---------
 
 Test separate function
 
   $ hg log -r 0 -T '{separate("-", "", "a", "b", "", "", "c", "")}\n'
   a-b-c
   $ hg log -r 0 -T '{separate(" ", "{rev}:{node|short}", author|user, branch)}\n'
   0:f7769ec2ab97 test default
   $ hg log -r 0 --color=always -T '{separate(" ", "a", label(red, "b"), "c", label(red, ""), "d")}\n'
   a \x1b[0;31mb\x1b[0m c d (esc)
 
 Test boolean expression/literal passed to if function
 
   $ hg log -r 0 -T '{if(rev, "rev 0 is True")}\n'
   rev 0 is True
   $ hg log -r 0 -T '{if(0, "literal 0 is True as well")}\n'
   literal 0 is True as well
   $ hg log -r 0 -T '{if("", "", "empty string is False")}\n'
   empty string is False
   $ hg log -r 0 -T '{if(revset(r"0 - 0"), "", "empty list is False")}\n'
   empty list is False
   $ hg log -r 0 -T '{if(true, "true is True")}\n'
   true is True
   $ hg log -r 0 -T '{if(false, "", "false is False")}\n'
   false is False
   $ hg log -r 0 -T '{if("false", "non-empty string is True")}\n'
   non-empty string is True
 
 Test ifcontains function
 
   $ hg log --template '{rev} {ifcontains(rev, "2 two 0", "is in the string", "is not")}\n'
   2 is in the string
   1 is not
   0 is in the string
 
   $ hg log -T '{rev} {ifcontains(rev, "2 two{" 0"}", "is in the string", "is not")}\n'
   2 is in the string
   1 is not
   0 is in the string
 
   $ hg log --template '{rev} {ifcontains("a", file_adds, "added a", "did not add a")}\n'
   2 did not add a
   1 did not add a
   0 added a
 
   $ hg log --debug -T '{rev}{ifcontains(1, parents, " is parent of 1")}\n'
   2 is parent of 1
   1
   0
 
+  $ hg log -l1 -T '{ifcontains("branch", extras, "t", "f")}\n'
+  t
+  $ hg log -l1 -T '{ifcontains("branch", extras % "{key}", "t", "f")}\n'
+  t
+  $ hg log -l1 -T '{ifcontains("branc", extras % "{key}", "t", "f")}\n'
+  f
+  $ hg log -l1 -T '{ifcontains("branc", stringify(extras % "{key}"), "t", "f")}\n'
+  t
+
 Test revset function
 
   $ hg log --template '{rev} {ifcontains(rev, revset("."), "current rev", "not current rev")}\n'
   2 current rev
   1 not current rev
   0 not current rev
 
   $ hg log --template '{rev} {ifcontains(rev, revset(". + .^"), "match rev", "not match rev")}\n'
   2 match rev
   1 match rev
   0 not match rev
 
   $ hg log -T '{ifcontains(desc, revset(":"), "", "type not match")}\n' -l1
   type not match
 
   $ hg log --template '{rev} Parents: {revset("parents(%s)", rev)}\n'
   2 Parents: 1
   1 Parents: 0
   0 Parents: 
 
   $ cat >> .hg/hgrc <<EOF
   > [revsetalias]
   > myparents(\$1) = parents(\$1)
   > EOF
   $ hg log --template '{rev} Parents: {revset("myparents(%s)", rev)}\n'
   2 Parents: 1
   1 Parents: 0
   0 Parents: 
 
   $ hg log --template 'Rev: {rev}\n{revset("::%s", rev) % "Ancestor: {revision}\n"}\n'
   Rev: 2
   Ancestor: 0
   Ancestor: 1
   Ancestor: 2
   
   Rev: 1
   Ancestor: 0
   Ancestor: 1
   
   Rev: 0
   Ancestor: 0
   
   $ hg log --template '{revset("TIP"|lower)}\n' -l1
   2
 
   $ hg log -T '{revset("%s", "t{"ip"}")}\n' -l1
   2
 
  a list template is evaluated for each item of revset/parents
 
   $ hg log -T '{rev} p: {revset("p1(%s)", rev) % "{rev}:{node|short}"}\n'
   2 p: 1:bcc7ff960b8e
   1 p: 0:f7769ec2ab97
   0 p: 
 
   $ hg log --debug -T '{rev} p:{parents % " {rev}:{node|short}"}\n'
   2 p: 1:bcc7ff960b8e -1:000000000000
   1 p: 0:f7769ec2ab97 -1:000000000000
   0 p: -1:000000000000 -1:000000000000
 
  therefore, 'revcache' should be recreated for each rev
 
   $ hg log -T '{rev} {file_adds}\np {revset("p1(%s)", rev) % "{file_adds}"}\n'
   2 aa b
   p 
   1 
   p a
   0 a
   p 
 
   $ hg log --debug -T '{rev} {file_adds}\np {parents % "{file_adds}"}\n'
   2 aa b
   p 
   1 
   p a
   0 a
   p 
 
 a revset item must be evaluated as an integer revision, not an offset from tip
 
   $ hg log -l 1 -T '{revset("null") % "{rev}:{node|short}"}\n'
   -1:000000000000
   $ hg log -l 1 -T '{revset("%s", "null") % "{rev}:{node|short}"}\n'
   -1:000000000000
 
 join() should pick '{rev}' from revset items:
 
   $ hg log -R ../a -T '{join(revset("parents(%d)", rev), ", ")}\n' -r6
   4, 5
 
 on the other hand, parents are formatted as '{rev}:{node|formatnode}' by
 default. join() should agree with the default formatting:
 
   $ hg log -R ../a -T '{join(parents, ", ")}\n' -r6
   5:13207e5a10d9, 4:bbe44766e73d
 
   $ hg log -R ../a -T '{join(parents, ",\n")}\n' -r6 --debug
   5:13207e5a10d9fd28ec424934298e176197f2c67f,
   4:bbe44766e73d5f11ed2177f1838de10c53ef3e74
 
 Invalid arguments passed to revset()
 
   $ hg log -T '{revset("%whatever", 0)}\n'
   hg: parse error: unexpected revspec format character w
   [255]
   $ hg log -T '{revset("%lwhatever", files)}\n'
   hg: parse error: unexpected revspec format character w
   [255]
   $ hg log -T '{revset("%s %s", 0)}\n'
   hg: parse error: missing argument for revspec
   [255]
   $ hg log -T '{revset("", 0)}\n'
   hg: parse error: too many revspec arguments specified
   [255]
   $ hg log -T '{revset("%s", 0, 1)}\n'
   hg: parse error: too many revspec arguments specified
   [255]
   $ hg log -T '{revset("%", 0)}\n'
   hg: parse error: incomplete revspec format character
   [255]
   $ hg log -T '{revset("%l", 0)}\n'
   hg: parse error: incomplete revspec format character
   [255]
   $ hg log -T '{revset("%d", 'foo')}\n'
   hg: parse error: invalid argument for revspec
   [255]
   $ hg log -T '{revset("%ld", files)}\n'
   hg: parse error: invalid argument for revspec
   [255]
   $ hg log -T '{revset("%ls", 0)}\n'
   hg: parse error: invalid argument for revspec
   [255]
   $ hg log -T '{revset("%b", 'foo')}\n'
   hg: parse error: invalid argument for revspec
   [255]
   $ hg log -T '{revset("%lb", files)}\n'
   hg: parse error: invalid argument for revspec
   [255]
   $ hg log -T '{revset("%r", 0)}\n'
   hg: parse error: invalid argument for revspec
   [255]
 
 Test 'originalnode'
 
   $ hg log -r 1 -T '{revset("null") % "{node|short} {originalnode|short}"}\n'
   000000000000 bcc7ff960b8e
   $ hg log -r 0 -T '{manifest % "{node} {originalnode}"}\n'
   a0c8bcbbb45c63b90b70ad007bf38961f64f2af0 f7769ec2ab975ad19684098ad1ffd9b81ecc71a1
 
 Test files function
 
   $ hg log -T "{rev}\n{join(files('*'), '\n')}\n"
   2
   a
   aa
   b
   1
   a
   0
   a
 
   $ hg log -T "{rev}\n{join(files('aa'), '\n')}\n"
   2
   aa
   1
   
   0
   
 
 Test relpath function
 
   $ hg log -r0 -T '{files % "{file|relpath}\n"}'
   a
   $ cd ..
   $ hg log -R r -r0 -T '{files % "{file|relpath}\n"}'
   r/a
   $ cd r
 
 Test active bookmark templating
 
   $ hg book foo
   $ hg book bar
   $ hg log --template "{rev} {bookmarks % '{bookmark}{ifeq(bookmark, active, \"*\")} '}\n"
   2 bar* foo 
   1 
   0 
   $ hg log --template "{rev} {activebookmark}\n"
   2 bar
   1 
   0 
   $ hg bookmarks --inactive bar
   $ hg log --template "{rev} {activebookmark}\n"
   2 
   1 
   0 
   $ hg book -r1 baz
   $ hg log --template "{rev} {join(bookmarks, ' ')}\n"
   2 bar foo
   1 baz
   0 
   $ hg log --template "{rev} {ifcontains('foo', bookmarks, 't', 'f')}\n"
   2 t
   1 f
   0 f
 
 Test namespaces dict
 
   $ hg --config extensions.revnamesext=$TESTDIR/revnamesext.py log -T '{rev}\n{namespaces % " {namespace} color={colorname} builtin={builtin}\n  {join(names, ",")}\n"}\n'
   2
    bookmarks color=bookmark builtin=True
     bar,foo
    tags color=tag builtin=True
     tip
    branches color=branch builtin=True
     text.{rev}
    revnames color=revname builtin=False
     r2
   
   1
    bookmarks color=bookmark builtin=True
     baz
    tags color=tag builtin=True
     
    branches color=branch builtin=True
     text.{rev}
    revnames color=revname builtin=False
     r1
   
   0
    bookmarks color=bookmark builtin=True
     
    tags color=tag builtin=True
     
    branches color=branch builtin=True
     default
    revnames color=revname builtin=False
     r0
   
   $ hg log -r2 -T '{namespaces % "{namespace}: {names}\n"}'
   bookmarks: bar foo
   tags: tip
   branches: text.{rev}
   $ hg log -r2 -T '{namespaces % "{namespace}:\n{names % " {name}\n"}"}'
   bookmarks:
    bar
    foo
   tags:
    tip
   branches:
    text.{rev}
   $ hg log -r2 -T '{get(namespaces, "bookmarks") % "{name}\n"}'
   bar
   foo
   $ hg log -r2 -T '{namespaces.bookmarks % "{bookmark}\n"}'
   bar
   foo
 
 Test stringify on sub expressions
 
   $ cd ..
   $ hg log -R a -r 8 --template '{join(files, if("1", if("1", ", ")))}\n'
   fourth, second, third
   $ hg log -R a -r 8 --template '{strip(if("1", if("1", "-abc-")), if("1", if("1", "-")))}\n'
   abc
 
 Test splitlines
 
   $ hg log -Gv -R a --template "{splitlines(desc) % 'foo {line}\n'}"
   @  foo Modify, add, remove, rename
   |
   o  foo future
   |
   o  foo third
   |
   o  foo second
   
   o    foo merge
   |\
   | o  foo new head
   | |
   o |  foo new branch
   |/
   o  foo no user, no domain
   |
   o  foo no person
   |
   o  foo other 1
   |  foo other 2
   |  foo
   |  foo other 3
   o  foo line 1
      foo line 2
 
   $ hg log -R a -r0 -T '{desc|splitlines}\n'
   line 1 line 2
   $ hg log -R a -r0 -T '{join(desc|splitlines, "|")}\n'
   line 1|line 2
 
 Test startswith
   $ hg log -Gv -R a --template "{startswith(desc)}"
   hg: parse error: startswith expects two arguments
   [255]
 
   $ hg log -Gv -R a --template "{startswith('line', desc)}"
   @
   |
   o
   |
   o
   |
   o
   
   o
   |\
   | o
   | |
   o |
   |/
   o
   |
   o
   |
   o
   |
   o  line 1
      line 2
 
 Test bad template with better error message
 
   $ hg log -Gv -R a --template '{desc|user()}'
   hg: parse error: expected a symbol, got 'func'
   [255]
 
 Test word function (including index out of bounds graceful failure)
 
   $ hg log -Gv -R a --template "{word('1', desc)}"
   @  add,
   |
   o
   |
   o
   |
   o
   
   o
   |\
   | o  head
   | |
   o |  branch
   |/
   o  user,
   |
   o  person
   |
   o  1
   |
   o  1
   
 
 Test word third parameter used as splitter
 
   $ hg log -Gv -R a --template "{word('0', desc, 'o')}"
   @  M
   |
   o  future
   |
   o  third
   |
   o  sec
   
   o    merge
   |\
   | o  new head
   | |
   o |  new branch
   |/
   o  n
   |
   o  n
   |
   o
   |
   o  line 1
      line 2
 
 Test word error messages for not enough and too many arguments
 
   $ hg log -Gv -R a --template "{word('0')}"
   hg: parse error: word expects two or three arguments, got 1
   [255]
 
   $ hg log -Gv -R a --template "{word('0', desc, 'o', 'h', 'b', 'o', 'y')}"
   hg: parse error: word expects two or three arguments, got 7
   [255]
 
 Test word for integer literal
 
   $ hg log -R a --template "{word(2, desc)}\n" -r0
   line
 
 Test word for invalid numbers
 
   $ hg log -Gv -R a --template "{word('a', desc)}"
   hg: parse error: word expects an integer index
   [255]
 
 Test word for out of range
 
   $ hg log -R a --template "{word(10000, desc)}"
   $ hg log -R a --template "{word(-10000, desc)}"
 
 Test indent and not adding to empty lines
 
   $ hg log -T "-----\n{indent(desc, '>> ', ' > ')}\n" -r 0:1 -R a
   -----
    > line 1
   >> line 2
   -----
    > other 1
   >> other 2
   
   >> other 3
 
 Test with non-strings like dates
 
   $ hg log -T "{indent(date, '   ')}\n" -r 2:3 -R a
      1200000.00
      1300000.00
 
 Test broken string escapes:
 
   $ hg log -T "bogus\\" -R a
   hg: parse error: trailing \ in string
   [255]
   $ hg log -T "\\xy" -R a
   hg: parse error: invalid \x escape* (glob)
   [255]
 
 json filter should escape HTML tags so that the output can be embedded in hgweb:
 
   $ hg log -T "{'<[e-mail]>'|json}\n" -R a -l1
   "\[e-mail]\u003e"
 
 Templater supports aliases of symbol and func() styles:
 
   $ hg clone -q a aliases
   $ cd aliases
   $ cat <<EOF >> .hg/hgrc
   > [templatealias]
   > r = rev
   > rn = "{r}:{node|short}"
   > status(c, files) = files % "{c} {file}\n"
   > utcdate(d) = localdate(d, "UTC")
   > EOF
 
   $ hg debugtemplate -vr0 '{rn} {utcdate(date)|isodate}\n'
   (template
     (symbol 'rn')
     (string ' ')
     (|
       (func
         (symbol 'utcdate')
         (symbol 'date'))
       (symbol 'isodate'))
     (string '\n'))
   * expanded:
   (template
     (template
       (symbol 'rev')
       (string ':')
       (|
         (symbol 'node')
         (symbol 'short')))
     (string ' ')
     (|
       (func
         (symbol 'localdate')
         (list
           (symbol 'date')
           (string 'UTC')))
       (symbol 'isodate'))
     (string '\n'))
   0:1e4e1b8f71e0 1970-01-12 13:46 +0000
 
   $ hg debugtemplate -vr0 '{status("A", file_adds)}'
   (template
     (func
       (symbol 'status')
       (list
         (string 'A')
         (symbol 'file_adds'))))
   * expanded:
   (template
     (%
       (symbol 'file_adds')
       (template
         (string 'A')
         (string ' ')
         (symbol 'file')
         (string '\n'))))
   A a
 
 A unary function alias can be called as a filter:
 
   $ hg debugtemplate -vr0 '{date|utcdate|isodate}\n'
   (template
     (|
       (|
         (symbol 'date')
         (symbol 'utcdate'))
       (symbol 'isodate'))
     (string '\n'))
   * expanded:
   (template
     (|
       (func
         (symbol 'localdate')
         (list
           (symbol 'date')
           (string 'UTC')))
       (symbol 'isodate'))
     (string '\n'))
   1970-01-12 13:46 +0000
 
 Aliases should be applied only to command arguments and templates in hgrc.
 Otherwise, our stock styles and web templates could be corrupted:
 
   $ hg log -r0 -T '{rn} {utcdate(date)|isodate}\n'
   0:1e4e1b8f71e0 1970-01-12 13:46 +0000
 
   $ hg log -r0 --config ui.logtemplate='"{rn} {utcdate(date)|isodate}\n"'
   0:1e4e1b8f71e0 1970-01-12 13:46 +0000
 
   $ cat <<EOF > tmpl
   > changeset = 'nothing expanded:{rn}\n'
   > EOF
   $ hg log -r0 --style ./tmpl
   nothing expanded:
 
 Aliases in formatter:
 
   $ hg branches -T '{pad(branch, 7)} {rn}\n'
   default 6:d41e714fe50d
   foo     4:bbe44766e73d
 
 Aliases should honor HGPLAIN:
 
   $ HGPLAIN= hg log -r0 -T 'nothing expanded:{rn}\n'
   nothing expanded:
   $ HGPLAINEXCEPT=templatealias hg log -r0 -T '{rn}\n'
   0:1e4e1b8f71e0
 
 Unparsable alias:
 
   $ hg debugtemplate --config templatealias.bad='x(' -v '{bad}'
   (template
     (symbol 'bad'))
   abort: bad definition of template alias "bad": at 2: not a prefix: end
   [255]
   $ hg log --config templatealias.bad='x(' -T '{bad}'
   abort: bad definition of template alias "bad": at 2: not a prefix: end
   [255]
 
   $ cd ..
 
 Set up repository for non-ascii encoding tests:
 
   $ hg init nonascii
   $ cd nonascii
   $ $PYTHON <<EOF
   > open('latin1', 'wb').write(b'\xe9')
   > open('utf-8', 'wb').write(b'\xc3\xa9')
   > EOF
   $ HGENCODING=utf-8 hg branch -q `cat utf-8`
   $ HGENCODING=utf-8 hg ci -qAm "non-ascii branch: `cat utf-8`" utf-8
 
 json filter should try round-trip conversion to utf-8:
 
   $ HGENCODING=ascii hg log -T "{branch|json}\n" -r0
   "\u00e9"
   $ HGENCODING=ascii hg log -T "{desc|json}\n" -r0
   "non-ascii branch: \u00e9"
 
 json filter should take input as utf-8 if it was converted from utf-8:
 
   $ HGENCODING=latin-1 hg log -T "{branch|json}\n" -r0
   "\u00e9"
   $ HGENCODING=latin-1 hg log -T "{desc|json}\n" -r0
   "non-ascii branch: \u00e9"
 
 json filter takes input as utf-8b:
 
   $ HGENCODING=ascii hg log -T "{'`cat utf-8`'|json}\n" -l1
   "\u00e9"
   $ HGENCODING=ascii hg log -T "{'`cat latin1`'|json}\n" -l1
   "\udce9"
 
 utf8 filter:
 
   $ HGENCODING=ascii hg log -T "round-trip: {branch|utf8|hex}\n" -r0
   round-trip: c3a9
   $ HGENCODING=latin1 hg log -T "decoded: {'`cat latin1`'|utf8|hex}\n" -l1
   decoded: c3a9
   $ HGENCODING=ascii hg log -T "replaced: {'`cat latin1`'|utf8|hex}\n" -l1
   abort: decoding near * (glob)
   [255]
   $ hg log -T "coerced to string: {rev|utf8}\n" -r0
   coerced to string: 0
 
 pad width:
 
   $ HGENCODING=utf-8 hg debugtemplate "{pad('`cat utf-8`', 2, '-')}\n"
   \xc3\xa9- (esc)
 
   $ cd ..
 
 Test that template function in extension is registered as expected
 
   $ cd a
 
   $ cat <<EOF > $TESTTMP/customfunc.py
   > from mercurial import registrar
   > 
   > templatefunc = registrar.templatefunc()
   > 
   > @templatefunc(b'custom()')
   > def custom(context, mapping, args):
   >     return b'custom'
   > EOF
   $ cat <<EOF > .hg/hgrc
   > [extensions]
   > customfunc = $TESTTMP/customfunc.py
   > EOF
 
   $ hg log -r . -T "{custom()}\n" --config customfunc.enabled=true
   custom
 
   $ cd ..
 
 Test 'graphwidth' in 'hg log' on various topologies. The key here is that the
 printed graphwidths 3, 5, 7, etc. should all line up in their respective
 columns. We don't care about other aspects of the graph rendering here.
 
   $ hg init graphwidth
   $ cd graphwidth
 
   $ wrappabletext="a a a a a a a a a a a a"
 
   $ printf "first\n" > file
   $ hg add file
   $ hg commit -m "$wrappabletext"
 
   $ printf "first\nsecond\n" > file
   $ hg commit -m "$wrappabletext"
 
   $ hg checkout 0
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ printf "third\nfirst\n" > file
   $ hg commit -m "$wrappabletext"
   created new head
 
   $ hg merge
   merging file
   0 files updated, 1 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
 
   $ hg log --graph -T "{graphwidth}"
   @  3
   |
   | @  5
   |/
   o  3
   
   $ hg commit -m "$wrappabletext"
 
   $ hg log --graph -T "{graphwidth}"
   @    5
   |\
   | o  5
   | |
   o |  5
   |/
   o  3
   
 
   $ hg checkout 0
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ printf "third\nfirst\nsecond\n" > file
   $ hg commit -m "$wrappabletext"
   created new head
 
   $ hg log --graph -T "{graphwidth}"
   @  3
   |
   | o    7
   | |\
   +---o  7
   | |
   | o  5
   |/
   o  3
   
 
   $ hg log --graph -T "{graphwidth}" -r 3
   o    5
   |\
   ~ ~
 
   $ hg log --graph -T "{graphwidth}" -r 1
   o  3
   |
   ~
 
   $ hg merge
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hg commit -m "$wrappabletext"
 
   $ printf "seventh\n" >> file
   $ hg commit -m "$wrappabletext"
 
   $ hg log --graph -T "{graphwidth}"
   @  3
   |
   o    5
   |\
   | o  5
   | |
   o |    7
   |\ \
   | o |  7
   | |/
   o /  5
   |/
   o  3
   
 
 The point of graphwidth is to allow wrapping that accounts for the space taken
 by the graph.
 
   $ COLUMNS=10 hg log --graph -T "{fill(desc, termwidth - graphwidth)}"
   @  a a a a
   |  a a a a
   |  a a a a
   o    a a a
   |\   a a a
   | |  a a a
   | |  a a a
   | o  a a a
   | |  a a a
   | |  a a a
   | |  a a a
   o |    a a
   |\ \   a a
   | | |  a a
   | | |  a a
   | | |  a a
   | | |  a a
   | o |  a a
   | |/   a a
   | |    a a
   | |    a a
   | |    a a
   | |    a a
   o |  a a a
   |/   a a a
   |    a a a
   |    a a a
   o  a a a a
      a a a a
      a a a a
 
 Something tricky happens when there are elided nodes; the next drawn row of
 edges can be more than one column wider, but the graph width only increases by
 one column. The remaining columns are added in between the nodes.
 
   $ hg log --graph -T "{graphwidth}" -r "0|2|4|5"
   o    5
   |\
   | \
   | :\
   o : :  7
   :/ /
   : o  5
   :/
   o  3
   
 
   $ cd ..