templateutil.py
1092 lines
| 33.1 KiB
| text/x-python
|
PythonLexer
/ mercurial / templateutil.py
|
r36931 | # templateutil.py - utility for template evaluation | ||
# | ||||
# Copyright 2005, 2006 Matt Mackall <mpm@selenic.com> | ||||
# | ||||
# 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 | ||||
|
r37291 | import abc | ||
|
r36931 | import types | ||
from .i18n import _ | ||||
from . import ( | ||||
error, | ||||
pycompat, | ||||
util, | ||||
) | ||||
|
r37102 | from .utils import ( | ||
|
r37241 | dateutil, | ||
|
r37102 | stringutil, | ||
) | ||||
|
r36931 | |||
|
r43346 | |||
|
r36931 | class ResourceUnavailable(error.Abort): | ||
pass | ||||
|
r43346 | |||
|
r36931 | class TemplateNotFound(error.Abort): | ||
pass | ||||
|
r43346 | |||
|
r37291 | class wrapped(object): | ||
"""Object requiring extra conversion prior to displaying or processing | ||||
|
r37297 | as value | ||
|
r38289 | Use unwrapvalue() or unwrapastype() to obtain the inner object. | ||
|
r37297 | """ | ||
|
r37291 | |||
__metaclass__ = abc.ABCMeta | ||||
@abc.abstractmethod | ||||
|
r38286 | def contains(self, context, mapping, item): | ||
"""Test if the specified item is in self | ||||
The item argument may be a wrapped object. | ||||
""" | ||||
@abc.abstractmethod | ||||
|
r38261 | def getmember(self, context, mapping, key): | ||
"""Return a member item for the specified key | ||||
|
r38262 | The key argument may be a wrapped object. | ||
|
r38261 | A returned object may be either a wrapped object or a pure value | ||
depending on the self type. | ||||
""" | ||||
@abc.abstractmethod | ||||
|
r38284 | def getmin(self, context, mapping): | ||
"""Return the smallest item, which may be either a wrapped or a pure | ||||
value depending on the self type""" | ||||
@abc.abstractmethod | ||||
def getmax(self, context, mapping): | ||||
"""Return the largest item, which may be either a wrapped or a pure | ||||
value depending on the self type""" | ||||
@abc.abstractmethod | ||||
|
r38467 | def filter(self, context, mapping, select): | ||
"""Return new container of the same type which includes only the | ||||
selected elements | ||||
select() takes each item as a wrapped object and returns True/False. | ||||
""" | ||||
@abc.abstractmethod | ||||
|
r37340 | def itermaps(self, context): | ||
|
r37339 | """Yield each template mapping""" | ||
@abc.abstractmethod | ||||
|
r37343 | def join(self, context, mapping, sep): | ||
"""Join items with the separator; Returns a bytes or (possibly nested) | ||||
generator of bytes | ||||
A pre-configured template may be rendered per item if this container | ||||
holds unprintable items. | ||||
""" | ||||
@abc.abstractmethod | ||||
|
r37291 | def show(self, context, mapping): | ||
"""Return a bytes or (possibly nested) generator of bytes representing | ||||
the underlying object | ||||
A pre-configured template may be rendered if the underlying object is | ||||
not printable. | ||||
""" | ||||
|
r37297 | @abc.abstractmethod | ||
|
r38308 | def tobool(self, context, mapping): | ||
"""Return a boolean representation of the inner value""" | ||||
@abc.abstractmethod | ||||
|
r37297 | def tovalue(self, context, mapping): | ||
"""Move the inner value object out or create a value representation | ||||
A returned value must be serializable by templaterfilters.json(). | ||||
""" | ||||
|
r43346 | |||
|
r38303 | class mappable(object): | ||
"""Object which can be converted to a single template mapping""" | ||||
def itermaps(self, context): | ||||
yield self.tomap(context) | ||||
@abc.abstractmethod | ||||
def tomap(self, context): | ||||
"""Create a single template mapping representing this""" | ||||
|
r43346 | |||
|
r38228 | class wrappedbytes(wrapped): | ||
"""Wrapper for byte string""" | ||||
def __init__(self, value): | ||||
self._value = value | ||||
|
r38286 | def contains(self, context, mapping, item): | ||
item = stringify(context, mapping, item) | ||||
return item in self._value | ||||
|
r38261 | def getmember(self, context, mapping, key): | ||
|
r43346 | raise error.ParseError( | ||
|
r43347 | _(b'%r is not a dictionary') % pycompat.bytestr(self._value) | ||
|
r43346 | ) | ||
|
r38261 | |||
|
r38284 | def getmin(self, context, mapping): | ||
return self._getby(context, mapping, min) | ||||
def getmax(self, context, mapping): | ||||
return self._getby(context, mapping, max) | ||||
def _getby(self, context, mapping, func): | ||||
if not self._value: | ||||
|
r43347 | raise error.ParseError(_(b'empty string')) | ||
|
r38284 | return func(pycompat.iterbytestr(self._value)) | ||
|
r38467 | def filter(self, context, mapping, select): | ||
|
r43346 | raise error.ParseError( | ||
|
r43347 | _(b'%r is not filterable') % pycompat.bytestr(self._value) | ||
|
r43346 | ) | ||
|
r38467 | |||
|
r38228 | def itermaps(self, context): | ||
|
r43346 | raise error.ParseError( | ||
|
r43347 | _(b'%r is not iterable of mappings') % pycompat.bytestr(self._value) | ||
|
r43346 | ) | ||
|
r38228 | |||
def join(self, context, mapping, sep): | ||||
return joinitems(pycompat.iterbytestr(self._value), sep) | ||||
def show(self, context, mapping): | ||||
return self._value | ||||
|
r38308 | def tobool(self, context, mapping): | ||
return bool(self._value) | ||||
|
r38228 | def tovalue(self, context, mapping): | ||
return self._value | ||||
|
r43346 | |||
|
r38228 | class wrappedvalue(wrapped): | ||
"""Generic wrapper for pure non-list/dict/bytes value""" | ||||
def __init__(self, value): | ||||
self._value = value | ||||
|
r38286 | def contains(self, context, mapping, item): | ||
|
r43347 | raise error.ParseError(_(b"%r is not iterable") % self._value) | ||
|
r38286 | |||
|
r38261 | def getmember(self, context, mapping, key): | ||
|
r43347 | raise error.ParseError(_(b'%r is not a dictionary') % self._value) | ||
|
r38261 | |||
|
r38284 | def getmin(self, context, mapping): | ||
|
r43347 | raise error.ParseError(_(b"%r is not iterable") % self._value) | ||
|
r38284 | |||
def getmax(self, context, mapping): | ||||
|
r43347 | raise error.ParseError(_(b"%r is not iterable") % self._value) | ||
|
r38284 | |||
|
r38467 | def filter(self, context, mapping, select): | ||
|
r43347 | raise error.ParseError(_(b"%r is not iterable") % self._value) | ||
|
r38467 | |||
|
r38228 | def itermaps(self, context): | ||
|
r43346 | raise error.ParseError( | ||
|
r43347 | _(b'%r is not iterable of mappings') % self._value | ||
|
r43346 | ) | ||
|
r38228 | |||
def join(self, context, mapping, sep): | ||||
|
r43347 | raise error.ParseError(_(b'%r is not iterable') % self._value) | ||
|
r38228 | |||
def show(self, context, mapping): | ||||
|
r38291 | if self._value is None: | ||
return b'' | ||||
|
r38228 | return pycompat.bytestr(self._value) | ||
|
r38308 | def tobool(self, context, mapping): | ||
if self._value is None: | ||||
return False | ||||
if isinstance(self._value, bool): | ||||
return self._value | ||||
# otherwise evaluate as string, which means 0 is True | ||||
return bool(pycompat.bytestr(self._value)) | ||||
|
r38228 | def tovalue(self, context, mapping): | ||
return self._value | ||||
|
r43346 | |||
|
r38305 | class date(mappable, wrapped): | ||
|
r38304 | """Wrapper for date tuple""" | ||
|
r43347 | def __init__(self, value, showfmt=b'%d %d'): | ||
|
r38304 | # value may be (float, int), but public interface shouldn't support | ||
# floating-point timestamp | ||||
self._unixtime, self._tzoffset = map(int, value) | ||||
|
r38318 | self._showfmt = showfmt | ||
|
r38304 | |||
def contains(self, context, mapping, item): | ||||
|
r43347 | raise error.ParseError(_(b'date is not iterable')) | ||
|
r38304 | |||
def getmember(self, context, mapping, key): | ||||
|
r43347 | raise error.ParseError(_(b'date is not a dictionary')) | ||
|
r38304 | |||
def getmin(self, context, mapping): | ||||
|
r43347 | raise error.ParseError(_(b'date is not iterable')) | ||
|
r38304 | |||
def getmax(self, context, mapping): | ||||
|
r43347 | raise error.ParseError(_(b'date is not iterable')) | ||
|
r38304 | |||
|
r38467 | def filter(self, context, mapping, select): | ||
|
r43347 | raise error.ParseError(_(b'date is not iterable')) | ||
|
r38467 | |||
|
r38304 | def join(self, context, mapping, sep): | ||
|
r43347 | raise error.ParseError(_(b"date is not iterable")) | ||
|
r38304 | |||
def show(self, context, mapping): | ||||
|
r38318 | return self._showfmt % (self._unixtime, self._tzoffset) | ||
|
r38304 | |||
|
r38305 | def tomap(self, context): | ||
|
r43347 | return {b'unixtime': self._unixtime, b'tzoffset': self._tzoffset} | ||
|
r38305 | |||
|
r38308 | def tobool(self, context, mapping): | ||
return True | ||||
|
r38304 | def tovalue(self, context, mapping): | ||
return (self._unixtime, self._tzoffset) | ||||
|
r37244 | |||
|
r43346 | |||
|
r37291 | class hybrid(wrapped): | ||
|
r36939 | """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): | ||||
|
r37341 | self._gen = gen # generator or function returning generator | ||
|
r36939 | self._values = values | ||
self._makemap = makemap | ||||
|
r37345 | self._joinfmt = joinfmt | ||
|
r38287 | self._keytype = keytype # hint for 'x in y' where type(x) is unresolved | ||
|
r37293 | |||
|
r38286 | def contains(self, context, mapping, item): | ||
|
r38287 | item = unwrapastype(context, mapping, item, self._keytype) | ||
|
r38286 | return item in self._values | ||
|
r38260 | def getmember(self, context, mapping, key): | ||
# TODO: maybe split hybrid list/dict types? | ||||
|
r43347 | if not util.safehasattr(self._values, b'get'): | ||
raise error.ParseError(_(b'not a dictionary')) | ||||
|
r38287 | key = unwrapastype(context, mapping, key, self._keytype) | ||
|
r38260 | return self._wrapvalue(key, self._values.get(key)) | ||
|
r38284 | def getmin(self, context, mapping): | ||
return self._getby(context, mapping, min) | ||||
def getmax(self, context, mapping): | ||||
return self._getby(context, mapping, max) | ||||
def _getby(self, context, mapping, func): | ||||
if not self._values: | ||||
|
r43347 | raise error.ParseError(_(b'empty sequence')) | ||
|
r38284 | val = func(self._values) | ||
return self._wrapvalue(val, val) | ||||
|
r38260 | def _wrapvalue(self, key, val): | ||
if val is None: | ||||
return | ||||
|
r43347 | if util.safehasattr(val, b'_makemap'): | ||
|
r38285 | # a nested hybrid list/dict, which has its own way of map operation | ||
return val | ||||
|
r38302 | return hybriditem(None, key, val, self._makemap) | ||
|
r38260 | |||
|
r38467 | def filter(self, context, mapping, select): | ||
|
r43347 | if util.safehasattr(self._values, b'get'): | ||
|
r43346 | values = { | ||
k: v | ||||
for k, v in self._values.iteritems() | ||||
if select(self._wrapvalue(k, v)) | ||||
} | ||||
|
r38467 | else: | ||
values = [v for v in self._values if select(self._wrapvalue(v, v))] | ||||
return hybrid(None, values, self._makemap, self._joinfmt, self._keytype) | ||||
|
r37340 | def itermaps(self, context): | ||
|
r36939 | makemap = self._makemap | ||
for x in self._values: | ||||
yield makemap(x) | ||||
|
r37291 | |||
|
r37343 | def join(self, context, mapping, sep): | ||
# TODO: switch gen to (context, mapping) API? | ||||
|
r37345 | return joinitems((self._joinfmt(x) for x in self._values), sep) | ||
|
r37343 | |||
|
r37291 | def show(self, context, mapping): | ||
# TODO: switch gen to (context, mapping) API? | ||||
|
r37293 | gen = self._gen | ||
|
r37341 | if gen is None: | ||
|
r43347 | return self.join(context, mapping, b' ') | ||
|
r37291 | if callable(gen): | ||
return gen() | ||||
return gen | ||||
|
r38308 | def tobool(self, context, mapping): | ||
return bool(self._values) | ||||
|
r37297 | def tovalue(self, context, mapping): | ||
|
r38288 | # TODO: make it non-recursive for trivial lists/dicts | ||
xs = self._values | ||||
|
r43347 | if util.safehasattr(xs, b'get'): | ||
|
r43346 | return { | ||
k: unwrapvalue(context, mapping, v) for k, v in xs.iteritems() | ||||
} | ||||
|
r38288 | return [unwrapvalue(context, mapping, x) for x in xs] | ||
|
r36939 | |||
|
r43346 | |||
|
r38303 | class hybriditem(mappable, wrapped): | ||
|
r36939 | """Wrapper for non-list/dict object to support map operation | ||
This class allows us to handle both: | ||||
- "{manifest}" | ||||
- "{manifest % '{rev}:{node}'}" | ||||
- "{manifest.rev}" | ||||
""" | ||||
def __init__(self, gen, key, value, makemap): | ||||
|
r37294 | self._gen = gen # generator or function returning generator | ||
|
r36939 | self._key = key | ||
self._value = value # may be generator of strings | ||||
self._makemap = makemap | ||||
|
r38303 | def tomap(self, context): | ||
|
r36939 | return self._makemap(self._key) | ||
|
r38286 | def contains(self, context, mapping, item): | ||
w = makewrapped(context, mapping, self._value) | ||||
return w.contains(context, mapping, item) | ||||
|
r38261 | def getmember(self, context, mapping, key): | ||
w = makewrapped(context, mapping, self._value) | ||||
return w.getmember(context, mapping, key) | ||||
|
r38284 | def getmin(self, context, mapping): | ||
w = makewrapped(context, mapping, self._value) | ||||
return w.getmin(context, mapping) | ||||
def getmax(self, context, mapping): | ||||
w = makewrapped(context, mapping, self._value) | ||||
return w.getmax(context, mapping) | ||||
|
r38467 | def filter(self, context, mapping, select): | ||
w = makewrapped(context, mapping, self._value) | ||||
return w.filter(context, mapping, select) | ||||
|
r37343 | def join(self, context, mapping, sep): | ||
|
r38230 | w = makewrapped(context, mapping, self._value) | ||
return w.join(context, mapping, sep) | ||||
|
r37343 | |||
|
r37291 | def show(self, context, mapping): | ||
# TODO: switch gen to (context, mapping) API? | ||||
|
r37293 | gen = self._gen | ||
|
r37294 | if gen is None: | ||
return pycompat.bytestr(self._value) | ||||
|
r37291 | if callable(gen): | ||
return gen() | ||||
return gen | ||||
|
r38308 | def tobool(self, context, mapping): | ||
|
r38466 | w = makewrapped(context, mapping, self._value) | ||
return w.tobool(context, mapping) | ||||
|
r38308 | |||
|
r37297 | def tovalue(self, context, mapping): | ||
return _unthunk(context, mapping, self._value) | ||||
|
r43346 | |||
|
r37417 | class _mappingsequence(wrapped): | ||
"""Wrapper for sequence of template mappings | ||||
This represents an inner template structure (i.e. a list of dicts), | ||||
which can also be rendered by the specified named/literal template. | ||||
Template mappings may be nested. | ||||
""" | ||||
|
r43347 | def __init__(self, name=None, tmpl=None, sep=b''): | ||
|
r37417 | if name is not None and tmpl is not None: | ||
|
r43347 | raise error.ProgrammingError( | ||
b'name and tmpl are mutually exclusive' | ||||
) | ||||
|
r37417 | self._name = name | ||
self._tmpl = tmpl | ||||
self._defaultsep = sep | ||||
|
r38286 | def contains(self, context, mapping, item): | ||
|
r43347 | raise error.ParseError(_(b'not comparable')) | ||
|
r38286 | |||
|
r38261 | def getmember(self, context, mapping, key): | ||
|
r43347 | raise error.ParseError(_(b'not a dictionary')) | ||
|
r38261 | |||
|
r38284 | def getmin(self, context, mapping): | ||
|
r43347 | raise error.ParseError(_(b'not comparable')) | ||
|
r38284 | |||
def getmax(self, context, mapping): | ||||
|
r43347 | raise error.ParseError(_(b'not comparable')) | ||
|
r38284 | |||
|
r38467 | def filter(self, context, mapping, select): | ||
|
r38468 | # implement if necessary; we'll need a wrapped type for a mapping dict | ||
|
r43347 | raise error.ParseError(_(b'not filterable without template')) | ||
|
r38467 | |||
|
r37417 | def join(self, context, mapping, sep): | ||
mapsiter = _iteroverlaymaps(context, mapping, self.itermaps(context)) | ||||
if self._name: | ||||
itemiter = (context.process(self._name, m) for m in mapsiter) | ||||
elif self._tmpl: | ||||
itemiter = (context.expand(self._tmpl, m) for m in mapsiter) | ||||
else: | ||||
|
r43347 | raise error.ParseError(_(b'not displayable without template')) | ||
|
r37417 | return joinitems(itemiter, sep) | ||
def show(self, context, mapping): | ||||
return self.join(context, mapping, self._defaultsep) | ||||
def tovalue(self, context, mapping): | ||||
|
r37520 | knownres = context.knownresourcekeys() | ||
items = [] | ||||
for nm in self.itermaps(context): | ||||
# drop internal resources (recursively) which shouldn't be displayed | ||||
lm = context.overlaymap(mapping, nm) | ||||
|
r43346 | items.append( | ||
{ | ||||
k: unwrapvalue(context, lm, v) | ||||
for k, v in nm.iteritems() | ||||
if k not in knownres | ||||
} | ||||
) | ||||
|
r37520 | return items | ||
|
r37417 | |||
|
r43346 | |||
|
r37417 | class mappinggenerator(_mappingsequence): | ||
"""Wrapper for generator of template mappings | ||||
The function ``make(context, *args)`` should return a generator of | ||||
mapping dicts. | ||||
""" | ||||
|
r43347 | def __init__(self, make, args=(), name=None, tmpl=None, sep=b''): | ||
|
r37417 | super(mappinggenerator, self).__init__(name, tmpl, sep) | ||
self._make = make | ||||
self._args = args | ||||
def itermaps(self, context): | ||||
return self._make(context, *self._args) | ||||
|
r38308 | def tobool(self, context, mapping): | ||
return _nonempty(self.itermaps(context)) | ||||
|
r43346 | |||
|
r37417 | class mappinglist(_mappingsequence): | ||
"""Wrapper for list of template mappings""" | ||||
|
r43347 | def __init__(self, mappings, name=None, tmpl=None, sep=b''): | ||
|
r37417 | super(mappinglist, self).__init__(name, tmpl, sep) | ||
self._mappings = mappings | ||||
def itermaps(self, context): | ||||
return iter(self._mappings) | ||||
|
r38308 | def tobool(self, context, mapping): | ||
return bool(self._mappings) | ||||
|
r43346 | |||
|
r40509 | class mappingdict(mappable, _mappingsequence): | ||
"""Wrapper for a single template mapping | ||||
This isn't a sequence in a way that the underlying dict won't be iterated | ||||
as a dict, but shares most of the _mappingsequence functions. | ||||
""" | ||||
def __init__(self, mapping, name=None, tmpl=None): | ||||
super(mappingdict, self).__init__(name, tmpl) | ||||
self._mapping = mapping | ||||
def tomap(self, context): | ||||
return self._mapping | ||||
def tobool(self, context, mapping): | ||||
# no idea when a template mapping should be considered an empty, but | ||||
# a mapping dict should have at least one item in practice, so always | ||||
# mark this as non-empty. | ||||
return True | ||||
def tovalue(self, context, mapping): | ||||
return super(mappingdict, self).tovalue(context, mapping)[0] | ||||
|
r43346 | |||
|
r40971 | class mappingnone(wrappedvalue): | ||
"""Wrapper for None, but supports map operation | ||||
This represents None of Optional[mappable]. It's similar to | ||||
mapplinglist([]), but the underlying value is not [], but None. | ||||
""" | ||||
def __init__(self): | ||||
super(mappingnone, self).__init__(None) | ||||
def itermaps(self, context): | ||||
return iter([]) | ||||
|
r43346 | |||
|
r37517 | class mappedgenerator(wrapped): | ||
"""Wrapper for generator of strings which acts as a list | ||||
The function ``make(context, *args)`` should return a generator of | ||||
byte strings, or a generator of (possibly nested) generators of byte | ||||
strings (i.e. a generator for a list of byte strings.) | ||||
""" | ||||
def __init__(self, make, args=()): | ||||
self._make = make | ||||
self._args = args | ||||
|
r38286 | def contains(self, context, mapping, item): | ||
item = stringify(context, mapping, item) | ||||
return item in self.tovalue(context, mapping) | ||||
|
r37517 | def _gen(self, context): | ||
return self._make(context, *self._args) | ||||
|
r38261 | def getmember(self, context, mapping, key): | ||
|
r43347 | raise error.ParseError(_(b'not a dictionary')) | ||
|
r38261 | |||
|
r38284 | def getmin(self, context, mapping): | ||
return self._getby(context, mapping, min) | ||||
def getmax(self, context, mapping): | ||||
return self._getby(context, mapping, max) | ||||
def _getby(self, context, mapping, func): | ||||
xs = self.tovalue(context, mapping) | ||||
if not xs: | ||||
|
r43347 | raise error.ParseError(_(b'empty sequence')) | ||
|
r38284 | return func(xs) | ||
|
r38467 | @staticmethod | ||
def _filteredgen(context, mapping, make, args, select): | ||||
for x in make(context, *args): | ||||
s = stringify(context, mapping, x) | ||||
if select(wrappedbytes(s)): | ||||
yield s | ||||
def filter(self, context, mapping, select): | ||||
args = (mapping, self._make, self._args, select) | ||||
return mappedgenerator(self._filteredgen, args) | ||||
|
r37517 | def itermaps(self, context): | ||
|
r43347 | raise error.ParseError(_(b'list of strings is not mappable')) | ||
|
r37517 | |||
def join(self, context, mapping, sep): | ||||
return joinitems(self._gen(context), sep) | ||||
def show(self, context, mapping): | ||||
|
r43347 | return self.join(context, mapping, b'') | ||
|
r37517 | |||
|
r38308 | def tobool(self, context, mapping): | ||
return _nonempty(self._gen(context)) | ||||
|
r37517 | def tovalue(self, context, mapping): | ||
return [stringify(context, mapping, x) for x in self._gen(context)] | ||||
|
r43346 | |||
|
r43347 | def hybriddict(data, key=b'key', value=b'value', fmt=None, gen=None): | ||
|
r36939 | """Wrap data to support both dict-like and string-like operations""" | ||
prefmt = pycompat.identity | ||||
if fmt is None: | ||||
|
r43347 | fmt = b'%s=%s' | ||
|
r36939 | prefmt = pycompat.bytestr | ||
|
r43346 | return hybrid( | ||
gen, | ||||
data, | ||||
lambda k: {key: k, value: data[k]}, | ||||
lambda k: fmt % (prefmt(k), prefmt(data[k])), | ||||
) | ||||
|
r36939 | |||
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: | ||||
|
r43347 | fmt = b'%s' | ||
|
r36939 | prefmt = pycompat.bytestr | ||
return hybrid(gen, data, lambda x: {name: x}, lambda x: fmt % prefmt(x)) | ||||
|
r43346 | |||
def compatdict( | ||||
context, | ||||
mapping, | ||||
name, | ||||
data, | ||||
|
r43347 | key=b'key', | ||
value=b'value', | ||||
|
r43346 | fmt=None, | ||
plural=None, | ||||
|
r43347 | separator=b' ', | ||
|
r43346 | ): | ||
|
r36939 | """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()] | ||||
|
r37086 | f = _showcompatlist(context, mapping, name, c, plural, separator) | ||
|
r36939 | return hybriddict(data, key=key, value=value, fmt=fmt, gen=f) | ||
|
r43346 | |||
def compatlist( | ||||
context, | ||||
mapping, | ||||
name, | ||||
data, | ||||
element=None, | ||||
fmt=None, | ||||
plural=None, | ||||
|
r43347 | separator=b' ', | ||
|
r43346 | ): | ||
|
r36939 | """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. | ||||
""" | ||||
|
r37086 | f = _showcompatlist(context, mapping, name, data, plural, separator) | ||
|
r36939 | return hybridlist(data, name=element or name, fmt=fmt, gen=f) | ||
|
r43346 | |||
|
r39404 | def compatfilecopiesdict(context, mapping, name, copies): | ||
"""Wrap list of (dest, source) file names to support old-style list | ||||
template and field names | ||||
This exists for backward compatibility. Use hybriddict for new template | ||||
keywords. | ||||
""" | ||||
# no need to provide {path} to old-style list template | ||||
|
r43347 | c = [{b'name': k, b'source': v} for k, v in copies] | ||
f = _showcompatlist(context, mapping, name, c, plural=b'file_copies') | ||||
|
r39404 | copies = util.sortdict(copies) | ||
|
r43346 | return hybrid( | ||
f, | ||||
copies, | ||||
|
r43347 | lambda k: {b'name': k, b'path': k, b'source': copies[k]}, | ||
lambda k: b'%s (%s)' % (k, copies[k]), | ||||
|
r43346 | ) | ||
|
r39404 | |||
|
r39403 | def compatfileslist(context, mapping, name, files): | ||
"""Wrap list of file names to support old-style list template and field | ||||
names | ||||
This exists for backward compatibility. Use hybridlist for new template | ||||
keywords. | ||||
""" | ||||
f = _showcompatlist(context, mapping, name, files) | ||||
|
r43347 | return hybrid( | ||
f, files, lambda x: {b'file': x, b'path': x}, pycompat.identity | ||||
) | ||||
|
r43346 | |||
|
r39403 | |||
|
r43347 | def _showcompatlist( | ||
context, mapping, name, values, plural=None, separator=b' ' | ||||
): | ||||
|
r37086 | """Return a generator that renders old-style list template | ||
|
r36939 | 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'. | ||||
|
r37086 | """ | ||
|
r36939 | if not plural: | ||
|
r43347 | plural = name + b's' | ||
|
r36939 | if not values: | ||
|
r43347 | noname = b'no_' + plural | ||
|
r37086 | if context.preload(noname): | ||
yield context.process(noname, mapping) | ||||
|
r36939 | return | ||
|
r37086 | if not context.preload(name): | ||
|
r36939 | if isinstance(values[0], bytes): | ||
yield separator.join(values) | ||||
else: | ||||
for v in values: | ||||
r = dict(v) | ||||
r.update(mapping) | ||||
yield r | ||||
return | ||||
|
r43347 | startname = b'start_' + plural | ||
|
r37086 | if context.preload(startname): | ||
yield context.process(startname, mapping) | ||||
|
r43346 | |||
|
r36939 | def one(v, tag=name): | ||
|
r37092 | vmapping = {} | ||
|
r36939 | 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 | ||||
|
r37092 | vmapping = context.overlaymap(mapping, vmapping) | ||
|
r37086 | return context.process(tag, vmapping) | ||
|
r43346 | |||
|
r43347 | lastname = b'last_' + name | ||
|
r37086 | if context.preload(lastname): | ||
|
r36939 | last = values.pop() | ||
else: | ||||
last = None | ||||
for v in values: | ||||
yield one(v) | ||||
if last is not None: | ||||
yield one(last, tag=lastname) | ||||
|
r43347 | endname = b'end_' + plural | ||
|
r37086 | if context.preload(endname): | ||
yield context.process(endname, mapping) | ||||
|
r36939 | |||
|
r43346 | |||
|
r37290 | def flatten(context, mapping, thing): | ||
|
r37174 | """Yield a single stream from a possibly nested set of iterators""" | ||
|
r38289 | if isinstance(thing, wrapped): | ||
thing = thing.show(context, mapping) | ||||
|
r37174 | 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. | ||||
|
r43346 | raise error.ProgrammingError( | ||
|
r43347 | b'Mercurial IO including templates is done' | ||
b' with bytes, not strings, got %r' % thing | ||||
|
r43346 | ) | ||
|
r37174 | elif thing is None: | ||
pass | ||||
|
r43347 | elif not util.safehasattr(thing, b'__iter__'): | ||
|
r37174 | yield pycompat.bytestr(thing) | ||
else: | ||||
for i in thing: | ||||
|
r38289 | if isinstance(i, wrapped): | ||
i = i.show(context, mapping) | ||||
|
r37174 | if isinstance(i, bytes): | ||
yield i | ||||
elif i is None: | ||||
pass | ||||
|
r43347 | elif not util.safehasattr(i, b'__iter__'): | ||
|
r37174 | yield pycompat.bytestr(i) | ||
else: | ||||
|
r37290 | for j in flatten(context, mapping, i): | ||
|
r37174 | yield j | ||
|
r43346 | |||
|
r37290 | def stringify(context, mapping, thing): | ||
|
r36938 | """Turn values into bytes by converting into text and concatenating them""" | ||
|
r37175 | if isinstance(thing, bytes): | ||
return thing # retain localstr to be round-tripped | ||||
|
r37290 | return b''.join(flatten(context, mapping, thing)) | ||
|
r36938 | |||
|
r43346 | |||
|
r36931 | 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 | ||||
|
r43346 | |||
|
r38308 | def _nonempty(xiter): | ||
try: | ||||
next(xiter) | ||||
return True | ||||
except StopIteration: | ||||
return False | ||||
|
r43346 | |||
|
r37296 | def _unthunk(context, mapping, thing): | ||
"""Evaluate a lazy byte string into value""" | ||||
if not isinstance(thing, types.GeneratorType): | ||||
return thing | ||||
return stringify(context, mapping, thing) | ||||
|
r43346 | |||
|
r36931 | 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) | ||||
|
r43346 | |||
|
r38228 | def evalwrapped(context, mapping, arg): | ||
"""Evaluate given argument to wrapped object""" | ||||
thing = evalrawexp(context, mapping, arg) | ||||
return makewrapped(context, mapping, thing) | ||||
|
r43346 | |||
|
r38228 | def makewrapped(context, mapping, thing): | ||
"""Lift object to a wrapped type""" | ||||
if isinstance(thing, wrapped): | ||||
return thing | ||||
thing = _unthunk(context, mapping, thing) | ||||
if isinstance(thing, bytes): | ||||
return wrappedbytes(thing) | ||||
return wrappedvalue(thing) | ||||
|
r43346 | |||
|
r36931 | def evalfuncarg(context, mapping, arg): | ||
"""Evaluate given argument as value type""" | ||||
|
r38227 | return unwrapvalue(context, mapping, evalrawexp(context, mapping, arg)) | ||
|
r37178 | |||
|
r43346 | |||
|
r38227 | def unwrapvalue(context, mapping, thing): | ||
"""Move the inner value object out of the wrapper""" | ||||
|
r38226 | if isinstance(thing, wrapped): | ||
return thing.tovalue(context, mapping) | ||||
|
r36931 | # evalrawexp() may return string, generator of strings or arbitrary object | ||
# such as date tuple, but filter does not want generator. | ||||
|
r37296 | return _unthunk(context, mapping, thing) | ||
|
r36931 | |||
|
r43346 | |||
|
r36931 | 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 | ||||
|
r37102 | thing = stringutil.parsebool(data) | ||
|
r36931 | else: | ||
thing = func(context, mapping, data) | ||||
|
r38308 | return makewrapped(context, mapping, thing).tobool(context, mapping) | ||
|
r36931 | |||
|
r43346 | |||
|
r37241 | def evaldate(context, mapping, arg, err=None): | ||
"""Evaluate given argument as a date tuple or a date string; returns | ||||
a (unixtime, offset) tuple""" | ||||
|
r37290 | thing = evalrawexp(context, mapping, arg) | ||
return unwrapdate(context, mapping, thing, err) | ||||
|
r37241 | |||
|
r43346 | |||
|
r37290 | def unwrapdate(context, mapping, thing, err=None): | ||
|
r38304 | if isinstance(thing, date): | ||
return thing.tovalue(context, mapping) | ||||
# TODO: update hgweb to not return bare tuple; then just stringify 'thing' | ||||
|
r38227 | thing = unwrapvalue(context, mapping, thing) | ||
|
r37241 | try: | ||
return dateutil.parsedate(thing) | ||||
except AttributeError: | ||||
|
r43347 | raise error.ParseError(err or _(b'not a date tuple nor a string')) | ||
|
r37242 | except error.ParseError: | ||
if not err: | ||||
raise | ||||
raise error.ParseError(err) | ||||
|
r37241 | |||
|
r43346 | |||
|
r36931 | def evalinteger(context, mapping, arg, err=None): | ||
|
r37290 | thing = evalrawexp(context, mapping, arg) | ||
return unwrapinteger(context, mapping, thing, err) | ||||
|
r37179 | |||
|
r43346 | |||
|
r37290 | def unwrapinteger(context, mapping, thing, err=None): | ||
|
r38227 | thing = unwrapvalue(context, mapping, thing) | ||
|
r36931 | try: | ||
|
r37179 | return int(thing) | ||
|
r36931 | except (TypeError, ValueError): | ||
|
r43347 | raise error.ParseError(err or _(b'not an integer')) | ||
|
r36931 | |||
|
r43346 | |||
|
r36931 | def evalstring(context, mapping, arg): | ||
|
r37290 | return stringify(context, mapping, evalrawexp(context, mapping, arg)) | ||
|
r36931 | |||
|
r43346 | |||
|
r36931 | 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) | ||||
|
r37290 | return stringify(context, mapping, thing) | ||
|
r36931 | |||
|
r43346 | |||
|
r37180 | _unwrapfuncbytype = { | ||
|
r38227 | None: unwrapvalue, | ||
|
r37180 | bytes: stringify, | ||
|
r37244 | date: unwrapdate, | ||
|
r37180 | int: unwrapinteger, | ||
|
r36931 | } | ||
|
r43346 | |||
|
r37290 | def unwrapastype(context, mapping, thing, typ): | ||
|
r37180 | """Move the inner value object out of the wrapper and coerce its type""" | ||
|
r36931 | try: | ||
|
r37180 | f = _unwrapfuncbytype[typ] | ||
|
r36931 | except KeyError: | ||
|
r43347 | raise error.ProgrammingError(b'invalid type specified: %r' % typ) | ||
|
r37290 | return f(context, mapping, thing) | ||
|
r36931 | |||
|
r43346 | |||
|
r36931 | def runinteger(context, mapping, data): | ||
return int(data) | ||||
|
r43346 | |||
|
r36931 | def runstring(context, mapping, data): | ||
return data | ||||
|
r43346 | |||
|
r36931 | def _recursivesymbolblocker(key): | ||
|
r38966 | def showrecursion(context, mapping): | ||
|
r43347 | raise error.Abort(_(b"recursive reference '%s' in template") % key) | ||
|
r43346 | |||
|
r36931 | return showrecursion | ||
|
r43346 | |||
|
r43347 | def runsymbol(context, mapping, key, default=b''): | ||
|
r36931 | 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): | ||||
# new templatekw | ||||
try: | ||||
return v(context, mapping) | ||||
except ResourceUnavailable: | ||||
# unsupported keyword is mapped to empty just like unknown keyword | ||||
return None | ||||
return v | ||||
|
r43346 | |||
|
r36931 | def runtemplate(context, mapping, template): | ||
for arg in template: | ||||
yield evalrawexp(context, mapping, arg) | ||||
|
r43346 | |||
|
r36931 | def runfilter(context, mapping, data): | ||
arg, filt = data | ||||
|
r37239 | thing = evalrawexp(context, mapping, arg) | ||
|
r37290 | intype = getattr(filt, '_intype', None) | ||
|
r36931 | try: | ||
|
r37290 | thing = unwrapastype(context, mapping, thing, intype) | ||
|
r36931 | return filt(thing) | ||
|
r37243 | except error.ParseError as e: | ||
raise error.ParseError(bytes(e), hint=_formatfiltererror(arg, filt)) | ||||
|
r43346 | |||
|
r37243 | def _formatfiltererror(arg, filt): | ||
fn = pycompat.sysbytes(filt.__name__) | ||||
sym = findsymbolicname(arg) | ||||
if not sym: | ||||
|
r43347 | return _(b"incompatible use of template filter '%s'") % fn | ||
return _(b"template filter '%s' is not compatible with keyword '%s'") % ( | ||||
|
r43346 | fn, | ||
sym, | ||||
) | ||||
|
r36931 | |||
|
r37417 | def _iteroverlaymaps(context, origmapping, newmappings): | ||
"""Generate combined mappings from the original mapping and an iterable | ||||
of partial mappings to override the original""" | ||||
for i, nm in enumerate(newmappings): | ||||
lm = context.overlaymap(origmapping, nm) | ||||
|
r43347 | lm[b'index'] = i | ||
|
r37417 | yield lm | ||
|
r43346 | |||
|
r38290 | def _applymap(context, mapping, d, darg, targ): | ||
try: | ||||
diter = d.itermaps(context) | ||||
except error.ParseError as err: | ||||
sym = findsymbolicname(darg) | ||||
if not sym: | ||||
raise | ||||
|
r43347 | hint = _(b"keyword '%s' does not support map operation") % sym | ||
|
r38290 | raise error.ParseError(bytes(err), hint=hint) | ||
for lm in _iteroverlaymaps(context, mapping, diter): | ||||
|
r37517 | yield evalrawexp(context, lm, targ) | ||
|
r43346 | |||
|
r36931 | def runmap(context, mapping, data): | ||
darg, targ = data | ||||
|
r38231 | d = evalwrapped(context, mapping, darg) | ||
|
r38290 | return mappedgenerator(_applymap, args=(mapping, d, darg, targ)) | ||
|
r36931 | |||
|
r43346 | |||
|
r36931 | def runmember(context, mapping, data): | ||
darg, memb = data | ||||
|
r38258 | d = evalwrapped(context, mapping, darg) | ||
|
r38303 | if isinstance(d, mappable): | ||
lm = context.overlaymap(mapping, d.tomap(context)) | ||||
|
r36931 | return runsymbol(context, lm, memb) | ||
|
r38259 | try: | ||
|
r38261 | return d.getmember(context, mapping, memb) | ||
except error.ParseError as err: | ||||
|
r38259 | sym = findsymbolicname(darg) | ||
|
r38261 | if not sym: | ||
raise | ||||
|
r43347 | hint = _(b"keyword '%s' does not support member operation") % sym | ||
|
r38261 | raise error.ParseError(bytes(err), hint=hint) | ||
|
r36931 | |||
|
r43346 | |||
|
r36931 | def runnegate(context, mapping, data): | ||
|
r43346 | data = evalinteger( | ||
|
r43347 | context, mapping, data, _(b'negation needs an integer argument') | ||
|
r43346 | ) | ||
|
r36931 | return -data | ||
|
r43346 | |||
|
r36931 | def runarithmetic(context, mapping, data): | ||
func, left, right = data | ||||
|
r43346 | left = evalinteger( | ||
|
r43347 | context, mapping, left, _(b'arithmetic only defined on integers') | ||
|
r43346 | ) | ||
right = evalinteger( | ||||
|
r43347 | context, mapping, right, _(b'arithmetic only defined on integers') | ||
|
r43346 | ) | ||
|
r36931 | try: | ||
return func(left, right) | ||||
except ZeroDivisionError: | ||||
|
r43347 | raise error.Abort(_(b'division by zero is not defined')) | ||
|
r36931 | |||
|
r43346 | |||
|
r37341 | def joinitems(itemiter, sep): | ||
"""Join items with the separator; Returns generator of bytes""" | ||||
first = True | ||||
for x in itemiter: | ||||
if first: | ||||
first = False | ||||
|
r37342 | elif sep: | ||
|
r37341 | yield sep | ||
yield x | ||||