templater: remove __iter__() from _hybrid, resolve it explicitly

The goal is to fix "{hybrid_obj|json}" output.

A _hybrid object must act as a list or a dict as well as a generator of
legacy template strings. Before, _hybrid.__iter__() was assigned for legacy
template, which conflicted with list.__iter__() API.

This patch drops _hybrid.__iter__() and makes stringify/flatten functions
unwrap a generator instead.

mercurial/templatefilters.py

@@ -1,431 +1,432 b''
 # template-filters.py - common template expansion filters
 #
 # Copyright 2005-2008 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 cgi
 import os
 import re
 import time
 
 from . import (
     encoding,
     hbisect,
     node,
     registrar,
     templatekw,
     util,
 )
 
 urlerr = util.urlerr
 urlreq = util.urlreq
 
 # filters are callables like:
 #   fn(obj)
 # with:
 #   obj - object to be filtered (text, date, list and so on)
 filters = {}
 
 templatefilter = registrar.templatefilter(filters)
 
 @templatefilter('addbreaks')
 def addbreaks(text):
     """Any text. Add an XHTML "<br />" tag before the end of
     every line except the last.
     """
     return text.replace('\n', '<br/>\n')
 
 agescales = [("year", 3600 * 24 * 365, 'Y'),
              ("month", 3600 * 24 * 30, 'M'),
              ("week", 3600 * 24 * 7, 'W'),
              ("day", 3600 * 24, 'd'),
              ("hour", 3600, 'h'),
              ("minute", 60, 'm'),
              ("second", 1, 's')]
 
 @templatefilter('age')
 def age(date, abbrev=False):
     """Date. Returns a human-readable date/time difference between the
     given date/time and the current date/time.
     """
 
     def plural(t, c):
         if c == 1:
             return t
         return t + "s"
     def fmt(t, c, a):
         if abbrev:
             return "%d%s" % (c, a)
         return "%d %s" % (c, plural(t, c))
 
     now = time.time()
     then = date[0]
     future = False
     if then > now:
         future = True
         delta = max(1, int(then - now))
         if delta > agescales[0][1] * 30:
             return 'in the distant future'
     else:
         delta = max(1, int(now - then))
         if delta > agescales[0][1] * 2:
             return util.shortdate(date)
 
     for t, s, a in agescales:
         n = delta // s
         if n >= 2 or s == 1:
             if future:
                 return '%s from now' % fmt(t, n, a)
             return '%s ago' % fmt(t, n, a)
 
 @templatefilter('basename')
 def basename(path):
     """Any text. Treats the text as a path, and returns the last
     component of the path after splitting by the path separator
     (ignoring trailing separators). For example, "foo/bar/baz" becomes
     "baz" and "foo/bar//" becomes "bar".
     """
     return os.path.basename(path)
 
 @templatefilter('count')
 def count(i):
     """List or text. Returns the length as an integer."""
     return len(i)
 
 @templatefilter('domain')
 def domain(author):
     """Any text. Finds the first string that looks like an email
     address, and extracts just the domain component. Example: ``User
     <[e-mail]>`` becomes ``example.com``.
     """
     f = author.find('@')
     if f == -1:
         return ''
     author = author[f + 1:]
     f = author.find('>')
     if f >= 0:
         author = author[:f]
     return author
 
 @templatefilter('email')
 def email(text):
     """Any text. Extracts the first string that looks like an email
     address. Example: ``User <[e-mail]>`` becomes
     ``[e-mail]``.
     """
     return util.email(text)
 
 @templatefilter('escape')
 def escape(text):
     """Any text. Replaces the special XML/XHTML characters "&", "<"
     and ">" with XML entities, and filters out NUL characters.
     """
     return cgi.escape(text.replace('\0', ''), True)
 
 para_re = None
 space_re = None
 
 def fill(text, width, initindent='', hangindent=''):
     '''fill many paragraphs with optional indentation.'''
     global para_re, space_re
     if para_re is None:
         para_re = re.compile('(\n\n|\n\\s*[-*]\\s*)', re.M)
         space_re = re.compile(r'  +')
 
     def findparas():
         start = 0
         while True:
             m = para_re.search(text, start)
             if not m:
                 uctext = unicode(text[start:], encoding.encoding)
                 w = len(uctext)
                 while 0 < w and uctext[w - 1].isspace():
                     w -= 1
                 yield (uctext[:w].encode(encoding.encoding),
                        uctext[w:].encode(encoding.encoding))
                 break
             yield text[start:m.start(0)], m.group(1)
             start = m.end(1)
 
     return "".join([util.wrap(space_re.sub(' ', util.wrap(para, width)),
                               width, initindent, hangindent) + rest
                     for para, rest in findparas()])
 
 @templatefilter('fill68')
 def fill68(text):
     """Any text. Wraps the text to fit in 68 columns."""
     return fill(text, 68)
 
 @templatefilter('fill76')
 def fill76(text):
     """Any text. Wraps the text to fit in 76 columns."""
     return fill(text, 76)
 
 @templatefilter('firstline')
 def firstline(text):
     """Any text. Returns the first line of text."""
     try:
         return text.splitlines(True)[0].rstrip('\r\n')
     except IndexError:
         return ''
 
 @templatefilter('hex')
 def hexfilter(text):
     """Any text. Convert a binary Mercurial node identifier into
     its long hexadecimal representation.
     """
     return node.hex(text)
 
 @templatefilter('hgdate')
 def hgdate(text):
     """Date. Returns the date as a pair of numbers: "1157407993
     25200" (Unix timestamp, timezone offset).
     """
     return "%d %d" % text
 
 @templatefilter('isodate')
 def isodate(text):
     """Date. Returns the date in ISO 8601 format: "2009-08-18 13:00
     +0200".
     """
     return util.datestr(text, '%Y-%m-%d %H:%M %1%2')
 
 @templatefilter('isodatesec')
 def isodatesec(text):
     """Date. Returns the date in ISO 8601 format, including
     seconds: "2009-08-18 13:00:13 +0200". See also the rfc3339date
     filter.
     """
     return util.datestr(text, '%Y-%m-%d %H:%M:%S %1%2')
 
 def indent(text, prefix):
     '''indent each non-empty line of text after first with prefix.'''
     lines = text.splitlines()
     num_lines = len(lines)
     endswithnewline = text[-1:] == '\n'
     def indenter():
         for i in xrange(num_lines):
             l = lines[i]
             if i and l.strip():
                 yield prefix
             yield l
             if i < num_lines - 1 or endswithnewline:
                 yield '\n'
     return "".join(indenter())
 
 @templatefilter('json')
 def json(obj, paranoid=True):
     if obj is None:
         return 'null'
     elif obj is False:
         return 'false'
     elif obj is True:
         return 'true'
     elif isinstance(obj, (int, long, float)):
         return str(obj)
     elif isinstance(obj, str):
         return '"%s"' % encoding.jsonescape(obj, paranoid=paranoid)
     elif util.safehasattr(obj, 'keys'):
         out = ['%s: %s' % (json(k), json(v))
                for k, v in sorted(obj.iteritems())]
         return '{' + ', '.join(out) + '}'
     elif util.safehasattr(obj, '__iter__'):
         out = [json(i) for i in obj]
         return '[' + ', '.join(out) + ']'
     else:
         raise TypeError('cannot encode type %s' % obj.__class__.__name__)
 
 @templatefilter('lower')
 def lower(text):
     """Any text. Converts the text to lowercase."""
     return encoding.lower(text)
 
 @templatefilter('nonempty')
 def nonempty(str):
     """Any text. Returns '(none)' if the string is empty."""
     return str or "(none)"
 
 @templatefilter('obfuscate')
 def obfuscate(text):
     """Any text. Returns the input text rendered as a sequence of
     XML entities.
     """
     text = unicode(text, encoding.encoding, 'replace')
     return ''.join(['&#%d;' % ord(c) for c in text])
 
 @templatefilter('permissions')
 def permissions(flags):
     if "l" in flags:
         return "lrwxrwxrwx"
     if "x" in flags:
         return "-rwxr-xr-x"
     return "-rw-r--r--"
 
 @templatefilter('person')
 def person(author):
     """Any text. Returns the name before an email address,
     interpreting it as per RFC 5322.
 
     >>> person('foo@bar')
     'foo'
     >>> person('Foo Bar <foo@bar>')
     'Foo Bar'
     >>> person('"Foo Bar" <foo@bar>')
     'Foo Bar'
     >>> person('"Foo \"buz\" Bar" <foo@bar>')
     'Foo "buz" Bar'
     >>> # The following are invalid, but do exist in real-life
     ...
     >>> person('Foo "buz" Bar <foo@bar>')
     'Foo "buz" Bar'
     >>> person('"Foo Bar <foo@bar>')
     'Foo Bar'
     """
     if '@' not in author:
         return author
     f = author.find('<')
     if f != -1:
         return author[:f].strip(' "').replace('\\"', '"')
     f = author.find('@')
     return author[:f].replace('.', ' ')
 
 @templatefilter('revescape')
 def revescape(text):
     """Any text. Escapes all "special" characters, except @.
     Forward slashes are escaped twice to prevent web servers from prematurely
     unescaping them. For example, "@foo bar/baz" becomes "@foo%20bar%252Fbaz".
     """
     return urlreq.quote(text, safe='/@').replace('/', '%252F')
 
 @templatefilter('rfc3339date')
 def rfc3339date(text):
     """Date. Returns a date using the Internet date format
     specified in RFC 3339: "2009-08-18T13:00:13+02:00".
     """
     return util.datestr(text, "%Y-%m-%dT%H:%M:%S%1:%2")
 
 @templatefilter('rfc822date')
 def rfc822date(text):
     """Date. Returns a date using the same format used in email
     headers: "Tue, 18 Aug 2009 13:00:13 +0200".
     """
     return util.datestr(text, "%a, %d %b %Y %H:%M:%S %1%2")
 
 @templatefilter('short')
 def short(text):
     """Changeset hash. Returns the short form of a changeset hash,
     i.e. a 12 hexadecimal digit string.
     """
     return text[:12]
 
 @templatefilter('shortbisect')
 def shortbisect(text):
     """Any text. Treats `text` as a bisection status, and
     returns a single-character representing the status (G: good, B: bad,
     S: skipped, U: untested, I: ignored). Returns single space if `text`
     is not a valid bisection status.
     """
     return hbisect.shortlabel(text) or ' '
 
 @templatefilter('shortdate')
 def shortdate(text):
     """Date. Returns a date like "2006-09-18"."""
     return util.shortdate(text)
 
 @templatefilter('splitlines')
 def splitlines(text):
     """Any text. Split text into a list of lines."""
     return templatekw.showlist('line', text.splitlines(), 'lines')
 
 @templatefilter('stringescape')
 def stringescape(text):
     return util.escapestr(text)
 
 @templatefilter('stringify')
 def stringify(thing):
     """Any type. Turns the value into text by converting values into
     text and concatenating them.
     """
+    thing = templatekw.unwraphybrid(thing)
     if util.safehasattr(thing, '__iter__') and not isinstance(thing, str):
         return "".join([stringify(t) for t in thing if t is not None])
     if thing is None:
         return ""
     return str(thing)
 
 @templatefilter('stripdir')
 def stripdir(text):
     """Treat the text as path and strip a directory level, if
     possible. For example, "foo" and "foo/bar" becomes "foo".
     """
     dir = os.path.dirname(text)
     if dir == "":
         return os.path.basename(text)
     else:
         return dir
 
 @templatefilter('tabindent')
 def tabindent(text):
     """Any text. Returns the text, with every non-empty line
     except the first starting with a tab character.
     """
     return indent(text, '\t')
 
 @templatefilter('upper')
 def upper(text):
     """Any text. Converts the text to uppercase."""
     return encoding.upper(text)
 
 @templatefilter('urlescape')
 def urlescape(text):
     """Any text. Escapes all "special" characters. For example,
     "foo bar" becomes "foo%20bar".
     """
     return urlreq.quote(text)
 
 @templatefilter('user')
 def userfilter(text):
     """Any text. Returns a short representation of a user name or email
     address."""
     return util.shortuser(text)
 
 @templatefilter('emailuser')
 def emailuser(text):
     """Any text. Returns the user portion of an email address."""
     return util.emailuser(text)
 
 @templatefilter('utf8')
 def utf8(text):
     """Any text. Converts from the local character encoding to UTF-8."""
     return encoding.fromlocal(text)
 
 @templatefilter('xmlescape')
 def xmlescape(text):
     text = (text
             .replace('&', '&amp;')
             .replace('<', '&lt;')
             .replace('>', '&gt;')
             .replace('"', '&quot;')
             .replace("'", '&#39;')) # &apos; invalid in HTML
     return re.sub('[\x00-\x08\x0B\x0C\x0E-\x1F]', ' ', text)
 
 def websub(text, websubtable):
     """:websub: Any text. Only applies to hgweb. Applies the regular
     expression replacements defined in the websub section.
     """
     if websubtable:
         for regexp, format in websubtable:
             text = regexp.sub(format, text)
     return text
 
 def loadfilter(ui, extname, registrarobj):
     """Load template filter from specified registrarobj
     """
     for name, func in registrarobj._table.iteritems():
         filters[name] = func
 
 # tell hggettext to extract docstrings from these functions:
 i18nfunctions = filters.values()

mercurial/templatekw.py

@@ -1,649 +1,654 b''
 # templatekw.py - common changeset template keywords
 #
 # Copyright 2005-2009 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
 
 from .i18n import _
 from .node import hex, nullid
 from . import (
     encoding,
     error,
     hbisect,
     patch,
     registrar,
     scmutil,
     util,
 )
 
 class _hybrid(object):
     """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)}"
     """
 
     def __init__(self, gen, values, makemap, joinfmt):
         self.gen = gen
         self.values = values
         self._makemap = makemap
         self.joinfmt = joinfmt
-    def __iter__(self):
-        return self.gen
     def itermaps(self):
         makemap = self._makemap
         for x in self.values:
             yield makemap(x)
     def __contains__(self, x):
         return x in self.values
     def __len__(self):
         return len(self.values)
     def __getattr__(self, name):
         if name != 'get':
             raise AttributeError(name)
         return getattr(self.values, name)
 
+def unwraphybrid(thing):
+    """Return an object which can be stringified possibly by using a legacy
+    template"""
+    if not util.safehasattr(thing, 'gen'):
+        return thing
+    return thing.gen
+
 def showlist(name, values, plural=None, element=None, separator=' ', **args):
     if not element:
         element = name
     f = _showlist(name, values, plural, separator, **args)
     return _hybrid(f, values, lambda x: {element: x}, lambda d: d[element])
 
 def _showlist(name, values, plural=None, separator=' ', **args):
     '''expand set of values.
     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'.
     '''
     templ = args['templ']
     if plural:
         names = plural
     else: names = name + 's'
     if not values:
         noname = 'no_' + names
         if noname in templ:
             yield templ(noname, **args)
         return
     if name not in templ:
         if isinstance(values[0], str):
             yield separator.join(values)
         else:
             for v in values:
                 yield dict(v, **args)
         return
     startname = 'start_' + names
     if startname in templ:
         yield templ(startname, **args)
     vargs = args.copy()
     def one(v, tag=name):
         try:
             vargs.update(v)
         except (AttributeError, ValueError):
             try:
                 for a, b in v:
                     vargs[a] = b
             except ValueError:
                 vargs[name] = v
         return templ(tag, **vargs)
     lastname = 'last_' + name
     if lastname in templ:
         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_' + names
     if endname in templ:
         yield templ(endname, **args)
 
 def _formatrevnode(ctx):
     """Format changeset as '{rev}:{node|formatnode}', which is the default
     template provided by cmdutil.changeset_templater"""
     repo = ctx.repo()
     if repo.ui.debugflag:
         hexnode = ctx.hex()
     else:
         hexnode = ctx.hex()[:12]
     return '%d:%s' % (scmutil.intrev(ctx.rev()), hexnode)
 
 def getfiles(repo, ctx, revcache):
     if 'files' not in revcache:
         revcache['files'] = repo.status(ctx.p1(), ctx)[:3]
     return revcache['files']
 
 def getlatesttags(repo, ctx, cache, pattern=None):
     '''return date, distance and name for the latest tag of rev'''
 
     cachename = 'latesttags'
     if pattern is not None:
         cachename += '-' + pattern
         match = util.stringmatcher(pattern)[2]
     else:
         match = util.always
 
     if cachename not in cache:
         # Cache mapping from rev to a tuple with tag date, tag
         # distance and tag name
         cache[cachename] = {-1: (0, 0, ['null'])}
     latesttags = cache[cachename]
 
     rev = ctx.rev()
     todo = [rev]
     while todo:
         rev = todo.pop()
         if rev in latesttags:
             continue
         ctx = repo[rev]
         tags = [t for t in ctx.tags()
                 if (repo.tagtype(t) and repo.tagtype(t) != 'local'
                     and match(t))]
         if tags:
             latesttags[rev] = ctx.date()[0], 0, [t for t in sorted(tags)]
             continue
         try:
             # The tuples are laid out so the right one can be found by
             # comparison.
             pdate, pdist, ptag = max(
                 latesttags[p.rev()] for p in ctx.parents())
         except KeyError:
             # Cache miss - recurse
             todo.append(rev)
             todo.extend(p.rev() for p in ctx.parents())
             continue
         latesttags[rev] = pdate, pdist + 1, ptag
     return latesttags[rev]
 
 def getrenamedfn(repo, endrev=None):
     rcache = {}
     if endrev is None:
         endrev = len(repo)
 
     def getrenamed(fn, rev):
         '''looks up all renames for a file (up to endrev) the first
         time the file is given. It indexes on the changerev and only
         parses the manifest if linkrev != changerev.
         Returns rename info for fn at changerev rev.'''
         if fn not in rcache:
             rcache[fn] = {}
             fl = repo.file(fn)
             for i in fl:
                 lr = fl.linkrev(i)
                 renamed = fl.renamed(fl.node(i))
                 rcache[fn][lr] = renamed
                 if lr >= endrev:
                     break
         if rev in rcache[fn]:
             return rcache[fn][rev]
 
         # If linkrev != rev (i.e. rev not found in rcache) fallback to
         # filectx logic.
         try:
             return repo[rev][fn].renamed()
         except error.LookupError:
             return None
 
     return getrenamed
 
 # default templates internally used for rendering of lists
 defaulttempl = {
     'parent': '{rev}:{node|formatnode} ',
     'manifest': '{rev}:{node|formatnode}',
     'file_copy': '{name} ({source})',
     'envvar': '{key}={value}',
     'extra': '{key}={value|stringescape}'
 }
 # filecopy is preserved for compatibility reasons
 defaulttempl['filecopy'] = defaulttempl['file_copy']
 
 # keywords are callables like:
 # fn(repo, ctx, templ, cache, revcache, **args)
 # with:
 # repo - current repository instance
 # ctx - the changectx being displayed
 # templ - the templater instance
 # cache - a cache dictionary for the whole templater run
 # revcache - a cache dictionary for the current revision
 keywords = {}
 
 templatekeyword = registrar.templatekeyword(keywords)
 
 @templatekeyword('author')
 def showauthor(repo, ctx, templ, **args):
     """String. The unmodified author of the changeset."""
     return ctx.user()
 
 @templatekeyword('bisect')
 def showbisect(repo, ctx, templ, **args):
     """String. The changeset bisection status."""
     return hbisect.label(repo, ctx.node())
 
 @templatekeyword('branch')
 def showbranch(**args):
     """String. The name of the branch on which the changeset was
     committed.
     """
     return args['ctx'].branch()
 
 @templatekeyword('branches')
 def showbranches(**args):
     """List of strings. The name of the branch on which the
     changeset was committed. Will be empty if the branch name was
     default. (DEPRECATED)
     """
     branch = args['ctx'].branch()
     if branch != 'default':
         return showlist('branch', [branch], plural='branches', **args)
     return showlist('branch', [], plural='branches', **args)
 
 @templatekeyword('bookmarks')
 def showbookmarks(**args):
     """List of strings. Any bookmarks associated with the
     changeset. Also sets 'active', the name of the active bookmark.
     """
     repo = args['ctx']._repo
     bookmarks = args['ctx'].bookmarks()
     active = repo._activebookmark
     makemap = lambda v: {'bookmark': v, 'active': active, 'current': active}
     f = _showlist('bookmark', bookmarks, **args)
     return _hybrid(f, bookmarks, makemap, lambda x: x['bookmark'])
 
 @templatekeyword('children')
 def showchildren(**args):
     """List of strings. The children of the changeset."""
     ctx = args['ctx']
     childrevs = ['%d:%s' % (cctx, cctx) for cctx in ctx.children()]
     return showlist('children', childrevs, element='child', **args)
 
 # Deprecated, but kept alive for help generation a purpose.
 @templatekeyword('currentbookmark')
 def showcurrentbookmark(**args):
     """String. The active bookmark, if it is
     associated with the changeset (DEPRECATED)"""
     return showactivebookmark(**args)
 
 @templatekeyword('activebookmark')
 def showactivebookmark(**args):
     """String. The active bookmark, if it is
     associated with the changeset"""
     active = args['repo']._activebookmark
     if active and active in args['ctx'].bookmarks():
         return active
     return ''
 
 @templatekeyword('date')
 def showdate(repo, ctx, templ, **args):
     """Date information. The date when the changeset was committed."""
     return ctx.date()
 
 @templatekeyword('desc')
 def showdescription(repo, ctx, templ, **args):
     """String. The text of the changeset description."""
     s = ctx.description()
     if isinstance(s, encoding.localstr):
         # try hard to preserve utf-8 bytes
         return encoding.tolocal(encoding.fromlocal(s).strip())
     else:
         return s.strip()
 
 @templatekeyword('diffstat')
 def showdiffstat(repo, ctx, templ, **args):
     """String. Statistics of changes with the following format:
     "modified files: +added/-removed lines"
     """
     stats = patch.diffstatdata(util.iterlines(ctx.diff(noprefix=False)))
     maxname, maxtotal, adds, removes, binary = patch.diffstatsum(stats)
     return '%s: +%s/-%s' % (len(stats), adds, removes)
 
 @templatekeyword('envvars')
 def showenvvars(repo, **args):
     """A dictionary of environment variables. (EXPERIMENTAL)"""
 
     env = repo.ui.exportableenviron()
     env = util.sortdict((k, env[k]) for k in sorted(env))
     makemap = lambda k: {'key': k, 'value': env[k]}
     c = [makemap(k) for k in env]
     f = _showlist('envvar', c, plural='envvars', **args)
     return _hybrid(f, env, makemap,
                    lambda x: '%s=%s' % (x['key'], x['value']))
 
 @templatekeyword('extras')
 def showextras(**args):
     """List of dicts with key, value entries of the 'extras'
     field of this changeset."""
     extras = args['ctx'].extra()
     extras = util.sortdict((k, extras[k]) for k in sorted(extras))
     makemap = lambda k: {'key': k, 'value': extras[k]}
     c = [makemap(k) for k in extras]
     f = _showlist('extra', c, plural='extras', **args)
     return _hybrid(f, extras, makemap,
                    lambda x: '%s=%s' % (x['key'], util.escapestr(x['value'])))
 
 @templatekeyword('file_adds')
 def showfileadds(**args):
     """List of strings. Files added by this changeset."""
     repo, ctx, revcache = args['repo'], args['ctx'], args['revcache']
     return showlist('file_add', getfiles(repo, ctx, revcache)[1],
                     element='file', **args)
 
 @templatekeyword('file_copies')
 def showfilecopies(**args):
     """List of strings. Files copied in this changeset with
     their sources.
     """
     cache, ctx = args['cache'], args['ctx']
     copies = args['revcache'].get('copies')
     if copies is None:
         if 'getrenamed' not in cache:
             cache['getrenamed'] = getrenamedfn(args['repo'])
         copies = []
         getrenamed = cache['getrenamed']
         for fn in ctx.files():
             rename = getrenamed(fn, ctx.rev())
             if rename:
                 copies.append((fn, rename[0]))
 
     copies = util.sortdict(copies)
     makemap = lambda k: {'name': k, 'source': copies[k]}
     c = [makemap(k) for k in copies]
     f = _showlist('file_copy', c, plural='file_copies', **args)
     return _hybrid(f, copies, makemap,
                    lambda x: '%s (%s)' % (x['name'], x['source']))
 
 # showfilecopiesswitch() displays file copies only if copy records are
 # provided before calling the templater, usually with a --copies
 # command line switch.
 @templatekeyword('file_copies_switch')
 def showfilecopiesswitch(**args):
     """List of strings. Like "file_copies" but displayed
     only if the --copied switch is set.
     """
     copies = args['revcache'].get('copies') or []
     copies = util.sortdict(copies)
     makemap = lambda k: {'name': k, 'source': copies[k]}
     c = [makemap(k) for k in copies]
     f = _showlist('file_copy', c, plural='file_copies', **args)
     return _hybrid(f, copies, makemap,
                    lambda x: '%s (%s)' % (x['name'], x['source']))
 
 @templatekeyword('file_dels')
 def showfiledels(**args):
     """List of strings. Files removed by this changeset."""
     repo, ctx, revcache = args['repo'], args['ctx'], args['revcache']
     return showlist('file_del', getfiles(repo, ctx, revcache)[2],
                     element='file', **args)
 
 @templatekeyword('file_mods')
 def showfilemods(**args):
     """List of strings. Files modified by this changeset."""
     repo, ctx, revcache = args['repo'], args['ctx'], args['revcache']
     return showlist('file_mod', getfiles(repo, ctx, revcache)[0],
                     element='file', **args)
 
 @templatekeyword('files')
 def showfiles(**args):
     """List of strings. All files modified, added, or removed by this
     changeset.
     """
     return showlist('file', args['ctx'].files(), **args)
 
 @templatekeyword('graphnode')
 def showgraphnode(repo, ctx, **args):
     """String. The character representing the changeset node in
     an ASCII revision graph"""
     wpnodes = repo.dirstate.parents()
     if wpnodes[1] == nullid:
         wpnodes = wpnodes[:1]
     if ctx.node() in wpnodes:
         return '@'
     elif ctx.obsolete():
         return 'x'
     elif ctx.closesbranch():
         return '_'
     else:
         return 'o'
 
 @templatekeyword('index')
 def showindex(**args):
     """Integer. The current iteration of the loop. (0 indexed)"""
     # just hosts documentation; should be overridden by template mapping
     raise error.Abort(_("can't use index in this context"))
 
 @templatekeyword('latesttag')
 def showlatesttag(**args):
     """List of strings. The global tags on the most recent globally
     tagged ancestor of this changeset.  If no such tags exist, the list
     consists of the single string "null".
     """
     return showlatesttags(None, **args)
 
 def showlatesttags(pattern, **args):
     """helper method for the latesttag keyword and function"""
     repo, ctx = args['repo'], args['ctx']
     cache = args['cache']
     latesttags = getlatesttags(repo, ctx, cache, pattern)
 
     # latesttag[0] is an implementation detail for sorting csets on different
     # branches in a stable manner- it is the date the tagged cset was created,
     # not the date the tag was created.  Therefore it isn't made visible here.
     makemap = lambda v: {
         'changes': _showchangessincetag,
         'distance': latesttags[1],
         'latesttag': v,   # BC with {latesttag % '{latesttag}'}
         'tag': v
     }
 
     tags = latesttags[2]
     f = _showlist('latesttag', tags, separator=':', **args)
     return _hybrid(f, tags, makemap, lambda x: x['latesttag'])
 
 @templatekeyword('latesttagdistance')
 def showlatesttagdistance(repo, ctx, templ, cache, **args):
     """Integer. Longest path to the latest tag."""
     return getlatesttags(repo, ctx, cache)[1]
 
 @templatekeyword('changessincelatesttag')
 def showchangessincelatesttag(repo, ctx, templ, cache, **args):
     """Integer. All ancestors not in the latest tag."""
     latesttag = getlatesttags(repo, ctx, cache)[2][0]
 
     return _showchangessincetag(repo, ctx, tag=latesttag, **args)
 
 def _showchangessincetag(repo, ctx, **args):
     offset = 0
     revs = [ctx.rev()]
     tag = args['tag']
 
     # The only() revset doesn't currently support wdir()
     if ctx.rev() is None:
         offset = 1
         revs = [p.rev() for p in ctx.parents()]
 
     return len(repo.revs('only(%ld, %s)', revs, tag)) + offset
 
 @templatekeyword('manifest')
 def showmanifest(**args):
     repo, ctx, templ = args['repo'], args['ctx'], args['templ']
     mnode = ctx.manifestnode()
     if mnode is None:
         # just avoid crash, we might want to use the 'ff...' hash in future
         return
     args = args.copy()
     args.update({'rev': repo.manifestlog._revlog.rev(mnode),
                  'node': hex(mnode)})
     return templ('manifest', **args)
 
 def shownames(namespace, **args):
     """helper method to generate a template keyword for a namespace"""
     ctx = args['ctx']
     repo = ctx.repo()
     ns = repo.names[namespace]
     names = ns.names(repo, ctx.node())
     return showlist(ns.templatename, names, plural=namespace, **args)
 
 @templatekeyword('namespaces')
 def shownamespaces(**args):
     """Dict of lists. Names attached to this changeset per
     namespace."""
     ctx = args['ctx']
     repo = ctx.repo()
     namespaces = util.sortdict((k, showlist('name', ns.names(repo, ctx.node()),
                                             **args))
                                for k, ns in repo.names.iteritems())
     f = _showlist('namespace', list(namespaces), **args)
     return _hybrid(f, namespaces,
                    lambda k: {'namespace': k, 'names': namespaces[k]},
                    lambda x: x['namespace'])
 
 @templatekeyword('node')
 def shownode(repo, ctx, templ, **args):
     """String. The changeset identification hash, as a 40 hexadecimal
     digit string.
     """
     return ctx.hex()
 
 @templatekeyword('obsolete')
 def showobsolete(repo, ctx, templ, **args):
     """String. Whether the changeset is obsolete.
     """
     if ctx.obsolete():
         return 'obsolete'
     return ''
 
 @templatekeyword('p1rev')
 def showp1rev(repo, ctx, templ, **args):
     """Integer. The repository-local revision number of the changeset's
     first parent, or -1 if the changeset has no parents."""
     return ctx.p1().rev()
 
 @templatekeyword('p2rev')
 def showp2rev(repo, ctx, templ, **args):
     """Integer. The repository-local revision number of the changeset's
     second parent, or -1 if the changeset has no second parent."""
     return ctx.p2().rev()
 
 @templatekeyword('p1node')
 def showp1node(repo, ctx, templ, **args):
     """String. The identification hash of the changeset's first parent,
     as a 40 digit hexadecimal string. If the changeset has no parents, all
     digits are 0."""
     return ctx.p1().hex()
 
 @templatekeyword('p2node')
 def showp2node(repo, ctx, templ, **args):
     """String. The identification hash of the changeset's second
     parent, as a 40 digit hexadecimal string. If the changeset has no second
     parent, all digits are 0."""
     return ctx.p2().hex()
 
 @templatekeyword('parents')
 def showparents(**args):
     """List of strings. The parents of the changeset in "rev:node"
     format. If the changeset has only one "natural" parent (the predecessor
     revision) nothing is shown."""
     repo = args['repo']
     ctx = args['ctx']
     pctxs = scmutil.meaningfulparents(repo, ctx)
     prevs = [str(p.rev()) for p in pctxs]  # ifcontains() needs a list of str
     parents = [[('rev', p.rev()),
                 ('node', p.hex()),
                 ('phase', p.phasestr())]
                for p in pctxs]
     f = _showlist('parent', parents, **args)
     return _hybrid(f, prevs, lambda x: {'ctx': repo[int(x)], 'revcache': {}},
                    lambda d: _formatrevnode(d['ctx']))
 
 @templatekeyword('phase')
 def showphase(repo, ctx, templ, **args):
     """String. The changeset phase name."""
     return ctx.phasestr()
 
 @templatekeyword('phaseidx')
 def showphaseidx(repo, ctx, templ, **args):
     """Integer. The changeset phase index."""
     return ctx.phase()
 
 @templatekeyword('rev')
 def showrev(repo, ctx, templ, **args):
     """Integer. The repository-local changeset revision number."""
     return scmutil.intrev(ctx.rev())
 
 def showrevslist(name, revs, **args):
     """helper to generate a list of revisions in which a mapped template will
     be evaluated"""
     repo = args['ctx'].repo()
     revs = [str(r) for r in revs]  # ifcontains() needs a list of str
     f = _showlist(name, revs, **args)
     return _hybrid(f, revs,
                    lambda x: {name: x, 'ctx': repo[int(x)], 'revcache': {}},
                    lambda d: d[name])
 
 @templatekeyword('subrepos')
 def showsubrepos(**args):
     """List of strings. Updated subrepositories in the changeset."""
     ctx = args['ctx']
     substate = ctx.substate
     if not substate:
         return showlist('subrepo', [], **args)
     psubstate = ctx.parents()[0].substate or {}
     subrepos = []
     for sub in substate:
         if sub not in psubstate or substate[sub] != psubstate[sub]:
             subrepos.append(sub) # modified or newly added in ctx
     for sub in psubstate:
         if sub not in substate:
             subrepos.append(sub) # removed in ctx
     return showlist('subrepo', sorted(subrepos), **args)
 
 # don't remove "showtags" definition, even though namespaces will put
 # a helper function for "tags" keyword into "keywords" map automatically,
 # because online help text is built without namespaces initialization
 @templatekeyword('tags')
 def showtags(**args):
     """List of strings. Any tags associated with the changeset."""
     return shownames('tags', **args)
 
 def loadkeyword(ui, extname, registrarobj):
     """Load template keyword from specified registrarobj
     """
     for name, func in registrarobj._table.iteritems():
         keywords[name] = func
 
 @templatekeyword('termwidth')
 def termwidth(repo, ctx, templ, **args):
     """Integer. The width of the current terminal."""
     return repo.ui.termwidth()
 
 @templatekeyword('troubles')
 def showtroubles(**args):
     """List of strings. Evolution troubles affecting the changeset.
 
     (EXPERIMENTAL)
     """
     return showlist('trouble', args['ctx'].troubles(), **args)
 
 # tell hggettext to extract docstrings from these functions:
 i18nfunctions = keywords.values()

mercurial/templater.py

@@ -1,1293 +1,1295 b''
 # templater.py - template expansion for output
 #
 # Copyright 2005, 2006 Matt Mackall <[e-mail]>
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 from __future__ import absolute_import
 
 import os
 import re
 import types
 
 from .i18n import _
 from . import (
     color,
     config,
     encoding,
     error,
     minirst,
     parser,
     pycompat,
     registrar,
     revset as revsetmod,
     revsetlang,
     templatefilters,
     templatekw,
     util,
 )
 
 # template parsing
 
 elements = {
     # token-type: binding-strength, primary, prefix, infix, suffix
     "(": (20, None, ("group", 1, ")"), ("func", 1, ")"), None),
     ",": (2, None, None, ("list", 2), None),
     "|": (5, None, None, ("|", 5), None),
     "%": (6, None, None, ("%", 6), None),
     ")": (0, None, None, None, None),
     "+": (3, None, None, ("+", 3), None),
     "-": (3, None, ("negate", 10), ("-", 3), None),
     "*": (4, None, None, ("*", 4), None),
     "/": (4, None, None, ("/", 4), None),
     "integer": (0, "integer", None, None, None),
     "symbol": (0, "symbol", None, None, None),
     "string": (0, "string", None, None, None),
     "template": (0, "template", None, None, None),
     "end": (0, None, None, None, None),
 }
 
 def tokenize(program, start, end, term=None):
     """Parse a template expression into a stream of tokens, which must end
     with term if specified"""
     pos = start
     while pos < end:
         c = program[pos]
         if c.isspace(): # skip inter-token whitespace
             pass
         elif c in "(,)%|+-*/": # handle simple operators
             yield (c, None, pos)
         elif c in '"\'': # handle quoted templates
             s = pos + 1
             data, pos = _parsetemplate(program, s, end, c)
             yield ('template', data, s)
             pos -= 1
         elif c == 'r' and program[pos:pos + 2] in ("r'", 'r"'):
             # handle quoted strings
             c = program[pos + 1]
             s = pos = pos + 2
             while pos < end: # find closing quote
                 d = program[pos]
                 if d == '\\': # skip over escaped characters
                     pos += 2
                     continue
                 if d == c:
                     yield ('string', program[s:pos], s)
                     break
                 pos += 1
             else:
                 raise error.ParseError(_("unterminated string"), s)
         elif c.isdigit():
             s = pos
             while pos < end:
                 d = program[pos]
                 if not d.isdigit():
                     break
                 pos += 1
             yield ('integer', program[s:pos], s)
             pos -= 1
         elif (c == '\\' and program[pos:pos + 2] in (r"\'", r'\"')
               or c == 'r' and program[pos:pos + 3] in (r"r\'", r'r\"')):
             # handle escaped quoted strings for compatibility with 2.9.2-3.4,
             # where some of nested templates were preprocessed as strings and
             # then compiled. therefore, \"...\" was allowed. (issue4733)
             #
             # processing flow of _evalifliteral() at 5ab28a2e9962:
             # outer template string    -> stringify()  -> compiletemplate()
             # ------------------------    ------------    ------------------
             # {f("\\\\ {g(\"\\\"\")}"}    \\ {g("\"")}    [r'\\', {g("\"")}]
             #             ~~~~~~~~
             #             escaped quoted string
             if c == 'r':
                 pos += 1
                 token = 'string'
             else:
                 token = 'template'
             quote = program[pos:pos + 2]
             s = pos = pos + 2
             while pos < end: # find closing escaped quote
                 if program.startswith('\\\\\\', pos, end):
                     pos += 4 # skip over double escaped characters
                     continue
                 if program.startswith(quote, pos, end):
                     # interpret as if it were a part of an outer string
                     data = parser.unescapestr(program[s:pos])
                     if token == 'template':
                         data = _parsetemplate(data, 0, len(data))[0]
                     yield (token, data, s)
                     pos += 1
                     break
                 pos += 1
             else:
                 raise error.ParseError(_("unterminated string"), s)
         elif c.isalnum() or c in '_':
             s = pos
             pos += 1
             while pos < end: # find end of symbol
                 d = program[pos]
                 if not (d.isalnum() or d == "_"):
                     break
                 pos += 1
             sym = program[s:pos]
             yield ('symbol', sym, s)
             pos -= 1
         elif c == term:
             yield ('end', None, pos + 1)
             return
         else:
             raise error.ParseError(_("syntax error"), pos)
         pos += 1
     if term:
         raise error.ParseError(_("unterminated template expansion"), start)
     yield ('end', None, pos)
 
 def _parsetemplate(tmpl, start, stop, quote=''):
     r"""
     >>> _parsetemplate('foo{bar}"baz', 0, 12)
     ([('string', 'foo'), ('symbol', 'bar'), ('string', '"baz')], 12)
     >>> _parsetemplate('foo{bar}"baz', 0, 12, quote='"')
     ([('string', 'foo'), ('symbol', 'bar')], 9)
     >>> _parsetemplate('foo"{bar}', 0, 9, quote='"')
     ([('string', 'foo')], 4)
     >>> _parsetemplate(r'foo\"bar"baz', 0, 12, quote='"')
     ([('string', 'foo"'), ('string', 'bar')], 9)
     >>> _parsetemplate(r'foo\\"bar', 0, 10, quote='"')
     ([('string', 'foo\\')], 6)
     """
     parsed = []
     sepchars = '{' + quote
     pos = start
     p = parser.parser(elements)
     while pos < stop:
         n = min((tmpl.find(c, pos, stop) for c in sepchars),
                 key=lambda n: (n < 0, n))
         if n < 0:
             parsed.append(('string', parser.unescapestr(tmpl[pos:stop])))
             pos = stop
             break
         c = tmpl[n]
         bs = (n - pos) - len(tmpl[pos:n].rstrip('\\'))
         if bs % 2 == 1:
             # escaped (e.g. '\{', '\\\{', but not '\\{')
             parsed.append(('string', parser.unescapestr(tmpl[pos:n - 1]) + c))
             pos = n + 1
             continue
         if n > pos:
             parsed.append(('string', parser.unescapestr(tmpl[pos:n])))
         if c == quote:
             return parsed, n + 1
 
         parseres, pos = p.parse(tokenize(tmpl, n + 1, stop, '}'))
         parsed.append(parseres)
 
     if quote:
         raise error.ParseError(_("unterminated string"), start)
     return parsed, pos
 
 def _unnesttemplatelist(tree):
     """Expand list of templates to node tuple
 
     >>> def f(tree):
     ...     print prettyformat(_unnesttemplatelist(tree))
     >>> f(('template', []))
     ('string', '')
     >>> f(('template', [('string', 'foo')]))
     ('string', 'foo')
     >>> f(('template', [('string', 'foo'), ('symbol', 'rev')]))
     (template
       ('string', 'foo')
       ('symbol', 'rev'))
     >>> f(('template', [('symbol', 'rev')]))  # template(rev) -> str
     (template
       ('symbol', 'rev'))
     >>> f(('template', [('template', [('string', 'foo')])]))
     ('string', 'foo')
     """
     if not isinstance(tree, tuple):
         return tree
     op = tree[0]
     if op != 'template':
         return (op,) + tuple(_unnesttemplatelist(x) for x in tree[1:])
 
     assert len(tree) == 2
     xs = tuple(_unnesttemplatelist(x) for x in tree[1])
     if not xs:
         return ('string', '')  # empty template ""
     elif len(xs) == 1 and xs[0][0] == 'string':
         return xs[0]  # fast path for string with no template fragment "x"
     else:
         return (op,) + xs
 
 def parse(tmpl):
     """Parse template string into tree"""
     parsed, pos = _parsetemplate(tmpl, 0, len(tmpl))
     assert pos == len(tmpl), 'unquoted template should be consumed'
     return _unnesttemplatelist(('template', parsed))
 
 def _parseexpr(expr):
     """Parse a template expression into tree
 
     >>> _parseexpr('"foo"')
     ('string', 'foo')
     >>> _parseexpr('foo(bar)')
     ('func', ('symbol', 'foo'), ('symbol', 'bar'))
     >>> _parseexpr('foo(')
     Traceback (most recent call last):
       ...
     ParseError: ('not a prefix: end', 4)
     >>> _parseexpr('"foo" "bar"')
     Traceback (most recent call last):
       ...
     ParseError: ('invalid token', 7)
     """
     p = parser.parser(elements)
     tree, pos = p.parse(tokenize(expr, 0, len(expr)))
     if pos != len(expr):
         raise error.ParseError(_('invalid token'), pos)
     return _unnesttemplatelist(tree)
 
 def prettyformat(tree):
     return parser.prettyformat(tree, ('integer', 'string', 'symbol'))
 
 def compileexp(exp, context, curmethods):
     """Compile parsed template tree to (func, data) pair"""
     t = exp[0]
     if t in curmethods:
         return curmethods[t](exp, context)
     raise error.ParseError(_("unknown method '%s'") % t)
 
 # template evaluation
 
 def getsymbol(exp):
     if exp[0] == 'symbol':
         return exp[1]
     raise error.ParseError(_("expected a symbol, got '%s'") % exp[0])
 
 def getlist(x):
     if not x:
         return []
     if x[0] == 'list':
         return getlist(x[1]) + [x[2]]
     return [x]
 
 def gettemplate(exp, context):
     """Compile given template tree or load named template from map file;
     returns (func, data) pair"""
     if exp[0] in ('template', 'string'):
         return compileexp(exp, context, methods)
     if exp[0] == 'symbol':
         # unlike runsymbol(), here 'symbol' is always taken as template name
         # even if it exists in mapping. this allows us to override mapping
         # by web templates, e.g. 'changelogtag' is redefined in map file.
         return context._load(exp[1])
     raise error.ParseError(_("expected template specifier"))
 
 def evalfuncarg(context, mapping, arg):
     func, data = arg
     # func() may return string, generator of strings or arbitrary object such
     # as date tuple, but filter does not want generator.
     thing = func(context, mapping, data)
     if isinstance(thing, types.GeneratorType):
         thing = stringify(thing)
     return thing
 
 def 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 = util.parsebool(data)
     else:
         thing = func(context, mapping, data)
     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(thing))
 
 def evalinteger(context, mapping, arg, err):
     v = evalfuncarg(context, mapping, arg)
     try:
         return int(v)
     except (TypeError, ValueError):
         raise error.ParseError(err)
 
 def evalstring(context, mapping, arg):
     func, data = arg
     return stringify(func(context, mapping, data))
 
 def evalstringliteral(context, mapping, arg):
     """Evaluate given argument as string template, but returns symbol name
     if it is unknown"""
     func, data = arg
     if func is runsymbol:
         thing = func(context, mapping, data, default=data)
     else:
         thing = func(context, mapping, data)
     return stringify(thing)
 
 def runinteger(context, mapping, data):
     return int(data)
 
 def runstring(context, mapping, data):
     return data
 
 def _recursivesymbolblocker(key):
     def showrecursion(**args):
         raise error.Abort(_("recursive reference '%s' in template") % key)
     return showrecursion
 
 def _runrecursivesymbol(context, mapping, key):
     raise error.Abort(_("recursive reference '%s' in template") % key)
 
 def runsymbol(context, mapping, key, default=''):
     v = mapping.get(key)
     if v is None:
         v = context._defaults.get(key)
     if v is None:
         # put poison to cut recursion. we can't move this to parsing phase
         # because "x = {x}" is allowed if "x" is a keyword. (issue4758)
         safemapping = mapping.copy()
         safemapping[key] = _recursivesymbolblocker(key)
         try:
             v = context.process(key, safemapping)
         except TemplateNotFound:
             v = default
     if callable(v):
         return v(**mapping)
     return v
 
 def buildtemplate(exp, context):
     ctmpl = [compileexp(e, context, methods) for e in exp[1:]]
     return (runtemplate, ctmpl)
 
 def runtemplate(context, mapping, template):
     for func, data in template:
         yield func(context, mapping, data)
 
 def buildfilter(exp, context):
     arg = compileexp(exp[1], context, methods)
     n = getsymbol(exp[2])
     if n in context._filters:
         filt = context._filters[n]
         return (runfilter, (arg, filt))
     if n in funcs:
         f = funcs[n]
         return (f, [arg])
     raise error.ParseError(_("unknown function '%s'") % n)
 
 def runfilter(context, mapping, data):
     arg, filt = data
     thing = evalfuncarg(context, mapping, arg)
     try:
         return filt(thing)
     except (ValueError, AttributeError, TypeError):
         if isinstance(arg[1], tuple):
             dt = arg[1][1]
         else:
             dt = arg[1]
         raise error.Abort(_("template filter '%s' is not compatible with "
                            "keyword '%s'") % (filt.func_name, dt))
 
 def buildmap(exp, context):
     func, data = compileexp(exp[1], context, methods)
     tfunc, tdata = gettemplate(exp[2], context)
     return (runmap, (func, data, tfunc, tdata))
 
 def runmap(context, mapping, data):
     func, data, tfunc, tdata = data
     d = func(context, mapping, data)
     if util.safehasattr(d, 'itermaps'):
         diter = d.itermaps()
     else:
         try:
             diter = iter(d)
         except TypeError:
             if func is runsymbol:
                 raise error.ParseError(_("keyword '%s' is not iterable") % data)
             else:
                 raise error.ParseError(_("%r is not iterable") % d)
 
     for i, v in enumerate(diter):
         lm = mapping.copy()
         lm['index'] = i
         if isinstance(v, dict):
             lm.update(v)
             lm['originalnode'] = mapping.get('node')
             yield tfunc(context, lm, tdata)
         else:
             # v is not an iterable of dicts, this happen when 'key'
             # has been fully expanded already and format is useless.
             # If so, return the expanded value.
             yield v
 
 def buildnegate(exp, context):
     arg = compileexp(exp[1], context, exprmethods)
     return (runnegate, arg)
 
 def runnegate(context, mapping, data):
     data = evalinteger(context, mapping, data,
                        _('negation needs an integer argument'))
     return -data
 
 def buildarithmetic(exp, context, func):
     left = compileexp(exp[1], context, exprmethods)
     right = compileexp(exp[2], context, exprmethods)
     return (runarithmetic, (func, left, right))
 
 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 buildfunc(exp, context):
     n = getsymbol(exp[1])
     args = [compileexp(x, context, exprmethods) for x in getlist(exp[2])]
     if n in funcs:
         f = funcs[n]
         return (f, args)
     if n in context._filters:
         if len(args) != 1:
             raise error.ParseError(_("filter %s expects one argument") % n)
         f = context._filters[n]
         return (runfilter, (args[0], f))
     raise error.ParseError(_("unknown function '%s'") % n)
 
 # 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 = evalfuncarg(context, mapping, args[0])
     fmt = None
     if len(args) == 2:
         fmt = evalstring(context, mapping, args[1])
     try:
         if fmt is None:
             return util.datestr(date)
         else:
             return util.datestr(date, fmt)
     except (TypeError, ValueError):
         # i18n: "date" is a keyword
         raise error.ParseError(_("date expects a date information"))
 
 @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 = mapping['ctx']
     chunks = ctx.diff(match=ctx.match([], getpatterns(0), getpatterns(1)))
 
     return ''.join(chunks)
 
 @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 = mapping['ctx']
     m = ctx.match([raw])
     files = list(ctx.matches(m))
     return templatekw.showlist("file", files, **mapping)
 
 @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 = mapping['ui']
     node = evalstring(context, mapping, args[0])
     if ui.debugflag:
         return node
     return templatefilters.short(node)
 
 @templatefunc('pad(text, width[, fillchar=\' \'[, left=False]])')
 def pad(context, mapping, args):
     """Pad text with a
     fill character."""
     if not (2 <= len(args) <= 4):
         # i18n: "pad" is a keyword
         raise error.ParseError(_("pad() expects two to four arguments"))
 
     width = evalinteger(context, mapping, args[1],
                         # i18n: "pad" is a keyword
                         _("pad() expects an integer width"))
 
     text = evalstring(context, mapping, args[0])
 
     left = False
     fillchar = ' '
     if len(args) > 2:
         fillchar = evalstring(context, mapping, args[2])
         if len(color.stripeffects(fillchar)) != 1:
             # i18n: "pad" is a keyword
             raise error.ParseError(_("pad() expects a single fill character"))
     if len(args) > 3:
         left = evalboolean(context, mapping, args[3])
 
     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 = evalfuncarg(context, mapping, args[0])
     if not util.safehasattr(dictarg, 'get'):
         # i18n: "get" is a keyword
         raise error.ParseError(_("get() expects a dict as first argument"))
 
     key = evalfuncarg(context, mapping, args[1])
     return dictarg.get(key)
 
 @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:
         yield args[1][0](context, mapping, args[1][1])
     elif len(args) == 3:
         yield args[2][0](context, mapping, args[2][1])
 
 @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"))
 
     needle = evalstring(context, mapping, args[0])
     haystack = evalfuncarg(context, mapping, args[1])
 
     if needle in haystack:
         yield args[2][0](context, mapping, args[2][1])
     elif len(args) == 4:
         yield args[3][0](context, mapping, args[3][1])
 
 @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:
         yield args[2][0](context, mapping, args[2][1])
     elif len(args) == 4:
         yield args[3][0](context, mapping, args[3][1])
 
 @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 = args[0][0](context, mapping, args[0][1])
     if util.safehasattr(joinset, 'itermaps'):
         jf = joinset.joinfmt
         joinset = [jf(x) for x in joinset.itermaps()]
 
     joiner = " "
     if len(args) > 1:
         joiner = evalstring(context, mapping, args[1])
 
     first = True
     for x in joinset:
         if first:
             first = False
         else:
             yield joiner
         yield x
 
 @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 = 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"."""
     if len(args) > 1:
         # i18n: "latesttag" is a keyword
         raise error.ParseError(_("latesttag expects at most one argument"))
 
     pattern = None
     if len(args) == 1:
         pattern = evalstring(context, mapping, args[0])
 
     return templatekw.showlatesttags(pattern, **mapping)
 
 @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 = evalfuncarg(context, mapping, args[0])
     try:
         date = util.parsedate(date)
     except AttributeError:  # not str nor date tuple
         # i18n: "localdate" is a keyword
         raise error.ParseError(_("localdate expects a date information"))
     if len(args) >= 2:
         tzoffset = None
         tz = evalfuncarg(context, mapping, args[1])
         if isinstance(tz, str):
             tzoffset, remainder = util.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 = util.makedate()[1]
     return (date[0], tzoffset)
 
 @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 runarithmetic(context, mapping, (func, args[0], args[1]))
 
 @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 = 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 = mapping['ctx']
     repo = ctx.repo()
 
     def query(expr):
         m = revsetmod.match(repo.ui, expr)
         return m(repo)
 
     if len(args) > 1:
         formatargs = [evalfuncarg(context, mapping, a) for a in args[1:]]
         revs = query(revsetlang.formatspec(raw, *formatargs))
         revs = list(revs)
     else:
         revsetcache = mapping['cache'].setdefault("revsetcache", {})
         if raw in revsetcache:
             revs = revsetcache[raw]
         else:
             revs = query(raw)
             revs = list(revs)
             revsetcache[raw] = revs
 
     return templatekw.showrevslist("revision", revs, **mapping)
 
 @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'])
 
 @templatefunc('separate(sep, args)')
 def separate(context, mapping, args):
     """Add a separator between non-empty arguments."""
     if not args:
         # i18n: "separate" is a keyword
         raise error.ParseError(_("separate expects at least one argument"))
 
     sep = evalstring(context, mapping, args[0])
     first = True
     for arg in args[1:]:
         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"))
 
     node = evalstring(context, mapping, args[0])
 
     minlength = 4
     if len(args) > 1:
         minlength = evalinteger(context, mapping, args[1],
                                 # i18n: "shortest" is a keyword
                                 _("shortest() expects an integer minlength"))
 
     # _partialmatch() of filtered changelog could take O(len(repo)) time,
     # which would be unacceptably slow. so we look for hash collision in
     # unfiltered space, which means some hashes may be slightly longer.
     cl = mapping['ctx']._repo.unfiltered().changelog
     def isvalid(test):
         try:
             if cl._partialmatch(test) is None:
                 return False
 
             try:
                 i = int(test)
                 # if we are a pure int, then starting with zero will not be
                 # confused as a rev; or, obviously, if the int is larger than
                 # the value of the tip rev
                 if test[0] == '0' or i > len(cl):
                     return True
                 return False
             except ValueError:
                 return True
         except error.RevlogError:
             return False
 
     shortest = node
     startlength = max(6, minlength)
     length = startlength
     while True:
         test = node[:length]
         if isvalid(test):
             shortest = test
             if length == minlength or length > startlength:
                 return shortest
             length -= 1
         else:
             length += 1
             if len(shortest) <= length:
                 return shortest
 
 @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]
 
 # methods to interpret function arguments or inner expressions (e.g. {_(x)})
 exprmethods = {
     "integer": lambda e, c: (runinteger, e[1]),
     "string": lambda e, c: (runstring, e[1]),
     "symbol": lambda e, c: (runsymbol, e[1]),
     "template": buildtemplate,
     "group": lambda e, c: compileexp(e[1], c, exprmethods),
 #    ".": buildmember,
     "|": buildfilter,
     "%": buildmap,
     "func": buildfunc,
     "+": lambda e, c: buildarithmetic(e, c, lambda a, b: a + b),
     "-": lambda e, c: buildarithmetic(e, c, lambda a, b: a - b),
     "negate": buildnegate,
     "*": lambda e, c: buildarithmetic(e, c, lambda a, b: a * b),
     "/": lambda e, c: buildarithmetic(e, c, lambda a, b: a // b),
     }
 
 # methods to interpret top-level template (e.g. {x}, {x|_}, {x % "y"})
 methods = exprmethods.copy()
 methods["integer"] = exprmethods["symbol"]  # '{1}' as variable
 
 class _aliasrules(parser.basealiasrules):
     """Parsing and expansion rule set of template aliases"""
     _section = _('template alias')
     _parse = staticmethod(_parseexpr)
 
     @staticmethod
     def _trygetfunc(tree):
         """Return (name, args) if tree is func(...) or ...|filter; otherwise
         None"""
         if tree[0] == 'func' and tree[1][0] == 'symbol':
             return tree[1][1], getlist(tree[2])
         if tree[0] == '|' and tree[2][0] == 'symbol':
             return tree[2][1], [tree[1]]
 
 def expandaliases(tree, aliases):
     """Return new tree of aliases are expanded"""
     aliasmap = _aliasrules.buildmap(aliases)
     return _aliasrules.expand(aliasmap, tree)
 
 # template engine
 
 stringify = templatefilters.stringify
 
 def _flatten(thing):
     '''yield a single stream from a possibly nested set of iterators'''
+    thing = templatekw.unwraphybrid(thing)
     if isinstance(thing, str):
         yield thing
     elif thing is None:
         pass
     elif not util.safehasattr(thing, '__iter__'):
         yield str(thing)
     else:
         for i in thing:
+            i = templatekw.unwraphybrid(i)
             if isinstance(i, str):
                 yield i
             elif i is None:
                 pass
             elif not util.safehasattr(i, '__iter__'):
                 yield str(i)
             else:
                 for j in _flatten(i):
                     yield j
 
 def unquotestring(s):
     '''unwrap quotes if any; otherwise returns unmodified string'''
     if len(s) < 2 or s[0] not in "'\"" or s[0] != s[-1]:
         return s
     return s[1:-1]
 
 class engine(object):
     '''template expansion engine.
 
     template expansion works like this. a map file contains key=value
     pairs. if value is quoted, it is treated as string. otherwise, it
     is treated as name of template file.
 
     templater is asked to expand a key in map. it looks up key, and
     looks for strings like this: {foo}. it expands {foo} by looking up
     foo in map, and substituting it. expansion is recursive: it stops
     when there is no more {foo} to replace.
 
     expansion also allows formatting and filtering.
 
     format uses key to expand each item in list. syntax is
     {key%format}.
 
     filter uses function to transform value. syntax is
     {key|filter1|filter2|...}.'''
 
     def __init__(self, loader, filters=None, defaults=None, aliases=()):
         self._loader = loader
         if filters is None:
             filters = {}
         self._filters = filters
         if defaults is None:
             defaults = {}
         self._defaults = defaults
         self._aliasmap = _aliasrules.buildmap(aliases)
         self._cache = {}  # key: (func, data)
 
     def _load(self, t):
         '''load, parse, and cache a template'''
         if t not in self._cache:
             # put poison to cut recursion while compiling 't'
             self._cache[t] = (_runrecursivesymbol, t)
             try:
                 x = parse(self._loader(t))
                 if self._aliasmap:
                     x = _aliasrules.expand(self._aliasmap, x)
                 self._cache[t] = compileexp(x, self, methods)
             except: # re-raises
                 del self._cache[t]
                 raise
         return self._cache[t]
 
     def process(self, t, mapping):
         '''Perform expansion. t is name of map element to expand.
         mapping contains added elements for use during expansion. Is a
         generator.'''
         func, data = self._load(t)
         return _flatten(func(self, mapping, data))
 
 engines = {'default': engine}
 
 def stylelist():
     paths = templatepaths()
     if not paths:
         return _('no templates found, try `hg debuginstall` for more info')
     dirlist = os.listdir(paths[0])
     stylelist = []
     for file in dirlist:
         split = file.split(".")
         if split[-1] in ('orig', 'rej'):
             continue
         if split[0] == "map-cmdline":
             stylelist.append(split[1])
     return ", ".join(sorted(stylelist))
 
 def _readmapfile(mapfile):
     """Load template elements from the given map file"""
     if not os.path.exists(mapfile):
         raise error.Abort(_("style '%s' not found") % mapfile,
                           hint=_("available styles: %s") % stylelist())
 
     base = os.path.dirname(mapfile)
     conf = config.config(includepaths=templatepaths())
     conf.read(mapfile)
 
     cache = {}
     tmap = {}
     for key, val in conf[''].items():
         if not val:
             raise error.ParseError(_('missing value'), conf.source('', key))
         if val[0] in "'\"":
             if val[0] != val[-1]:
                 raise error.ParseError(_('unmatched quotes'),
                                        conf.source('', key))
             cache[key] = unquotestring(val)
         elif key == "__base__":
             # treat as a pointer to a base class for this style
             path = util.normpath(os.path.join(base, val))
 
             # fallback check in template paths
             if not os.path.exists(path):
                 for p in templatepaths():
                     p2 = util.normpath(os.path.join(p, val))
                     if os.path.isfile(p2):
                         path = p2
                         break
                     p3 = util.normpath(os.path.join(p2, "map"))
                     if os.path.isfile(p3):
                         path = p3
                         break
 
             bcache, btmap = _readmapfile(path)
             for k in bcache:
                 if k not in cache:
                     cache[k] = bcache[k]
             for k in btmap:
                 if k not in tmap:
                     tmap[k] = btmap[k]
         else:
             val = 'default', val
             if ':' in val[1]:
                 val = val[1].split(':', 1)
             tmap[key] = val[0], os.path.join(base, val[1])
     return cache, tmap
 
 class TemplateNotFound(error.Abort):
     pass
 
 class templater(object):
 
     def __init__(self, filters=None, defaults=None, cache=None, aliases=(),
                  minchunk=1024, maxchunk=65536):
         '''set up template engine.
         filters is dict of functions. each transforms a value into another.
         defaults is dict of default map definitions.
         aliases is list of alias (name, replacement) pairs.
         '''
         if filters is None:
             filters = {}
         if defaults is None:
             defaults = {}
         if cache is None:
             cache = {}
         self.cache = cache.copy()
         self.map = {}
         self.filters = templatefilters.filters.copy()
         self.filters.update(filters)
         self.defaults = defaults
         self._aliases = aliases
         self.minchunk, self.maxchunk = minchunk, maxchunk
         self.ecache = {}
 
     @classmethod
     def frommapfile(cls, mapfile, filters=None, defaults=None, cache=None,
                     minchunk=1024, maxchunk=65536):
         """Create templater from the specified map file"""
         t = cls(filters, defaults, cache, [], minchunk, maxchunk)
         cache, tmap = _readmapfile(mapfile)
         t.cache.update(cache)
         t.map = tmap
         return t
 
     def __contains__(self, key):
         return key in self.cache or key in self.map
 
     def load(self, t):
         '''Get the template for the given template name. Use a local cache.'''
         if t not in self.cache:
             try:
                 self.cache[t] = util.readfile(self.map[t][1])
             except KeyError as inst:
                 raise TemplateNotFound(_('"%s" not in template map') %
                                        inst.args[0])
             except IOError as inst:
                 raise IOError(inst.args[0], _('template file %s: %s') %
                               (self.map[t][1], inst.args[1]))
         return self.cache[t]
 
     def __call__(self, t, **mapping):
         ttype = t in self.map and self.map[t][0] or 'default'
         if ttype not in self.ecache:
             try:
                 ecls = engines[ttype]
             except KeyError:
                 raise error.Abort(_('invalid template engine: %s') % ttype)
             self.ecache[ttype] = ecls(self.load, self.filters, self.defaults,
                                       self._aliases)
         proc = self.ecache[ttype]
 
         stream = proc.process(t, mapping)
         if self.minchunk:
             stream = util.increasingchunks(stream, min=self.minchunk,
                                            max=self.maxchunk)
         return stream
 
 def templatepaths():
     '''return locations used for template files.'''
     pathsrel = ['templates']
     paths = [os.path.normpath(os.path.join(util.datapath, f))
              for f in pathsrel]
     return [p for p in paths if os.path.isdir(p)]
 
 def templatepath(name):
     '''return location of template file. returns None if not found.'''
     for p in templatepaths():
         f = os.path.join(p, name)
         if os.path.exists(f):
             return f
     return None
 
 def stylemap(styles, paths=None):
     """Return path to mapfile for a given style.
 
     Searches mapfile in the following locations:
     1. templatepath/style/map
     2. templatepath/map-style
     3. templatepath/map
     """
 
     if paths is None:
         paths = templatepaths()
     elif isinstance(paths, str):
         paths = [paths]
 
     if isinstance(styles, str):
         styles = [styles]
 
     for style in styles:
         # only plain name is allowed to honor template paths
         if (not style
             or style in (os.curdir, os.pardir)
             or pycompat.ossep in style
             or pycompat.osaltsep and pycompat.osaltsep in style):
             continue
         locations = [os.path.join(style, 'map'), 'map-' + style]
         locations.append('map')
 
         for path in paths:
             for location in locations:
                 mapfile = os.path.join(path, location)
                 if os.path.isfile(mapfile):
                     return style, mapfile
 
     raise RuntimeError("No hgweb templates found in %r" % paths)
 
 def loadfunction(ui, extname, registrarobj):
     """Load template function from specified registrarobj
     """
     for name, func in registrarobj._table.iteritems():
         funcs[name] = func
 
 # tell hggettext to extract docstrings from these functions:
 i18nfunctions = funcs.values()