mercurial-scm/hg-stable: mercurial/templatefuncs.py comparison

comparison mercurial/templatefuncs.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	da3329fe01e3
children	687b865b95ad

comparison

equal deleted inserted replaced

-:57875cf423c9
+:2372284d9457
 # dict of template built-in functions
 funcs = {}
 templatefunc = registrar.templatefunc(funcs)
 @templatefunc('date(date[, fmt])')
 def date(context, mapping, args):
 """Format a date. See :hg:`help dates` for formatting
 strings. The default is a Unix date format, including the timezone:
 "Mon Sep 04 15:13:13 2006 0700"."""
 if not (1 <= len(args) <= 2):
 # i18n: "date" is a keyword
 raise error.ParseError(_("date expects one or two arguments"))
-date = evaldate(context, mapping, args[0],
+date = evaldate(
-# i18n: "date" is a keyword
+context,
-_("date expects a date information"))
+mapping,
+args[0],
+# i18n: "date" is a keyword
+_("date expects a date information"),
+)
 fmt = None
 if len(args) == 2:
 fmt = evalstring(context, mapping, args[1])
 if fmt is None:
 return dateutil.datestr(date)
 else:
 return dateutil.datestr(date, fmt)
 @templatefunc('dict([[key=]value...])', argspec='*args **kwargs')
 def dict_(context, mapping, args):
 """Construct a dict from key-value pairs. A key may be omitted if
 a value expression can provide an unambiguous name."""
 raise error.ParseError(_('dict key cannot be inferred'))
 if k in data or k in args['kwargs']:
 raise error.ParseError(_("duplicated dict key '%s' inferred") % k)
 data[k] = evalfuncarg(context, mapping, v)
-data.update((k, evalfuncarg(context, mapping, v))
+data.update(
-for k, v in args['kwargs'].iteritems())
+(k, evalfuncarg(context, mapping, v))
+for k, v in args['kwargs'].iteritems()
+)
 return templateutil.hybriddict(data)
-@templatefunc('diff([includepattern [, excludepattern]])',
-requires={'ctx', 'ui'})
+@templatefunc(
+'diff([includepattern [, excludepattern]])', requires={'ctx', 'ui'}
+)
 def diff(context, mapping, args):
 """Show a diff, optionally
 specifying files to include or exclude."""
 if len(args) > 2:
 # i18n: "diff" is a keyword
 return []
 ctx = context.resource(mapping, 'ctx')
 ui = context.resource(mapping, 'ui')
 diffopts = diffutil.diffallopts(ui)
-chunks = ctx.diff(match=ctx.match([], getpatterns(0), getpatterns(1)),
+chunks = ctx.diff(
-opts=diffopts)
+match=ctx.match([], getpatterns(0), getpatterns(1)), opts=diffopts
+)
 return ''.join(chunks)
 @templatefunc('extdata(source)', argspec='source', requires={'ctx', 'cache'})
 def extdata(context, mapping, args):
 """Show a text read from the specified extdata source. (EXPERIMENTAL)"""
 if 'source' not in args:
 source = evalstring(context, mapping, args['source'])
 if not source:
 sym = templateutil.findsymbolicname(args['source'])
 if sym:
-raise error.ParseError(_('empty data source specified'),
+raise error.ParseError(
-hint=_("did you mean extdata('%s')?") % sym)
+_('empty data source specified'),
+hint=_("did you mean extdata('%s')?") % sym,
+)
 else:
 raise error.ParseError(_('empty data source specified'))
 cache = context.resource(mapping, 'cache').setdefault('extdata', {})
 ctx = context.resource(mapping, 'ctx')
 if source in cache:
 data = cache[source]
 else:
 data = cache[source] = scmutil.extdatasource(ctx.repo(), source)
 return data.get(ctx.rev(), '')
 @templatefunc('files(pattern)', requires={'ctx'})
 def files(context, mapping, args):
 """All files of the current changeset matching the pattern. See
 :hg:`help patterns`."""
 ctx = context.resource(mapping, 'ctx')
 m = ctx.match([raw])
 files = list(ctx.matches(m))
 return templateutil.compatfileslist(context, mapping, "file", files)
 @templatefunc('fill(text[, width[, initialident[, hangindent]]])')
 def fill(context, mapping, args):
 """Fill many
 paragraphs with optional indentation. See the "fill" filter."""
 if not (1 <= len(args) <= 4):
 text = evalstring(context, mapping, args[0])
 width = 76
 initindent = ''
 hangindent = ''
 if 2 <= len(args) <= 4:
-width = evalinteger(context, mapping, args[1],
+width = evalinteger(
-# i18n: "fill" is a keyword
+context,
-_("fill expects an integer width"))
+mapping,
+args[1],
+# i18n: "fill" is a keyword
+_("fill expects an integer width"),
+)
 try:
 initindent = evalstring(context, mapping, args[2])
 hangindent = evalstring(context, mapping, args[3])
 except IndexError:
 pass
 return templatefilters.fill(text, width, initindent, hangindent)
 @templatefunc('filter(iterable[, expr])')
 def filter_(context, mapping, args):
 """Remove empty elements from a list or a dict. If expr specified, it's
 applied to each element to test emptiness."""
 if not (1 <= len(args) <= 2):
 # i18n: "filter" is a keyword
 raise error.ParseError(_("filter expects one or two arguments"))
 iterable = evalwrapped(context, mapping, args[0])
 if len(args) == 1:
 def select(w):
 return w.tobool(context, mapping)
-else:
+else:
 def select(w):
 if not isinstance(w, templateutil.mappable):
 raise error.ParseError(_("not filterable by expression"))
 lm = context.overlaymap(mapping, w.tomap(context))
 return evalboolean(context, lm, args[1])
 return iterable.filter(context, mapping, select)
 @templatefunc('formatnode(node)', requires={'ui'})
 def formatnode(context, mapping, args):
 """Obtain the preferred form of a changeset hash. (DEPRECATED)"""
 if len(args) != 1:
 node = evalstring(context, mapping, args[0])
 if ui.debugflag:
 return node
 return templatefilters.short(node)
 @templatefunc('mailmap(author)', requires={'repo', 'cache'})
 def mailmap(context, mapping, args):
 """Return the author, updated according to the value
 set in the .mailmap file"""
 if len(args) != 1:
 data = repo.wvfs.tryread('.mailmap')
 cache['mailmap'] = stringutil.parsemailmap(data)
 return stringutil.mapname(cache['mailmap'], author)
 @templatefunc(
 'pad(text, width[, fillchar=\' \'[, left=False[, truncate=False]]])',
-argspec='text width fillchar left truncate')
+argspec='text width fillchar left truncate',
+)
 def pad(context, mapping, args):
 """Pad text with a
 fill character."""
 if 'text' not in args or 'width' not in args:
 # i18n: "pad" is a keyword
 raise error.ParseError(_("pad() expects two to four arguments"))
-width = evalinteger(context, mapping, args['width'],
+width = evalinteger(
-# i18n: "pad" is a keyword
+context,
-_("pad() expects an integer width"))
+mapping,
+args['width'],
+# i18n: "pad" is a keyword
+_("pad() expects an integer width"),
+)
 text = evalstring(context, mapping, args['text'])
 truncate = False
 left = False
 if left:
 return fillchar * fillwidth + text
 else:
 return text + fillchar * fillwidth
 @templatefunc('indent(text, indentchars[, firstline])')
 def indent(context, mapping, args):
 """Indents all non-empty lines
 with the characters given in the indentchars string. An optional
 third parameter will override the indent for the first line only
 firstline = indent
 # the indent function doesn't indent the first line, so we do it here
 return templatefilters.indent(firstline + text, indent)
 @templatefunc('get(dict, key)')
 def get(context, mapping, args):
 """Get an attribute/key from an object. Some keywords
 are complex types. This function allows you to obtain the value of an
 attribute on these types."""
 except error.ParseError as err:
 # i18n: "get" is a keyword
 hint = _("get() expects a dict as first argument")
 raise error.ParseError(bytes(err), hint=hint)
 @templatefunc('config(section, name[, default])', requires={'ui'})
 def config(context, mapping, args):
 """Returns the requested hgrc config option as a string."""
 fn = context.resource(mapping, 'ui').config
 return _config(context, mapping, args, fn, evalstring)
 @templatefunc('configbool(section, name[, default])', requires={'ui'})
 def configbool(context, mapping, args):
 """Returns the requested hgrc config option as a boolean."""
 fn = context.resource(mapping, 'ui').configbool
 return _config(context, mapping, args, fn, evalboolean)
 @templatefunc('configint(section, name[, default])', requires={'ui'})
 def configint(context, mapping, args):
 """Returns the requested hgrc config option as an integer."""
 fn = context.resource(mapping, 'ui').configint
 return _config(context, mapping, args, fn, evalinteger)
 def _config(context, mapping, args, configfn, defaultfn):
 if not (2 <= len(args) <= 3):
 raise error.ParseError(_("config expects two or three arguments"))
 default = defaultfn(context, mapping, args[2])
 return configfn(section, name, default)
 else:
 return configfn(section, name)
 @templatefunc('if(expr, then[, else])')
 def if_(context, mapping, args):
 """Conditionally execute based on the result of
 an expression."""
 if not (2 <= len(args) <= 3):
 if test:
 return evalrawexp(context, mapping, args[1])
 elif len(args) == 3:
 return evalrawexp(context, mapping, args[2])
 @templatefunc('ifcontains(needle, haystack, then[, else])')
 def ifcontains(context, mapping, args):
 """Conditionally execute based
 on whether the item "needle" is in "haystack"."""
 if not (3 <= len(args) <= 4):
 if found:
 return evalrawexp(context, mapping, args[2])
 elif len(args) == 4:
 return evalrawexp(context, mapping, args[3])
 @templatefunc('ifeq(expr1, expr2, then[, else])')
 def ifeq(context, mapping, args):
 """Conditionally execute based on
 whether 2 items are equivalent."""
 if not (3 <= len(args) <= 4):
 if test == match:
 return evalrawexp(context, mapping, args[2])
 elif len(args) == 4:
 return evalrawexp(context, mapping, args[3])
 @templatefunc('join(list, sep)')
 def join(context, mapping, args):
 """Join items in a list with a delimiter."""
 if not (1 <= len(args) <= 2):
 # i18n: "join" is a keyword
 joinset = evalwrapped(context, mapping, args[0])
 joiner = " "
 if len(args) > 1:
 joiner = evalstring(context, mapping, args[1])
 return joinset.join(context, mapping, joiner)
 @templatefunc('label(label, expr)', requires={'ui'})
 def label(context, mapping, args):
 """Apply a label to generated content. Content with
 a label applied can result in additional post-processing, such as
 # preserve unknown symbol as literal so effects like 'red', 'bold',
 # etc. don't need to be quoted
 label = evalstringliteral(context, mapping, args[0])
 return ui.label(thing, label)
 @templatefunc('latesttag([pattern])')
 def latesttag(context, mapping, args):
 """The global tags matching the given pattern on the
 most recent globally tagged ancestor of this changeset.
 pattern = None
 if len(args) == 1:
 pattern = evalstring(context, mapping, args[0])
 return templatekw.showlatesttags(context, mapping, pattern)
 @templatefunc('localdate(date[, tz])')
 def localdate(context, mapping, args):
 """Converts a date to the specified timezone.
 The default is local date."""
 if not (1 <= len(args) <= 2):
 # i18n: "localdate" is a keyword
 raise error.ParseError(_("localdate expects one or two arguments"))
-date = evaldate(context, mapping, args[0],
+date = evaldate(
-# i18n: "localdate" is a keyword
+context,
-_("localdate expects a date information"))
+mapping,
+args[0],
+# i18n: "localdate" is a keyword
+_("localdate expects a date information"),
+)
 if len(args) >= 2:
 tzoffset = None
 tz = evalfuncarg(context, mapping, args[1])
 if isinstance(tz, bytes):
 tzoffset, remainder = dateutil.parsetimezone(tz)
 raise error.ParseError(_("localdate expects a timezone"))
 else:
 tzoffset = dateutil.makedate()[1]
 return templateutil.date((date[0], tzoffset))
 @templatefunc('max(iterable)')
 def max_(context, mapping, args, **kwargs):
 """Return the max of an iterable"""
 if len(args) != 1:
 # i18n: "max" is a keyword
 except error.ParseError as err:
 # i18n: "max" is a keyword
 hint = _("max first argument should be an iterable")
 raise error.ParseError(bytes(err), hint=hint)
 @templatefunc('min(iterable)')
 def min_(context, mapping, args, **kwargs):
 """Return the min of an iterable"""
 if len(args) != 1:
 # i18n: "min" is a keyword
 except error.ParseError as err:
 # i18n: "min" is a keyword
 hint = _("min first argument should be an iterable")
 raise error.ParseError(bytes(err), hint=hint)
 @templatefunc('mod(a, b)')
 def mod(context, mapping, args):
 """Calculate a mod b such that a / b + a mod b == a"""
 if not len(args) == 2:
 # i18n: "mod" is a keyword
 raise error.ParseError(_("mod expects two arguments"))
 func = lambda a, b: a % b
-return templateutil.runarithmetic(context, mapping,
+return templateutil.runarithmetic(
-(func, args[0], args[1]))
+context, mapping, (func, args[0], args[1])
+)
 @templatefunc('obsfateoperations(markers)')
 def obsfateoperations(context, mapping, args):
 """Compute obsfate related information based on markers (EXPERIMENTAL)"""
 if len(args) != 1:
 return templateutil.hybridlist(data, name='operation')
 except (TypeError, KeyError):
 # i18n: "obsfateoperations" is a keyword
 errmsg = _("obsfateoperations first argument should be an iterable")
 raise error.ParseError(errmsg)
 @templatefunc('obsfatedate(markers)')
 def obsfatedate(context, mapping, args):
 """Compute obsfate related information based on markers (EXPERIMENTAL)"""
 if len(args) != 1:
 except (TypeError, KeyError):
 # i18n: "obsfatedate" is a keyword
 errmsg = _("obsfatedate first argument should be an iterable")
 raise error.ParseError(errmsg)
 @templatefunc('obsfateusers(markers)')
 def obsfateusers(context, mapping, args):
 """Compute obsfate related information based on markers (EXPERIMENTAL)"""
 if len(args) != 1:
 # i18n: "obsfateusers" is a keyword
 try:
 data = obsutil.markersusers(markers)
 return templateutil.hybridlist(data, name='user')
 except (TypeError, KeyError, ValueError):
 # i18n: "obsfateusers" is a keyword
-msg = _("obsfateusers first argument should be an iterable of "
+msg = _(
-"obsmakers")
+"obsfateusers first argument should be an iterable of " "obsmakers"
+)
 raise error.ParseError(msg)
 @templatefunc('obsfateverb(successors, markers)')
 def obsfateverb(context, mapping, args):
 """Compute obsfate related information based on successors (EXPERIMENTAL)"""
 if len(args) != 2:
 return obsutil.obsfateverb(successors, markers)
 except TypeError:
 # i18n: "obsfateverb" is a keyword
 errmsg = _("obsfateverb first argument should be countable")
 raise error.ParseError(errmsg)
 @templatefunc('relpath(path)', requires={'repo'})
 def relpath(context, mapping, args):
 """Convert a repository-absolute path into a filesystem path relative to
 the current working directory."""
 raise error.ParseError(_("relpath expects one argument"))
 repo = context.resource(mapping, 'repo')
 path = evalstring(context, mapping, args[0])
 return repo.pathto(path)
 @templatefunc('revset(query[, formatargs...])', requires={'repo', 'cache'})
 def revset(context, mapping, args):
 """Execute a revision set query. See
 :hg:`help revset`."""
 else:
 revs = query(raw)
 revsetcache[raw] = revs
 return templatekw.showrevslist(context, mapping, "revision", revs)
 @templatefunc('rstdoc(text, style)')
 def rstdoc(context, mapping, args):
 """Format reStructuredText."""
 if len(args) != 2:
 # i18n: "rstdoc" is a keyword
 text = evalstring(context, mapping, args[0])
 style = evalstring(context, mapping, args[1])
 return minirst.format(text, style=style, keep=['verbose'])
 @templatefunc('search(pattern, text)')
 def search(context, mapping, args):
 """Look for the first text matching the regular expression pattern.
 Groups are accessible as ``{1}``, ``{2}``, ... in %-mapped template."""
 patre = re.compile(pat)
 except re.error:
 # i18n: "search" is a keyword
 raise error.ParseError(_(b'search got an invalid pattern: %s') % pat)
 # named groups shouldn't shadow *reserved* resource keywords
-badgroups = (context.knownresourcekeys()
+badgroups = context.knownresourcekeys() & set(
-& set(pycompat.byteskwargs(patre.groupindex)))
+pycompat.byteskwargs(patre.groupindex)
+)
 if badgroups:
 raise error.ParseError(
 # i18n: "search" is a keyword
 _(b'invalid group %(group)s in search pattern: %(pat)s')
-% {b'group': b', '.join("'%s'" % g for g in sorted(badgroups)),
+% {
-b'pat': pat})
+b'group': b', '.join("'%s'" % g for g in sorted(badgroups)),
+b'pat': pat,
+}
+)
 match = patre.search(src)
 if not match:
 return templateutil.mappingnone()
 lm = {b'0': match.group(0)}
 lm.update((b'%d' % i, v) for i, v in enumerate(match.groups(), 1))
 lm.update(pycompat.byteskwargs(match.groupdict()))
 return templateutil.mappingdict(lm, tmpl=b'{0}')
 @templatefunc('separate(sep, args...)', argspec='sep *args')
 def separate(context, mapping, args):
 """Add a separator between non-empty arguments."""
 if 'sep' not in args:
 first = False
 else:
 yield sep
 yield argstr
 @templatefunc('shortest(node, minlength=4)', requires={'repo', 'cache'})
 def shortest(context, mapping, args):
 """Obtain the shortest representation of
 a node."""
 if not (1 <= len(args) <= 2):
 hexnode = evalstring(context, mapping, args[0])
 minlength = 4
 if len(args) > 1:
-minlength = evalinteger(context, mapping, args[1],
+minlength = evalinteger(
-# i18n: "shortest" is a keyword
+context,
-_("shortest() expects an integer minlength"))
+mapping,
+args[1],
+# i18n: "shortest" is a keyword
+_("shortest() expects an integer minlength"),
+)
 repo = context.resource(mapping, 'repo')
 if len(hexnode) > 40:
 return hexnode
 elif len(hexnode) == 40:
 try:
 return scmutil.shortesthexnodeidprefix(repo, node, minlength, cache)
 except error.RepoLookupError:
 return hexnode
 @templatefunc('strip(text[, chars])')
 def strip(context, mapping, args):
 """Strip characters from a string. By default,
 strips all leading and trailing whitespace."""
 if not (1 <= len(args) <= 2):
 if len(args) == 2:
 chars = evalstring(context, mapping, args[1])
 return text.strip(chars)
 return text.strip()
 @templatefunc('sub(pattern, replacement, expression)')
 def sub(context, mapping, args):
 """Perform text substitution
 using regular expressions."""
 if len(args) != 3:
 yield patre.sub(rpl, src)
 except re.error:
 # i18n: "sub" is a keyword
 raise error.ParseError(_("sub got an invalid replacement: %s") % rpl)
 @templatefunc('startswith(pattern, text)')
 def startswith(context, mapping, args):
 """Returns the value from the "text" argument
 if it begins with the content from the "pattern" argument."""
 if len(args) != 2:
 text = evalstring(context, mapping, args[1])
 if text.startswith(patn):
 return text
 return ''
 @templatefunc('word(number, text[, separator])')
 def word(context, mapping, args):
 """Return the nth word from a string."""
 if not (2 <= len(args) <= 3):
 # i18n: "word" is a keyword
-raise error.ParseError(_("word expects two or three arguments, got %d")
+raise error.ParseError(
-% len(args))
+_("word expects two or three arguments, got %d") % len(args)
+)
-num = evalinteger(context, mapping, args[0],
-# i18n: "word" is a keyword
+num = evalinteger(
-_("word expects an integer index"))
+context,
+mapping,
+args[0],
+# i18n: "word" is a keyword
+_("word expects an integer index"),
+)
 text = evalstring(context, mapping, args[1])
 if len(args) == 3:
 splitter = evalstring(context, mapping, args[2])
 else:
 splitter = None
 tokens = text.split(splitter)
 if num >= len(tokens) or num < -len(tokens):
 return ''
 else:
 return tokens[num]
 def loadfunction(ui, extname, registrarobj):
 """Load template function from specified registrarobj
 """
 for name, func in registrarobj._table.iteritems():
 funcs[name] = func
 # tell hggettext to extract docstrings from these functions:
 i18nfunctions = funcs.values()

Mercurial > public > mercurial-scm > hg-stable

comparison mercurial/templatefuncs.py @ 43076:2372284d9457