mercurial-scm/hg: mercurial/templateutil.py comparison

comparison mercurial/templateutil.py @ 37272:7d3bc1d4e871

templater: pass (context, mapping) down to unwraphybrid() See the subsequent patches for why. I initially thought it would be wrong to pass a mapping to flatten() and stringify() since these functions may be applied to a tree of generators, where each node should be bound to the mapping when it was evaluated. But, actually that isn't a problem. If an intermediate node has to override a mapping dict, it can do on unwraphybrid() and yield "unwrapped" generator of byte strings: "{f(g(v))}" # literal template example. ^^^^ # g() want to override a mapping, so it returns a wrapped # object 'G{V}' with partial mapping 'lm' attached. ^^^^^^^ # f() stringifies 'G{V}', starting from a mapping 'm'. # when unwrapping 'G{}', it updates 'm' with 'lm', and # passes it to 'V'. This structure is important for the formatter (and the hgweb) to build a static template keyword, which can't access a mapping dict until evaluation phase.

author	Yuya Nishihara <yuya@tcha.org>
date	Sat, 17 Mar 2018 20:09:05 +0900
parents	dc4bb1422f2b
children	83e1bbd48991

comparison

equal deleted inserted replaced

-:0194dac77c93
+:7d3bc1d4e871
 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):
+def unwraphybrid(context, mapping, 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
 yield one(last, tag=lastname)
 endname = 'end_' + plural
 if context.preload(endname):
 yield context.process(endname, mapping)
-def flatten(thing):
+def flatten(context, mapping, thing):
 """Yield a single stream from a possibly nested set of iterators"""
-thing = unwraphybrid(thing)
+thing = unwraphybrid(context, mapping, thing)
 if isinstance(thing, bytes):
 yield thing
 elif isinstance(thing, str):
 # We can only hit this on Python 3, and it's here to guard
 # against infinite recursion.
 pass
 elif not util.safehasattr(thing, '__iter__'):
 yield pycompat.bytestr(thing)
 else:
 for i in thing:
-i = unwraphybrid(i)
+i = unwraphybrid(context, mapping, i)
 if isinstance(i, bytes):
 yield i
 elif i is None:
 pass
 elif not util.safehasattr(i, '__iter__'):
 yield pycompat.bytestr(i)
 else:
-for j in flatten(i):
+for j in flatten(context, mapping, i):
 yield j
-def stringify(thing):
+def stringify(context, mapping, thing):
 """Turn values into bytes by converting into text and concatenating them"""
 if isinstance(thing, bytes):
 return thing  # retain localstr to be round-tripped
-return b''.join(flatten(thing))
+return b''.join(flatten(context, mapping, thing))
 def findsymbolicname(arg):
 """Find symbolic name for the given compiled expression; returns None
 if nothing found reliably"""
 while True:
 func, data = arg
 return func(context, mapping, data)
 def evalfuncarg(context, mapping, arg):
 """Evaluate given argument as value type"""
-return _unwrapvalue(evalrawexp(context, mapping, arg))
+return _unwrapvalue(context, mapping, 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):
+def _unwrapvalue(context, mapping, 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)
+thing = stringify(context, mapping, thing)
 return thing
 def evalboolean(context, mapping, arg):
 """Evaluate given argument as boolean, but also takes boolean literals"""
 func, data = arg
 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))
+return bool(stringify(context, mapping, thing))
 def evaldate(context, mapping, arg, err=None):
 """Evaluate given argument as a date tuple or a date string; returns
 a (unixtime, offset) tuple"""
-return unwrapdate(evalrawexp(context, mapping, arg), err)
+thing = evalrawexp(context, mapping, arg)
+return unwrapdate(context, mapping, thing, err)
-def unwrapdate(thing, err=None):
-thing = _unwrapvalue(thing)
+def unwrapdate(context, mapping, thing, err=None):
+thing = _unwrapvalue(context, mapping, thing)
 try:
 return dateutil.parsedate(thing)
 except AttributeError:
 raise error.ParseError(err or _('not a date tuple nor a string'))
 except error.ParseError:
 if not err:
 raise
 raise error.ParseError(err)
 def evalinteger(context, mapping, arg, err=None):
-return unwrapinteger(evalrawexp(context, mapping, arg), err)
+thing = evalrawexp(context, mapping, arg)
+return unwrapinteger(context, mapping, thing, err)
-def unwrapinteger(thing, err=None):
-thing = _unwrapvalue(thing)
+def unwrapinteger(context, mapping, thing, err=None):
+thing = _unwrapvalue(context, mapping, thing)
 try:
 return int(thing)
 except (TypeError, ValueError):
 raise error.ParseError(err or _('not an integer'))
 def evalstring(context, mapping, arg):
-return stringify(evalrawexp(context, mapping, arg))
+return stringify(context, mapping, evalrawexp(context, mapping, arg))
 def evalstringliteral(context, mapping, arg):
 """Evaluate given argument as string template, but returns symbol name
 if it is unknown"""
 func, data = arg
 if func is runsymbol:
 thing = func(context, mapping, data, default=data)
 else:
 thing = func(context, mapping, data)
-return stringify(thing)
+return stringify(context, mapping, thing)
 _unwrapfuncbytype = {
 None: _unwrapvalue,
 bytes: stringify,
 date: unwrapdate,
 int: unwrapinteger,
 }
-def unwrapastype(thing, typ):
+def unwrapastype(context, mapping, thing, typ):
 """Move the inner value object out of the wrapper and coerce its type"""
 try:
 f = _unwrapfuncbytype[typ]
 except KeyError:
 raise error.ProgrammingError('invalid type specified: %r' % typ)
-return f(thing)
+return f(context, mapping, thing)
 def runinteger(context, mapping, data):
 return int(data)
 def runstring(context, mapping, data):
 yield evalrawexp(context, mapping, arg)
 def runfilter(context, mapping, data):
 arg, filt = data
 thing = evalrawexp(context, mapping, arg)
+intype = getattr(filt, '_intype', None)
 try:
-thing = unwrapastype(thing, getattr(filt, '_intype', None))
+thing = unwrapastype(context, mapping, thing, intype)
 return filt(thing)
 except error.ParseError as e:
 raise error.ParseError(bytes(e), hint=_formatfiltererror(arg, filt))
 def _formatfiltererror(arg, filt):

Mercurial > public > mercurial-scm > hg

comparison mercurial/templateutil.py @ 37272:7d3bc1d4e871