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

comparison mercurial/templateutil.py @ 43076:2372284d9457

formatting: blacken the codebase This is using my patch to black (https://github.com/psf/black/pull/826) so we don't un-wrap collection literals. Done with: hg files 'set:**.py - mercurial/thirdparty/** - "contrib/python-zstandard/**"' | xargs black -S # skip-blame mass-reformatting only # no-check-commit reformats foo_bar functions Differential Revision: https://phab.mercurial-scm.org/D6971

author	Augie Fackler <augie@google.com>
date	Sun, 06 Oct 2019 09:45:02 -0400
parents	832c59d1196e
children	687b865b95ad

comparison

equal deleted inserted replaced

-:57875cf423c9
+:2372284d9457
 from .utils import (
 dateutil,
 stringutil,
 )
 class ResourceUnavailable(error.Abort):
 pass
 class TemplateNotFound(error.Abort):
 pass
 class wrapped(object):
 """Object requiring extra conversion prior to displaying or processing
 as value
 """Move the inner value object out or create a value representation
 A returned value must be serializable by templaterfilters.json().
 """
 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"""
 class wrappedbytes(wrapped):
 """Wrapper for byte string"""
 def __init__(self, value):
 self._value = value
 def contains(self, context, mapping, item):
 item = stringify(context, mapping, item)
 return item in self._value
 def getmember(self, context, mapping, key):
-raise error.ParseError(_('%r is not a dictionary')
+raise error.ParseError(
-% pycompat.bytestr(self._value))
+_('%r is not a dictionary') % pycompat.bytestr(self._value)
+)
 def getmin(self, context, mapping):
 return self._getby(context, mapping, min)
 def getmax(self, context, mapping):
 if not self._value:
 raise error.ParseError(_('empty string'))
 return func(pycompat.iterbytestr(self._value))
 def filter(self, context, mapping, select):
-raise error.ParseError(_('%r is not filterable')
+raise error.ParseError(
-% pycompat.bytestr(self._value))
+_('%r is not filterable') % pycompat.bytestr(self._value)
+)
 def itermaps(self, context):
-raise error.ParseError(_('%r is not iterable of mappings')
+raise error.ParseError(
-% pycompat.bytestr(self._value))
+_('%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 bool(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
 def filter(self, context, mapping, select):
 raise error.ParseError(_("%r is not iterable") % self._value)
 def itermaps(self, context):
-raise error.ParseError(_('%r is not iterable of mappings')
+raise error.ParseError(
-% self._value)
+_('%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 bool(pycompat.bytestr(self._value))
 def tovalue(self, context, mapping):
 return self._value
 class date(mappable, wrapped):
 """Wrapper for date tuple"""
 def __init__(self, value, showfmt='%d %d'):
 # value may be (float, int), but public interface shouldn't support
 def tobool(self, context, mapping):
 return True
 def tovalue(self, context, mapping):
 return (self._unixtime, self._tzoffset)
 class hybrid(wrapped):
 """Wrapper for list or dict to support legacy template
 This class allows us to handle both:
 return val
 return hybriditem(None, key, val, self._makemap)
 def filter(self, context, mapping, select):
 if util.safehasattr(self._values, 'get'):
-values = {k: v for k, v in self._values.iteritems()
+values = {
-if select(self._wrapvalue(k, v))}
+k: v
+for k, v in self._values.iteritems()
+if select(self._wrapvalue(k, v))
+}
 else:
 values = [v for v in self._values if select(self._wrapvalue(v, v))]
 return hybrid(None, values, self._makemap, self._joinfmt, self._keytype)
 def itermaps(self, context):
 def tovalue(self, context, mapping):
 # TODO: make it non-recursive for trivial lists/dicts
 xs = self._values
 if util.safehasattr(xs, 'get'):
-return {k: unwrapvalue(context, mapping, v)
+return {
-for k, v in xs.iteritems()}
+k: unwrapvalue(context, mapping, v) for k, v in xs.iteritems()
+}
 return [unwrapvalue(context, mapping, x) for x in xs]
 class hybriditem(mappable, wrapped):
 """Wrapper for non-list/dict object to support map operation
 This class allows us to handle both:
 w = makewrapped(context, mapping, self._value)
 return w.tobool(context, mapping)
 def tovalue(self, context, mapping):
 return _unthunk(context, mapping, self._value)
 class _mappingsequence(wrapped):
 """Wrapper for sequence of template mappings
 This represents an inner template structure (i.e. a list of dicts),
 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)
+items.append(
-for k, v in nm.iteritems() if k not in knownres})
+{
+k: unwrapvalue(context, lm, v)
+for k, v in nm.iteritems()
+if k not in knownres
+}
+)
 return items
 class mappinggenerator(_mappingsequence):
 """Wrapper for generator of template mappings
 The function ``make(context, *args)`` should return a generator of
 return self._make(context, *self._args)
 def tobool(self, context, mapping):
 return _nonempty(self.itermaps(context))
 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)
 def itermaps(self, context):
 return iter(self._mappings)
 def tobool(self, context, mapping):
 return bool(self._mappings)
 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
 return True
 def tovalue(self, context, mapping):
 return super(mappingdict, self).tovalue(context, mapping)[0]
 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([])
 class mappedgenerator(wrapped):
 """Wrapper for generator of strings which acts as a list
 The function ``make(context, *args)`` should return a generator of
 return _nonempty(self._gen(context))
 def tovalue(self, context, mapping):
 return [stringify(context, mapping, x) for x in self._gen(context)]
 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]},
+return hybrid(
-lambda k: fmt % (prefmt(k), prefmt(data[k])))
+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 compatdict(context, mapping, name, data, key='key', value='value',
-fmt=None, plural=None, separator=' '):
+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=' '):
+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 compatfilecopiesdict(context, mapping, name, copies):
 """Wrap list of (dest, source) file names to support old-style list
 template and field names
 """
 # no need to provide {path} to old-style list template
 c = [{'name': k, 'source': v} for k, v in copies]
 f = _showcompatlist(context, mapping, name, c, plural='file_copies')
 copies = util.sortdict(copies)
-return hybrid(f, copies,
+return hybrid(
-lambda k: {'name': k, 'path': k, 'source': copies[k]},
+f,
-lambda k: '%s (%s)' % (k, copies[k]))
+copies,
+lambda k: {'name': k, 'path': k, 'source': copies[k]},
+lambda k: '%s (%s)' % (k, copies[k]),
+)
 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)
-return hybrid(f, files, lambda x: {'file': x, 'path': x},
+return hybrid(f, files, lambda x: {'file': x, 'path': x}, pycompat.identity)
-pycompat.identity)
 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.
 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
 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
 yield one(last, tag=lastname)
 endname = 'end_' + plural
 if context.preload(endname):
 yield context.process(endname, mapping)
 def flatten(context, mapping, thing):
 """Yield a single stream from a possibly nested set of iterators"""
 if isinstance(thing, wrapped):
 thing = thing.show(context, mapping)
 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'
+raise error.ProgrammingError(
-' with bytes, not strings, got %r' % thing)
+'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:
 yield pycompat.bytestr(i)
 else:
 for j in flatten(context, mapping, i):
 yield j
 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(context, mapping, thing))
 def findsymbolicname(arg):
 """Find symbolic name for the given compiled expression; returns None
 if nothing found reliably"""
 while True:
 elif func is runfilter:
 arg = data[0]
 else:
 return None
 def _nonempty(xiter):
 try:
 next(xiter)
 return True
 except StopIteration:
 return False
 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)
 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 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)
 def evalfuncarg(context, mapping, arg):
 """Evaluate given argument as value type"""
 return unwrapvalue(context, mapping, evalrawexp(context, mapping, arg))
 def unwrapvalue(context, mapping, thing):
 """Move the inner value object out of the wrapper"""
 if isinstance(thing, wrapped):
 return thing.tovalue(context, mapping)
 # evalrawexp() may return string, generator of strings or arbitrary object
 # such as date tuple, but filter does not want generator.
 return _unthunk(context, mapping, thing)
 def evalboolean(context, mapping, arg):
 """Evaluate given argument as boolean, but also takes boolean literals"""
 func, data = arg
 if func is runsymbol:
 thing = stringutil.parsebool(data)
 else:
 thing = func(context, mapping, data)
 return makewrapped(context, mapping, thing).tobool(context, mapping)
 def evaldate(context, mapping, arg, err=None):
 """Evaluate given argument as a date tuple or a date string; returns
 a (unixtime, offset) tuple"""
 thing = evalrawexp(context, mapping, arg)
 return unwrapdate(context, mapping, thing, err)
 def unwrapdate(context, mapping, thing, err=None):
 if isinstance(thing, date):
 return thing.tovalue(context, mapping)
 # TODO: update hgweb to not return bare tuple; then just stringify 'thing'
 except error.ParseError:
 if not err:
 raise
 raise error.ParseError(err)
 def evalinteger(context, mapping, arg, err=None):
 thing = evalrawexp(context, mapping, arg)
 return unwrapinteger(context, mapping, thing, err)
 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(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
 thing = func(context, mapping, data, default=data)
 else:
 thing = func(context, mapping, data)
 return stringify(context, mapping, thing)
 _unwrapfuncbytype = {
 None: unwrapvalue,
 bytes: stringify,
 date: unwrapdate,
 int: unwrapinteger,
 }
 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(context, mapping, thing)
 def runinteger(context, mapping, data):
 return int(data)
 def runstring(context, mapping, data):
 return data
 def _recursivesymbolblocker(key):
 def showrecursion(context, mapping):
 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
 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 = evalrawexp(context, mapping, arg)
 intype = 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):
 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'")
+return _("template filter '%s' is not compatible with keyword '%s'") % (
-% (fn, sym))
+fn,
+sym,
+)
 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
 def _applymap(context, mapping, d, darg, targ):
 try:
 diter = d.itermaps(context)
 except error.ParseError as err:
 hint = _("keyword '%s' does not support map operation") % sym
 raise error.ParseError(bytes(err), hint=hint)
 for lm in _iteroverlaymaps(context, mapping, diter):
 yield evalrawexp(context, lm, targ)
 def runmap(context, mapping, data):
 darg, targ = data
 d = evalwrapped(context, mapping, darg)
 return mappedgenerator(_applymap, args=(mapping, d, darg, targ))
 def runmember(context, mapping, data):
 darg, memb = data
 d = evalwrapped(context, mapping, darg)
 if isinstance(d, mappable):
 if not sym:
 raise
 hint = _("keyword '%s' does not support member operation") % sym
 raise error.ParseError(bytes(err), hint=hint)
 def runnegate(context, mapping, data):
-data = evalinteger(context, mapping, data,
+data = evalinteger(
-_('negation needs an integer argument'))
+context, mapping, data, _('negation needs an integer argument')
+)
 return -data
 def runarithmetic(context, mapping, data):
 func, left, right = data
-left = evalinteger(context, mapping, left,
+left = evalinteger(
-_('arithmetic only defined on integers'))
+context, mapping, left, _('arithmetic only defined on integers')
-right = evalinteger(context, mapping, right,
+)
-_('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 joinitems(itemiter, sep):
 """Join items with the separator; Returns generator of bytes"""
 first = True
 for x in itemiter:

Mercurial > public > mercurial-scm > hg

comparison mercurial/templateutil.py @ 43076:2372284d9457