templateutil.py
805 lines
| 26.8 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 | |||
class ResourceUnavailable(error.Abort): | ||||
pass | ||||
class TemplateNotFound(error.Abort): | ||||
pass | ||||
|
r37291 | class wrapped(object): | ||
"""Object requiring extra conversion prior to displaying or processing | ||||
|
r37297 | as value | ||
Use unwrapvalue(), unwrapastype(), or unwraphybrid() to obtain the inner | ||||
object. | ||||
""" | ||||
|
r37291 | |||
__metaclass__ = abc.ABCMeta | ||||
@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 | ||||
|
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 | ||
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(). | ||||
""" | ||||
|
r38228 | class wrappedbytes(wrapped): | ||
"""Wrapper for byte string""" | ||||
def __init__(self, value): | ||||
self._value = value | ||||
|
r38261 | def getmember(self, context, mapping, key): | ||
raise error.ParseError(_('%r is not a dictionary') | ||||
% pycompat.bytestr(self._value)) | ||||
|
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: | ||||
raise error.ParseError(_('empty string')) | ||||
return func(pycompat.iterbytestr(self._value)) | ||||
|
r38228 | def itermaps(self, context): | ||
raise error.ParseError(_('%r is not iterable of mappings') | ||||
% pycompat.bytestr(self._value)) | ||||
def join(self, context, mapping, sep): | ||||
return joinitems(pycompat.iterbytestr(self._value), sep) | ||||
def show(self, context, mapping): | ||||
return self._value | ||||
def tovalue(self, context, mapping): | ||||
return self._value | ||||
class wrappedvalue(wrapped): | ||||
"""Generic wrapper for pure non-list/dict/bytes value""" | ||||
def __init__(self, value): | ||||
self._value = value | ||||
|
r38261 | def getmember(self, context, mapping, key): | ||
raise error.ParseError(_('%r is not a dictionary') % self._value) | ||||
|
r38284 | def getmin(self, context, mapping): | ||
raise error.ParseError(_("%r is not iterable") % self._value) | ||||
def getmax(self, context, mapping): | ||||
raise error.ParseError(_("%r is not iterable") % self._value) | ||||
|
r38228 | def itermaps(self, context): | ||
raise error.ParseError(_('%r is not iterable of mappings') | ||||
% self._value) | ||||
def join(self, context, mapping, sep): | ||||
raise error.ParseError(_('%r is not iterable') % self._value) | ||||
def show(self, context, mapping): | ||||
return pycompat.bytestr(self._value) | ||||
def tovalue(self, context, mapping): | ||||
return self._value | ||||
|
r37244 | # stub for representing a date type; may be a real date type that can | ||
# provide a readable string value | ||||
class date(object): | ||||
pass | ||||
|
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 | ||
|
r36939 | self.keytype = keytype # hint for 'x in y' where type(x) is unresolved | ||
|
r37293 | |||
|
r38260 | def getmember(self, context, mapping, key): | ||
# TODO: maybe split hybrid list/dict types? | ||||
if not util.safehasattr(self._values, 'get'): | ||||
raise error.ParseError(_('not a dictionary')) | ||||
|
r38262 | 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: | ||||
raise error.ParseError(_('empty sequence')) | ||||
val = func(self._values) | ||||
return self._wrapvalue(val, val) | ||||
|
r38260 | def _wrapvalue(self, key, val): | ||
if val is None: | ||||
return | ||||
return wraphybridvalue(self, key, val) | ||||
|
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: | ||
|
r37343 | return self.join(context, mapping, ' ') | ||
|
r37291 | if callable(gen): | ||
return gen() | ||||
return gen | ||||
|
r37297 | def tovalue(self, context, mapping): | ||
# TODO: return self._values and get rid of proxy methods | ||||
return self | ||||
|
r36939 | 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) | ||||
|
r37291 | class 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}" | ||||
Unlike a hybrid, this does not simulate the behavior of the underling | ||||
|
r37297 | value. | ||
|
r36939 | """ | ||
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 | ||||
def tomap(self): | ||||
return self._makemap(self._key) | ||||
|
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) | ||||
|
r37340 | def itermaps(self, context): | ||
|
r36939 | yield self.tomap() | ||
|
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 | ||||
|
r37297 | def tovalue(self, context, mapping): | ||
return _unthunk(context, mapping, self._value) | ||||
|
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. | ||||
""" | ||||
def __init__(self, name=None, tmpl=None, sep=''): | ||||
if name is not None and tmpl is not None: | ||||
raise error.ProgrammingError('name and tmpl are mutually exclusive') | ||||
self._name = name | ||||
self._tmpl = tmpl | ||||
self._defaultsep = sep | ||||
|
r38261 | def getmember(self, context, mapping, key): | ||
raise error.ParseError(_('not a dictionary')) | ||||
|
r38284 | def getmin(self, context, mapping): | ||
raise error.ParseError(_('not comparable')) | ||||
def getmax(self, context, mapping): | ||||
raise error.ParseError(_('not comparable')) | ||||
|
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: | ||||
raise error.ParseError(_('not displayable without template')) | ||||
return joinitems(itemiter, sep) | ||||
def show(self, context, mapping): | ||||
return self.join(context, mapping, self._defaultsep) | ||||
def tovalue(self, context, mapping): | ||||
|
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) | ||||
items.append({k: unwrapvalue(context, lm, v) | ||||
for k, v in nm.iteritems() if k not in knownres}) | ||||
return items | ||||
|
r37417 | |||
class mappinggenerator(_mappingsequence): | ||||
"""Wrapper for generator of template mappings | ||||
The function ``make(context, *args)`` should return a generator of | ||||
mapping dicts. | ||||
""" | ||||
def __init__(self, make, args=(), name=None, tmpl=None, sep=''): | ||||
super(mappinggenerator, self).__init__(name, tmpl, sep) | ||||
self._make = make | ||||
self._args = args | ||||
def itermaps(self, context): | ||||
return self._make(context, *self._args) | ||||
class mappinglist(_mappingsequence): | ||||
"""Wrapper for list of template mappings""" | ||||
def __init__(self, mappings, name=None, tmpl=None, sep=''): | ||||
super(mappinglist, self).__init__(name, tmpl, sep) | ||||
self._mappings = mappings | ||||
def itermaps(self, context): | ||||
return iter(self._mappings) | ||||
|
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 | ||||
def _gen(self, context): | ||||
return self._make(context, *self._args) | ||||
|
r38261 | def getmember(self, context, mapping, key): | ||
raise error.ParseError(_('not a dictionary')) | ||||
|
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: | ||||
raise error.ParseError(_('empty sequence')) | ||||
return func(xs) | ||||
|
r37517 | def itermaps(self, context): | ||
raise error.ParseError(_('list of strings is not mappable')) | ||||
def join(self, context, mapping, sep): | ||||
return joinitems(self._gen(context), sep) | ||||
def show(self, context, mapping): | ||||
return self.join(context, mapping, '') | ||||
def tovalue(self, context, mapping): | ||||
return [stringify(context, mapping, x) for x in self._gen(context)] | ||||
|
r36939 | 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)) | ||||
|
r37290 | def unwraphybrid(context, mapping, thing): | ||
|
r36939 | """Return an object which can be stringified possibly by using a legacy | ||
template""" | ||||
|
r37291 | if not isinstance(thing, wrapped): | ||
|
r36939 | return thing | ||
|
r37291 | return thing.show(context, mapping) | ||
|
r36939 | |||
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()] | ||||
|
r37086 | f = _showcompatlist(context, mapping, name, c, plural, separator) | ||
|
r36939 | 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. | ||||
""" | ||||
|
r37086 | f = _showcompatlist(context, mapping, name, data, plural, separator) | ||
|
r36939 | return hybridlist(data, name=element or name, fmt=fmt, gen=f) | ||
|
r37086 | def _showcompatlist(context, mapping, name, values, plural=None, separator=' '): | ||
"""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: | ||
plural = name + 's' | ||||
if not values: | ||||
noname = '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 | ||||
startname = 'start_' + plural | ||||
|
r37086 | if context.preload(startname): | ||
yield context.process(startname, mapping) | ||||
|
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) | ||
|
r36939 | lastname = '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) | ||||
endname = 'end_' + plural | ||||
|
r37086 | if context.preload(endname): | ||
yield context.process(endname, mapping) | ||||
|
r36939 | |||
|
r37290 | def flatten(context, mapping, thing): | ||
|
r37174 | """Yield a single stream from a possibly nested set of iterators""" | ||
|
r37290 | thing = unwraphybrid(context, mapping, thing) | ||
|
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. | ||||
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: | ||||
|
r37290 | i = unwraphybrid(context, mapping, i) | ||
|
r37174 | if isinstance(i, bytes): | ||
yield i | ||||
elif i is None: | ||||
pass | ||||
elif not util.safehasattr(i, '__iter__'): | ||||
yield pycompat.bytestr(i) | ||||
else: | ||||
|
r37290 | for j in flatten(context, mapping, i): | ||
|
r37174 | yield j | ||
|
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 | |||
|
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 | ||||
|
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) | ||||
|
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) | ||||
|
r38228 | def evalwrapped(context, mapping, arg): | ||
"""Evaluate given argument to wrapped object""" | ||||
thing = evalrawexp(context, mapping, arg) | ||||
return makewrapped(context, mapping, thing) | ||||
def makewrapped(context, mapping, thing): | ||||
"""Lift object to a wrapped type""" | ||||
if isinstance(thing, wrapped): | ||||
return thing | ||||
thing = _unthunk(context, mapping, thing) | ||||
if isinstance(thing, bytes): | ||||
return wrappedbytes(thing) | ||||
return wrappedvalue(thing) | ||||
|
r36931 | def evalfuncarg(context, mapping, arg): | ||
"""Evaluate given argument as value type""" | ||||
|
r38227 | return unwrapvalue(context, mapping, evalrawexp(context, mapping, arg)) | ||
|
r37178 | |||
|
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 | |||
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) | ||||
|
r38226 | if isinstance(thing, wrapped): | ||
thing = thing.tovalue(context, mapping) | ||||
|
r36931 | 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 '' | ||||
|
r37290 | return bool(stringify(context, mapping, thing)) | ||
|
r36931 | |||
|
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 | |||
|
r37290 | def unwrapdate(context, mapping, thing, err=None): | ||
|
r38227 | thing = unwrapvalue(context, mapping, thing) | ||
|
r37241 | try: | ||
return dateutil.parsedate(thing) | ||||
except AttributeError: | ||||
raise error.ParseError(err or _('not a date tuple nor a string')) | ||||
|
r37242 | except error.ParseError: | ||
if not err: | ||||
raise | ||||
raise error.ParseError(err) | ||||
|
r37241 | |||
|
r36931 | def evalinteger(context, mapping, arg, err=None): | ||
|
r37290 | thing = evalrawexp(context, mapping, arg) | ||
return unwrapinteger(context, mapping, thing, err) | ||||
|
r37179 | |||
|
r37290 | def unwrapinteger(context, mapping, thing, err=None): | ||
|
r38227 | thing = unwrapvalue(context, mapping, thing) | ||
|
r36931 | try: | ||
|
r37179 | return int(thing) | ||
|
r36931 | except (TypeError, ValueError): | ||
raise error.ParseError(err or _('not an integer')) | ||||
def evalstring(context, mapping, arg): | ||||
|
r37290 | return stringify(context, mapping, evalrawexp(context, mapping, arg)) | ||
|
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 | |||
|
r37180 | _unwrapfuncbytype = { | ||
|
r38227 | None: unwrapvalue, | ||
|
r37180 | bytes: stringify, | ||
|
r37244 | date: unwrapdate, | ||
|
r37180 | int: unwrapinteger, | ||
|
r36931 | } | ||
|
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: | ||
raise error.ProgrammingError('invalid type specified: %r' % typ) | ||||
|
r37290 | return f(context, mapping, thing) | ||
|
r36931 | |||
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 | ||||
|
r37088 | # (TODO: deprecate this after porting web template keywords to new API) | ||
|
r37091 | props = {k: context._resources.lookup(context, mapping, k) | ||
for k in context._resources.knownkeys()} | ||||
|
r37088 | # pass context to _showcompatlist() through templatekw._showlist() | ||
props['templ'] = context | ||||
|
r36931 | 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 | ||||
|
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)) | ||||
def _formatfiltererror(arg, filt): | ||||
fn = pycompat.sysbytes(filt.__name__) | ||||
sym = findsymbolicname(arg) | ||||
if not sym: | ||||
return _("incompatible use of template filter '%s'") % fn | ||||
return (_("template filter '%s' is not compatible with keyword '%s'") | ||||
% (fn, sym)) | ||||
|
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) | ||||
lm['index'] = i | ||||
yield lm | ||||
|
r38231 | def _applymap(context, mapping, d, targ): | ||
for lm in _iteroverlaymaps(context, mapping, d.itermaps(context)): | ||||
|
r37517 | yield evalrawexp(context, lm, targ) | ||
|
r36931 | def runmap(context, mapping, data): | ||
darg, targ = data | ||||
|
r38231 | d = evalwrapped(context, mapping, darg) | ||
return mappedgenerator(_applymap, args=(mapping, d, targ)) | ||||
|
r36931 | |||
def runmember(context, mapping, data): | ||||
darg, memb = data | ||||
|
r38258 | d = evalwrapped(context, mapping, darg) | ||
|
r36931 | if util.safehasattr(d, 'tomap'): | ||
|
r37092 | lm = context.overlaymap(mapping, d.tomap()) | ||
|
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 | ||||
hint = _("keyword '%s' does not support member operation") % sym | ||||
raise error.ParseError(bytes(err), hint=hint) | ||||
|
r36931 | |||
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')) | ||||
|
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 | ||||