templatefilters: allow declaration of input data type

Currently filters take an unwrapped value, which should have no hybrid magic
but actually it does because stringify() relies on it. The 'intype' allows
us to pre-process the magic by .e.g. evalstring() keeping filter functions
as simple as they are now.

stringify() is ported as an example. More follow.

mercurial/registrar.py

@@ -1,437 +1,443 b''
 # registrar.py - utilities to register function for specific purpose
 #
 #  Copyright FUJIWARA Katsunori <[e-mail]> and others
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 from __future__ import absolute_import
 
 from . import (
     configitems,
     error,
     pycompat,
     util,
 )
 
 # unlike the other registered items, config options are neither functions or
 # classes. Registering the option is just small function call.
 #
 # We still add the official API to the registrar module for consistency with
 # the other items extensions want might to register.
 configitem = configitems.getitemregister
 
 class _funcregistrarbase(object):
     """Base of decorator to register a function for specific purpose
 
     This decorator stores decorated functions into own dict 'table'.
 
     The least derived class can be defined by overriding 'formatdoc',
     for example::
 
         class keyword(_funcregistrarbase):
             _docformat = ":%s: %s"
 
     This should be used as below:
 
         keyword = registrar.keyword()
 
         @keyword('bar')
         def barfunc(*args, **kwargs):
             '''Explanation of bar keyword ....
             '''
             pass
 
     In this case:
 
     - 'barfunc' is stored as 'bar' in '_table' of an instance 'keyword' above
     - 'barfunc.__doc__' becomes ":bar: Explanation of bar keyword"
     """
     def __init__(self, table=None):
         if table is None:
             self._table = {}
         else:
             self._table = table
 
     def __call__(self, decl, *args, **kwargs):
         return lambda func: self._doregister(func, decl, *args, **kwargs)
 
     def _doregister(self, func, decl, *args, **kwargs):
         name = self._getname(decl)
 
         if name in self._table:
             msg = 'duplicate registration for name: "%s"' % name
             raise error.ProgrammingError(msg)
 
         if func.__doc__ and not util.safehasattr(func, '_origdoc'):
             doc = pycompat.sysbytes(func.__doc__).strip()
             func._origdoc = doc
             func.__doc__ = pycompat.sysstr(self._formatdoc(decl, doc))
 
         self._table[name] = func
         self._extrasetup(name, func, *args, **kwargs)
 
         return func
 
     def _parsefuncdecl(self, decl):
         """Parse function declaration and return the name of function in it
         """
         i = decl.find('(')
         if i >= 0:
             return decl[:i]
         else:
             return decl
 
     def _getname(self, decl):
         """Return the name of the registered function from decl
 
         Derived class should override this, if it allows more
         descriptive 'decl' string than just a name.
         """
         return decl
 
     _docformat = None
 
     def _formatdoc(self, decl, doc):
         """Return formatted document of the registered function for help
 
         'doc' is '__doc__.strip()' of the registered function.
         """
         return self._docformat % (decl, doc)
 
     def _extrasetup(self, name, func):
         """Execute exra setup for registered function, if needed
         """
 
 class command(_funcregistrarbase):
     """Decorator to register a command function to table
 
     This class receives a command table as its argument. The table should
     be a dict.
 
     The created object can be used as a decorator for adding commands to
     that command table. This accepts multiple arguments to define a command.
 
     The first argument is the command name (as bytes).
 
     The `options` keyword argument is an iterable of tuples defining command
     arguments. See ``mercurial.fancyopts.fancyopts()`` for the format of each
     tuple.
 
     The `synopsis` argument defines a short, one line summary of how to use the
     command. This shows up in the help output.
 
     There are three arguments that control what repository (if any) is found
     and passed to the decorated function: `norepo`, `optionalrepo`, and
     `inferrepo`.
 
     The `norepo` argument defines whether the command does not require a
     local repository. Most commands operate against a repository, thus the
     default is False. When True, no repository will be passed.
 
     The `optionalrepo` argument defines whether the command optionally requires
     a local repository. If no repository can be found, None will be passed
     to the decorated function.
 
     The `inferrepo` argument defines whether to try to find a repository from
     the command line arguments. If True, arguments will be examined for
     potential repository locations. See ``findrepo()``. If a repository is
     found, it will be used and passed to the decorated function.
 
     There are three constants in the class which tells what type of the command
     that is. That information will be helpful at various places. It will be also
     be used to decide what level of access the command has on hidden commits.
     The constants are:
 
     `unrecoverablewrite` is for those write commands which can't be recovered
     like push.
     `recoverablewrite` is for write commands which can be recovered like commit.
     `readonly` is for commands which are read only.
 
     The signature of the decorated function looks like this:
         def cmd(ui[, repo] [, <args>] [, <options>])
 
       `repo` is required if `norepo` is False.
       `<args>` are positional args (or `*args`) arguments, of non-option
       arguments from the command line.
       `<options>` are keyword arguments (or `**options`) of option arguments
       from the command line.
 
     See the WritingExtensions and MercurialApi documentation for more exhaustive
     descriptions and examples.
     """
 
     unrecoverablewrite = "unrecoverable"
     recoverablewrite = "recoverable"
     readonly = "readonly"
 
     possiblecmdtypes = {unrecoverablewrite, recoverablewrite, readonly}
 
     def _doregister(self, func, name, options=(), synopsis=None,
                     norepo=False, optionalrepo=False, inferrepo=False,
                     cmdtype=unrecoverablewrite):
 
         if cmdtype not in self.possiblecmdtypes:
             raise error.ProgrammingError("unknown cmdtype value '%s' for "
                                          "'%s' command" % (cmdtype, name))
         func.norepo = norepo
         func.optionalrepo = optionalrepo
         func.inferrepo = inferrepo
         func.cmdtype = cmdtype
         if synopsis:
             self._table[name] = func, list(options), synopsis
         else:
             self._table[name] = func, list(options)
         return func
 
 class revsetpredicate(_funcregistrarbase):
     """Decorator to register revset predicate
 
     Usage::
 
         revsetpredicate = registrar.revsetpredicate()
 
         @revsetpredicate('mypredicate(arg1, arg2[, arg3])')
         def mypredicatefunc(repo, subset, x):
             '''Explanation of this revset predicate ....
             '''
             pass
 
     The first string argument is used also in online help.
 
     Optional argument 'safe' indicates whether a predicate is safe for
     DoS attack (False by default).
 
     Optional argument 'takeorder' indicates whether a predicate function
     takes ordering policy as the last argument.
 
     Optional argument 'weight' indicates the estimated run-time cost, useful
     for static optimization, default is 1. Higher weight means more expensive.
     Usually, revsets that are fast and return only one revision has a weight of
     0.5 (ex. a symbol); revsets with O(changelog) complexity and read only the
     changelog have weight 10 (ex. author); revsets reading manifest deltas have
     weight 30 (ex. adds); revset reading manifest contents have weight 100
     (ex. contains). Note: those values are flexible. If the revset has a
     same big-O time complexity as 'contains', but with a smaller constant, it
     might have a weight of 90.
 
     'revsetpredicate' instance in example above can be used to
     decorate multiple functions.
 
     Decorated functions are registered automatically at loading
     extension, if an instance named as 'revsetpredicate' is used for
     decorating in extension.
 
     Otherwise, explicit 'revset.loadpredicate()' is needed.
     """
     _getname = _funcregistrarbase._parsefuncdecl
     _docformat = "``%s``\n    %s"
 
     def _extrasetup(self, name, func, safe=False, takeorder=False, weight=1):
         func._safe = safe
         func._takeorder = takeorder
         func._weight = weight
 
 class filesetpredicate(_funcregistrarbase):
     """Decorator to register fileset predicate
 
     Usage::
 
         filesetpredicate = registrar.filesetpredicate()
 
         @filesetpredicate('mypredicate()')
         def mypredicatefunc(mctx, x):
             '''Explanation of this fileset predicate ....
             '''
             pass
 
     The first string argument is used also in online help.
 
     Optional argument 'callstatus' indicates whether a predicate
      implies 'matchctx.status()' at runtime or not (False, by
      default).
 
     Optional argument 'callexisting' indicates whether a predicate
     implies 'matchctx.existing()' at runtime or not (False, by
     default).
 
     'filesetpredicate' instance in example above can be used to
     decorate multiple functions.
 
     Decorated functions are registered automatically at loading
     extension, if an instance named as 'filesetpredicate' is used for
     decorating in extension.
 
     Otherwise, explicit 'fileset.loadpredicate()' is needed.
     """
     _getname = _funcregistrarbase._parsefuncdecl
     _docformat = "``%s``\n    %s"
 
     def _extrasetup(self, name, func, callstatus=False, callexisting=False):
         func._callstatus = callstatus
         func._callexisting = callexisting
 
 class _templateregistrarbase(_funcregistrarbase):
     """Base of decorator to register functions as template specific one
     """
     _docformat = ":%s: %s"
 
 class templatekeyword(_templateregistrarbase):
     """Decorator to register template keyword
 
     Usage::
 
         templatekeyword = registrar.templatekeyword()
 
         # new API (since Mercurial 4.6)
         @templatekeyword('mykeyword', requires={'repo', 'ctx'})
         def mykeywordfunc(context, mapping):
             '''Explanation of this template keyword ....
             '''
             pass
 
         # old API
         @templatekeyword('mykeyword')
         def mykeywordfunc(repo, ctx, templ, cache, revcache, **args):
             '''Explanation of this template keyword ....
             '''
             pass
 
     The first string argument is used also in online help.
 
     Optional argument 'requires' should be a collection of resource names
     which the template keyword depends on. This also serves as a flag to
     switch to the new API. If 'requires' is unspecified, all template
     keywords and resources are expanded to the function arguments.
 
     'templatekeyword' instance in example above can be used to
     decorate multiple functions.
 
     Decorated functions are registered automatically at loading
     extension, if an instance named as 'templatekeyword' is used for
     decorating in extension.
 
     Otherwise, explicit 'templatekw.loadkeyword()' is needed.
     """
 
     def _extrasetup(self, name, func, requires=None):
         func._requires = requires
 
 class templatefilter(_templateregistrarbase):
     """Decorator to register template filer
 
     Usage::
 
         templatefilter = registrar.templatefilter()
 
-        @templatefilter('myfilter')
+        @templatefilter('myfilter', intype=bytes)
         def myfilterfunc(text):
             '''Explanation of this template filter ....
             '''
             pass
 
     The first string argument is used also in online help.
 
+    Optional argument 'intype' defines the type of the input argument,
+    which should be (bytes, int, or None for any.)
+
     'templatefilter' instance in example above can be used to
     decorate multiple functions.
 
     Decorated functions are registered automatically at loading
     extension, if an instance named as 'templatefilter' is used for
     decorating in extension.
 
     Otherwise, explicit 'templatefilters.loadkeyword()' is needed.
     """
 
+    def _extrasetup(self, name, func, intype=None):
+        func._intype = intype
+
 class templatefunc(_templateregistrarbase):
     """Decorator to register template function
 
     Usage::
 
         templatefunc = registrar.templatefunc()
 
         @templatefunc('myfunc(arg1, arg2[, arg3])', argspec='arg1 arg2 arg3')
         def myfuncfunc(context, mapping, args):
             '''Explanation of this template function ....
             '''
             pass
 
     The first string argument is used also in online help.
 
     If optional 'argspec' is defined, the function will receive 'args' as
     a dict of named arguments. Otherwise 'args' is a list of positional
     arguments.
 
     'templatefunc' instance in example above can be used to
     decorate multiple functions.
 
     Decorated functions are registered automatically at loading
     extension, if an instance named as 'templatefunc' is used for
     decorating in extension.
 
     Otherwise, explicit 'templatefuncs.loadfunction()' is needed.
     """
     _getname = _funcregistrarbase._parsefuncdecl
 
     def _extrasetup(self, name, func, argspec=None):
         func._argspec = argspec
 
 class internalmerge(_funcregistrarbase):
     """Decorator to register in-process merge tool
 
     Usage::
 
         internalmerge = registrar.internalmerge()
 
         @internalmerge('mymerge', internalmerge.mergeonly,
                        onfailure=None, precheck=None):
         def mymergefunc(repo, mynode, orig, fcd, fco, fca,
                         toolconf, files, labels=None):
             '''Explanation of this internal merge tool ....
             '''
             return 1, False # means "conflicted", "no deletion needed"
 
     The first string argument is used to compose actual merge tool name,
     ":name" and "internal:name" (the latter is historical one).
 
     The second argument is one of merge types below:
 
     ========== ======== ======== =========
     merge type precheck premerge fullmerge
     ========== ======== ======== =========
     nomerge     x        x        x
     mergeonly   o        x        o
     fullmerge   o        o        o
     ========== ======== ======== =========
 
     Optional argument 'onfailure' is the format of warning message
     to be used at failure of merging (target filename is specified
     at formatting). Or, None or so, if warning message should be
     suppressed.
 
     Optional argument 'precheck' is the function to be used
     before actual invocation of internal merge tool itself.
     It takes as same arguments as internal merge tool does, other than
     'files' and 'labels'. If it returns false value, merging is aborted
     immediately (and file is marked as "unresolved").
 
     'internalmerge' instance in example above can be used to
     decorate multiple functions.
 
     Decorated functions are registered automatically at loading
     extension, if an instance named as 'internalmerge' is used for
     decorating in extension.
 
     Otherwise, explicit 'filemerge.loadinternalmerge()' is needed.
     """
     _docformat = "``:%s``\n    %s"
 
     # merge type definitions:
     nomerge = None
     mergeonly = 'mergeonly'  # just the full merge, no premerge
     fullmerge = 'fullmerge'  # both premerge and merge
 
     def _extrasetup(self, name, func, mergetype,
                     onfailure=None, precheck=None):
         func.mergetype = mergetype
         func.onfailure = onfailure
         func.precheck = precheck

mercurial/templatefilters.py

@@ -1,436 +1,436 b''
 # templatefilters.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 os
 import re
 import time
 
 from . import (
     encoding,
     error,
     node,
     pycompat,
     registrar,
     templateutil,
     url,
     util,
 )
 from .utils import (
     dateutil,
     stringutil,
 )
 
 urlerr = util.urlerr
 urlreq = util.urlreq
 
 if pycompat.ispy3:
     long = int
 
 # 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 dateutil.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.
     For example, "foo/bar/baz" becomes "baz" and "foo/bar//" becomes "".
     """
     return os.path.basename(path)
 
 @templatefilter('count')
 def count(i):
     """List or text. Returns the length as an integer."""
     return len(i)
 
 @templatefilter('dirname')
 def dirname(path):
     """Any text. Treats the text as a path, and strips the last
     component of the path after splitting by the path separator.
     """
     return os.path.dirname(path)
 
 @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 stringutil.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 url.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(br'  +')
 
     def findparas():
         start = 0
         while True:
             m = para_re.search(text, start)
             if not m:
                 uctext = encoding.unifromlocal(text[start:])
                 w = len(uctext)
                 while 0 < w and uctext[w - 1].isspace():
                     w -= 1
                 yield (encoding.unitolocal(uctext[:w]),
                        encoding.unitolocal(uctext[w:]))
                 break
             yield text[start:m.start(0)], m.group(1)
             start = m.end(1)
 
     return "".join([stringutil.wrap(space_re.sub(' ',
                                                  stringutil.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 dateutil.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 dateutil.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 pycompat.bytestr(obj)
     elif isinstance(obj, bytes):
         return '"%s"' % encoding.jsonescape(obj, paranoid=paranoid)
     elif isinstance(obj, str):
         # This branch is unreachable on Python 2, because bytes == str
         # and we'll return in the next-earlier block in the elif
         # ladder. On Python 3, this helps us catch bugs before they
         # hurt someone.
         raise error.ProgrammingError(
             'Mercurial only does output with bytes on Python 3: %r' % obj)
     elif util.safehasattr(obj, 'keys'):
         out = ['"%s": %s' % (encoding.jsonescape(k, paranoid=paranoid),
                              json(v, paranoid))
                for k, v in sorted(obj.iteritems())]
         return '{' + ', '.join(out) + '}'
     elif util.safehasattr(obj, '__iter__'):
         out = [json(i, paranoid) 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(text):
     """Any text. Returns '(none)' if the string is empty."""
     return text or "(none)"
 
 @templatefilter('obfuscate')
 def obfuscate(text):
     """Any text. Returns the input text rendered as a sequence of
     XML entities.
     """
     text = unicode(text, pycompat.sysstr(encoding.encoding), r'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.
     """
     return stringutil.person(author)
 
 @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 dateutil.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 dateutil.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(label):
     """Any text. Treats `label` 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.
     """
     if label:
         return label[0:1].upper()
     return ' '
 
 @templatefilter('shortdate')
 def shortdate(text):
     """Date. Returns a date like "2006-09-18"."""
     return dateutil.shortdate(text)
 
 @templatefilter('slashpath')
 def slashpath(path):
     """Any text. Replaces the native path separator with slash."""
     return util.pconvert(path)
 
 @templatefilter('splitlines')
 def splitlines(text):
     """Any text. Split text into a list of lines."""
     return templateutil.hybridlist(text.splitlines(), name='line')
 
 @templatefilter('stringescape')
 def stringescape(text):
     return stringutil.escapestr(text)
 
-@templatefilter('stringify')
+@templatefilter('stringify', intype=bytes)
 def stringify(thing):
     """Any type. Turns the value into text by converting values into
     text and concatenating them.
     """
-    return templateutil.stringify(thing)
+    return thing  # coerced by the intype
 
 @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 stringutil.shortuser(text)
 
 @templatefilter('emailuser')
 def emailuser(text):
     """Any text. Returns the user portion of an email address."""
     return stringutil.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/templateutil.py

@@ -1,477 +1,479 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 types
 
 from .i18n import _
 from . import (
     error,
     pycompat,
     util,
 )
 from .utils import (
     stringutil,
 )
 
 class ResourceUnavailable(error.Abort):
     pass
 
 class TemplateNotFound(error.Abort):
     pass
 
 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)}"
     - "{files|json}"
     """
 
     def __init__(self, gen, values, makemap, joinfmt, keytype=None):
         if gen is not 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 gen(self):
         """Default generator to stringify this as {join(self, ' ')}"""
         for i, x in enumerate(self._values):
             if i > 0:
                 yield ' '
             yield self.joinfmt(x)
     def itermaps(self):
         makemap = self._makemap
         for x in self._values:
             yield makemap(x)
     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(object):
     """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. Use unwrapvalue(), unwrapastype(), or unwraphybrid() to obtain
     the inner object.
     """
 
     def __init__(self, gen, key, value, makemap):
         if gen is not None:
             self.gen = gen  # generator or function returning generator
         self._key = key
         self._value = value  # may be generator of strings
         self._makemap = makemap
 
     def gen(self):
         yield pycompat.bytestr(self._value)
 
     def tomap(self):
         return self._makemap(self._key)
 
     def itermaps(self):
         yield self.tomap()
 
 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(thing):
     """Return an object which can be stringified possibly by using a legacy
     template"""
     gen = getattr(thing, 'gen', None)
     if gen is None:
         return thing
     if callable(gen):
         return gen()
     return gen
 
 def unwrapvalue(thing):
     """Move the inner value object out of the wrapper"""
     if not util.safehasattr(thing, '_value'):
         return thing
     return thing._value
 
 def wraphybridvalue(container, key, value):
     """Wrap an element of hybrid container to be mappable
 
     The key is passed to the makemap function of the given container, which
     should be an item generated by iter(container).
     """
     makemap = getattr(container, '_makemap', None)
     if makemap is None:
         return value
     if util.safehasattr(value, '_makemap'):
         # a nested hybrid list/dict, which has its own way of map operation
         return value
     return mappable(None, key, value, makemap)
 
 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(thing):
     """Yield a single stream from a possibly nested set of iterators"""
     thing = unwraphybrid(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(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(i):
                     yield j
 
 def stringify(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(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 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 evalfuncarg(context, mapping, arg):
     """Evaluate given argument as value type"""
     return _unwrapvalue(evalrawexp(context, mapping, arg))
 
 # TODO: unify this with unwrapvalue() once the bug of templatefunc.join()
 # is fixed. we can't do that right now because join() has to take a generator
 # of byte strings as it is, not a lazy byte string.
 def _unwrapvalue(thing):
     thing = unwrapvalue(thing)
     # evalrawexp() may return string, generator of strings or arbitrary object
     # such as date tuple, but filter does not want generator.
     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 = stringutil.parsebool(data)
     else:
         thing = func(context, mapping, data)
     thing = unwrapvalue(thing)
     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=None):
     return unwrapinteger(evalrawexp(context, mapping, arg), err)
 
 def unwrapinteger(thing, err=None):
     thing = _unwrapvalue(thing)
     try:
         return int(thing)
     except (TypeError, ValueError):
         raise error.ParseError(err or _('not an integer'))
 
 def evalstring(context, mapping, arg):
     return stringify(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(thing)
 
 _unwrapfuncbytype = {
+    None: _unwrapvalue,
     bytes: stringify,
     int: unwrapinteger,
 }
 
 def unwrapastype(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(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 = evalfuncarg(context, mapping, arg)
+    thing = evalrawexp(context, mapping, arg)
     try:
+        thing = unwrapastype(thing, getattr(filt, '_intype', None))
         return filt(thing)
     except (ValueError, AttributeError, TypeError):
         sym = findsymbolicname(arg)
         if sym:
             msg = (_("template filter '%s' is not compatible with keyword '%s'")
                    % (pycompat.sysbytes(filt.__name__), sym))
         else:
             msg = (_("incompatible use of template filter '%s'")
                    % pycompat.sysbytes(filt.__name__))
         raise error.Abort(msg)
 
 def runmap(context, mapping, data):
     darg, targ = data
     d = evalrawexp(context, mapping, darg)
     if util.safehasattr(d, 'itermaps'):
         diter = d.itermaps()
     else:
         try:
             diter = iter(d)
         except TypeError:
             sym = findsymbolicname(darg)
             if sym:
                 raise error.ParseError(_("keyword '%s' is not iterable") % sym)
             else:
                 raise error.ParseError(_("%r is not iterable") % d)
 
     for i, v in enumerate(diter):
         if isinstance(v, dict):
             lm = context.overlaymap(mapping, v)
             lm['index'] = i
             yield evalrawexp(context, lm, targ)
         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 runmember(context, mapping, data):
     darg, memb = data
     d = evalrawexp(context, mapping, darg)
     if util.safehasattr(d, 'tomap'):
         lm = context.overlaymap(mapping, d.tomap())
         return runsymbol(context, lm, memb)
     if util.safehasattr(d, 'get'):
         return getdictitem(d, memb)
 
     sym = findsymbolicname(darg)
     if sym:
         raise error.ParseError(_("keyword '%s' has no member") % sym)
     else:
         raise error.ParseError(_("%r has no member") % pycompat.bytestr(d))
 
 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 getdictitem(dictarg, key):
     val = dictarg.get(key)
     if val is None:
         return
     return wraphybridvalue(dictarg, key, val)