templater.py
1576 lines
| 54.6 KiB
| text/x-python
|
PythonLexer
/ mercurial / templater.py
Vadim Gelfer
|
r1909 | # templater.py - template expansion for output | ||
# | ||||
# Copyright 2005, 2006 Matt Mackall <mpm@selenic.com> | ||||
# | ||||
Martin Geisler
|
r8225 | # This software may be used and distributed according to the terms of the | ||
Matt Mackall
|
r10263 | # GNU General Public License version 2 or any later version. | ||
Vadim Gelfer
|
r1909 | |||
Yuya Nishihara
|
r34139 | from __future__ import absolute_import, print_function | ||
Gregory Szorc
|
r25985 | |||
import os | ||||
import re | ||||
Weiwen
|
r17982 | import types | ||
Gregory Szorc
|
r25985 | |||
from .i18n import _ | ||||
from . import ( | ||||
Yuya Nishihara
|
r31521 | color, | ||
Gregory Szorc
|
r25985 | config, | ||
Yuya Nishihara
|
r31520 | encoding, | ||
Gregory Szorc
|
r25985 | error, | ||
minirst, | ||||
Boris Feld
|
r33995 | obsutil, | ||
Gregory Szorc
|
r25985 | parser, | ||
Pulkit Goyal
|
r30615 | pycompat, | ||
FUJIWARA Katsunori
|
r28696 | registrar, | ||
Gregory Szorc
|
r25985 | revset as revsetmod, | ||
Yuya Nishihara
|
r31024 | revsetlang, | ||
Yuya Nishihara
|
r34459 | scmutil, | ||
Gregory Szorc
|
r25985 | templatefilters, | ||
templatekw, | ||||
util, | ||||
) | ||||
Matt Mackall
|
r13176 | |||
# template parsing | ||||
elements = { | ||||
Yuya Nishihara
|
r25815 | # token-type: binding-strength, primary, prefix, infix, suffix | ||
"(": (20, None, ("group", 1, ")"), ("func", 1, ")"), None), | ||||
Yuya Nishihara
|
r34536 | ".": (18, None, None, (".", 18), None), | ||
Yuya Nishihara
|
r34330 | "%": (15, None, None, ("%", 15), None), | ||
Yuya Nishihara
|
r31884 | "|": (15, None, None, ("|", 15), None), | ||
"*": (5, None, None, ("*", 5), None), | ||||
"/": (5, None, None, ("/", 5), None), | ||||
"+": (4, None, None, ("+", 4), None), | ||||
"-": (4, None, ("negate", 19), ("-", 4), None), | ||||
Yuya Nishihara
|
r31885 | "=": (3, None, None, ("keyvalue", 3), None), | ||
Yuya Nishihara
|
r31883 | ",": (2, None, None, ("list", 2), None), | ||
")": (0, None, None, None, None), | ||||
Yuya Nishihara
|
r25815 | "integer": (0, "integer", None, None, None), | ||
"symbol": (0, "symbol", None, None, None), | ||||
"string": (0, "string", None, None, None), | ||||
"template": (0, "template", None, None, None), | ||||
"end": (0, None, None, None, None), | ||||
Matt Mackall
|
r13176 | } | ||
Yuya Nishihara
|
r28911 | def tokenize(program, start, end, term=None): | ||
"""Parse a template expression into a stream of tokens, which must end | ||||
with term if specified""" | ||||
Matt Mackall
|
r13176 | pos = start | ||
Pulkit Goyal
|
r32154 | program = pycompat.bytestr(program) | ||
Matt Mackall
|
r13176 | while pos < end: | ||
c = program[pos] | ||||
if c.isspace(): # skip inter-token whitespace | ||||
pass | ||||
Yuya Nishihara
|
r34536 | elif c in "(=,).%|+-*/": # handle simple operators | ||
Matt Mackall
|
r13176 | yield (c, None, pos) | ||
Yuya Nishihara
|
r25783 | elif c in '"\'': # handle quoted templates | ||
s = pos + 1 | ||||
data, pos = _parsetemplate(program, s, end, c) | ||||
yield ('template', data, s) | ||||
pos -= 1 | ||||
Yuya Nishihara
|
r25784 | elif c == 'r' and program[pos:pos + 2] in ("r'", 'r"'): | ||
# handle quoted strings | ||||
c = program[pos + 1] | ||||
s = pos = pos + 2 | ||||
Matt Mackall
|
r13176 | while pos < end: # find closing quote | ||
d = program[pos] | ||||
Yuya Nishihara
|
r25638 | if d == '\\': # skip over escaped characters | ||
Matt Mackall
|
r13176 | pos += 2 | ||
continue | ||||
if d == c: | ||||
Yuya Nishihara
|
r25785 | yield ('string', program[s:pos], s) | ||
Matt Mackall
|
r13176 | break | ||
pos += 1 | ||||
else: | ||||
raise error.ParseError(_("unterminated string"), s) | ||||
Simon Farnsworth
|
r30115 | elif c.isdigit(): | ||
Yuya Nishihara
|
r25002 | s = pos | ||
while pos < end: | ||||
d = program[pos] | ||||
if not d.isdigit(): | ||||
break | ||||
pos += 1 | ||||
yield ('integer', program[s:pos], s) | ||||
pos -= 1 | ||||
Yuya Nishihara
|
r25676 | elif (c == '\\' and program[pos:pos + 2] in (r"\'", r'\"') | ||
or c == 'r' and program[pos:pos + 3] in (r"r\'", r'r\"')): | ||||
# handle escaped quoted strings for compatibility with 2.9.2-3.4, | ||||
# where some of nested templates were preprocessed as strings and | ||||
# then compiled. therefore, \"...\" was allowed. (issue4733) | ||||
# | ||||
# processing flow of _evalifliteral() at 5ab28a2e9962: | ||||
# outer template string -> stringify() -> compiletemplate() | ||||
# ------------------------ ------------ ------------------ | ||||
# {f("\\\\ {g(\"\\\"\")}"} \\ {g("\"")} [r'\\', {g("\"")}] | ||||
# ~~~~~~~~ | ||||
# escaped quoted string | ||||
if c == 'r': | ||||
pos += 1 | ||||
Yuya Nishihara
|
r25785 | token = 'string' | ||
Yuya Nishihara
|
r25676 | else: | ||
Yuya Nishihara
|
r25783 | token = 'template' | ||
Yuya Nishihara
|
r25676 | quote = program[pos:pos + 2] | ||
s = pos = pos + 2 | ||||
while pos < end: # find closing escaped quote | ||||
if program.startswith('\\\\\\', pos, end): | ||||
pos += 4 # skip over double escaped characters | ||||
continue | ||||
if program.startswith(quote, pos, end): | ||||
Matt Mackall
|
r26215 | # interpret as if it were a part of an outer string | ||
Yuya Nishihara
|
r26231 | data = parser.unescapestr(program[s:pos]) | ||
Yuya Nishihara
|
r25783 | if token == 'template': | ||
data = _parsetemplate(data, 0, len(data))[0] | ||||
Yuya Nishihara
|
r25676 | yield (token, data, s) | ||
pos += 1 | ||||
break | ||||
pos += 1 | ||||
else: | ||||
raise error.ParseError(_("unterminated string"), s) | ||||
Matt Mackall
|
r13176 | elif c.isalnum() or c in '_': | ||
s = pos | ||||
pos += 1 | ||||
while pos < end: # find end of symbol | ||||
d = program[pos] | ||||
if not (d.isalnum() or d == "_"): | ||||
break | ||||
pos += 1 | ||||
sym = program[s:pos] | ||||
Brendan Cully
|
r18893 | yield ('symbol', sym, s) | ||
Matt Mackall
|
r13176 | pos -= 1 | ||
Yuya Nishihara
|
r28911 | elif c == term: | ||
Yuya Nishihara
|
r25782 | yield ('end', None, pos + 1) | ||
return | ||||
Matt Mackall
|
r13176 | else: | ||
raise error.ParseError(_("syntax error"), pos) | ||||
pos += 1 | ||||
Yuya Nishihara
|
r28911 | if term: | ||
raise error.ParseError(_("unterminated template expansion"), start) | ||||
yield ('end', None, pos) | ||||
Matt Mackall
|
r13176 | |||
Yuya Nishihara
|
r25783 | def _parsetemplate(tmpl, start, stop, quote=''): | ||
r""" | ||||
Yuya Nishihara
|
r34133 | >>> _parsetemplate(b'foo{bar}"baz', 0, 12) | ||
Yuya Nishihara
|
r25783 | ([('string', 'foo'), ('symbol', 'bar'), ('string', '"baz')], 12) | ||
Yuya Nishihara
|
r34133 | >>> _parsetemplate(b'foo{bar}"baz', 0, 12, quote=b'"') | ||
Yuya Nishihara
|
r25783 | ([('string', 'foo'), ('symbol', 'bar')], 9) | ||
Yuya Nishihara
|
r34133 | >>> _parsetemplate(b'foo"{bar}', 0, 9, quote=b'"') | ||
Yuya Nishihara
|
r25783 | ([('string', 'foo')], 4) | ||
Yuya Nishihara
|
r34133 | >>> _parsetemplate(br'foo\"bar"baz', 0, 12, quote=b'"') | ||
Yuya Nishihara
|
r25783 | ([('string', 'foo"'), ('string', 'bar')], 9) | ||
Yuya Nishihara
|
r34133 | >>> _parsetemplate(br'foo\\"bar', 0, 10, quote=b'"') | ||
Yuya Nishihara
|
r25785 | ([('string', 'foo\\')], 6) | ||
Yuya Nishihara
|
r25783 | """ | ||
Matt Mackall
|
r13176 | parsed = [] | ||
Yuya Nishihara
|
r25783 | sepchars = '{' + quote | ||
Yuya Nishihara
|
r25781 | pos = start | ||
Yuya Nishihara
|
r25654 | p = parser.parser(elements) | ||
Matt Mackall
|
r13176 | while pos < stop: | ||
Yuya Nishihara
|
r25783 | n = min((tmpl.find(c, pos, stop) for c in sepchars), | ||
key=lambda n: (n < 0, n)) | ||||
Matt Mackall
|
r13176 | if n < 0: | ||
Yuya Nishihara
|
r26231 | parsed.append(('string', parser.unescapestr(tmpl[pos:stop]))) | ||
Yuya Nishihara
|
r25780 | pos = stop | ||
Matt Mackall
|
r13176 | break | ||
Yuya Nishihara
|
r34073 | c = tmpl[n:n + 1] | ||
Yuya Nishihara
|
r24949 | bs = (n - pos) - len(tmpl[pos:n].rstrip('\\')) | ||
Yuya Nishihara
|
r25598 | if bs % 2 == 1: | ||
# escaped (e.g. '\{', '\\\{', but not '\\{') | ||||
Yuya Nishihara
|
r26231 | parsed.append(('string', parser.unescapestr(tmpl[pos:n - 1]) + c)) | ||
Matt Mackall
|
r13176 | pos = n + 1 | ||
continue | ||||
if n > pos: | ||||
Yuya Nishihara
|
r26231 | parsed.append(('string', parser.unescapestr(tmpl[pos:n]))) | ||
Yuya Nishihara
|
r25783 | if c == quote: | ||
return parsed, n + 1 | ||||
Matt Mackall
|
r13176 | |||
Yuya Nishihara
|
r28911 | parseres, pos = p.parse(tokenize(tmpl, n + 1, stop, '}')) | ||
Bernhard Leiner
|
r13665 | parsed.append(parseres) | ||
Yuya Nishihara
|
r25783 | |||
if quote: | ||||
raise error.ParseError(_("unterminated string"), start) | ||||
Yuya Nishihara
|
r25781 | return parsed, pos | ||
Matt Mackall
|
r13176 | |||
Yuya Nishihara
|
r28547 | def _unnesttemplatelist(tree): | ||
"""Expand list of templates to node tuple | ||||
>>> def f(tree): | ||||
Yuya Nishihara
|
r34139 | ... print(pycompat.sysstr(prettyformat(_unnesttemplatelist(tree)))) | ||
Yuya Nishihara
|
r34133 | >>> f((b'template', [])) | ||
Yuya Nishihara
|
r34075 | (string '') | ||
Yuya Nishihara
|
r34133 | >>> f((b'template', [(b'string', b'foo')])) | ||
Yuya Nishihara
|
r34075 | (string 'foo') | ||
Yuya Nishihara
|
r34133 | >>> f((b'template', [(b'string', b'foo'), (b'symbol', b'rev')])) | ||
Yuya Nishihara
|
r28547 | (template | ||
Yuya Nishihara
|
r34075 | (string 'foo') | ||
(symbol 'rev')) | ||||
Yuya Nishihara
|
r34133 | >>> f((b'template', [(b'symbol', b'rev')])) # template(rev) -> str | ||
Yuya Nishihara
|
r28547 | (template | ||
Yuya Nishihara
|
r34075 | (symbol 'rev')) | ||
Yuya Nishihara
|
r34133 | >>> f((b'template', [(b'template', [(b'string', b'foo')])])) | ||
Yuya Nishihara
|
r34075 | (string 'foo') | ||
Yuya Nishihara
|
r28547 | """ | ||
if not isinstance(tree, tuple): | ||||
return tree | ||||
op = tree[0] | ||||
if op != 'template': | ||||
return (op,) + tuple(_unnesttemplatelist(x) for x in tree[1:]) | ||||
assert len(tree) == 2 | ||||
xs = tuple(_unnesttemplatelist(x) for x in tree[1]) | ||||
if not xs: | ||||
return ('string', '') # empty template "" | ||||
elif len(xs) == 1 and xs[0][0] == 'string': | ||||
return xs[0] # fast path for string with no template fragment "x" | ||||
else: | ||||
return (op,) + xs | ||||
Yuya Nishihara
|
r28545 | def parse(tmpl): | ||
"""Parse template string into tree""" | ||||
Yuya Nishihara
|
r25781 | parsed, pos = _parsetemplate(tmpl, 0, len(tmpl)) | ||
Yuya Nishihara
|
r28545 | assert pos == len(tmpl), 'unquoted template should be consumed' | ||
Yuya Nishihara
|
r28547 | return _unnesttemplatelist(('template', parsed)) | ||
Yuya Nishihara
|
r28911 | def _parseexpr(expr): | ||
"""Parse a template expression into tree | ||||
Yuya Nishihara
|
r34133 | >>> _parseexpr(b'"foo"') | ||
Yuya Nishihara
|
r28911 | ('string', 'foo') | ||
Yuya Nishihara
|
r34133 | >>> _parseexpr(b'foo(bar)') | ||
Yuya Nishihara
|
r28911 | ('func', ('symbol', 'foo'), ('symbol', 'bar')) | ||
Yuya Nishihara
|
r34133 | >>> _parseexpr(b'foo(') | ||
Yuya Nishihara
|
r28911 | Traceback (most recent call last): | ||
... | ||||
ParseError: ('not a prefix: end', 4) | ||||
Yuya Nishihara
|
r34133 | >>> _parseexpr(b'"foo" "bar"') | ||
Yuya Nishihara
|
r28911 | Traceback (most recent call last): | ||
... | ||||
ParseError: ('invalid token', 7) | ||||
""" | ||||
p = parser.parser(elements) | ||||
tree, pos = p.parse(tokenize(expr, 0, len(expr))) | ||||
if pos != len(expr): | ||||
raise error.ParseError(_('invalid token'), pos) | ||||
return _unnesttemplatelist(tree) | ||||
Yuya Nishihara
|
r28547 | def prettyformat(tree): | ||
return parser.prettyformat(tree, ('integer', 'string', 'symbol')) | ||||
Yuya Nishihara
|
r28545 | |||
Yuya Nishihara
|
r25001 | def compileexp(exp, context, curmethods): | ||
Yuya Nishihara
|
r28956 | """Compile parsed template tree to (func, data) pair""" | ||
Matt Mackall
|
r13176 | t = exp[0] | ||
Yuya Nishihara
|
r25001 | if t in curmethods: | ||
return curmethods[t](exp, context) | ||||
Matt Mackall
|
r13176 | raise error.ParseError(_("unknown method '%s'") % t) | ||
# template evaluation | ||||
def getsymbol(exp): | ||||
if exp[0] == 'symbol': | ||||
return exp[1] | ||||
Ryan McElroy
|
r21822 | raise error.ParseError(_("expected a symbol, got '%s'") % exp[0]) | ||
Matt Mackall
|
r13176 | |||
def getlist(x): | ||||
if not x: | ||||
return [] | ||||
if x[0] == 'list': | ||||
return getlist(x[1]) + [x[2]] | ||||
return [x] | ||||
def gettemplate(exp, context): | ||||
Yuya Nishihara
|
r28545 | """Compile given template tree or load named template from map file; | ||
returns (func, data) pair""" | ||||
Yuya Nishihara
|
r28546 | if exp[0] in ('template', 'string'): | ||
Yuya Nishihara
|
r28545 | return compileexp(exp, context, methods) | ||
Matt Mackall
|
r13176 | if exp[0] == 'symbol': | ||
Yuya Nishihara
|
r25599 | # unlike runsymbol(), here 'symbol' is always taken as template name | ||
# even if it exists in mapping. this allows us to override mapping | ||||
# by web templates, e.g. 'changelogtag' is redefined in map file. | ||||
Matt Mackall
|
r13176 | return context._load(exp[1]) | ||
raise error.ParseError(_("expected template specifier")) | ||||
Yuya Nishihara
|
r31927 | 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 | ||||
Yuya Nishihara
|
r34327 | def evalrawexp(context, mapping, arg): | ||
"""Evaluate given argument as a bare template object which may require | ||||
further processing (such as folding generator of strings)""" | ||||
Yuya Nishihara
|
r26124 | func, data = arg | ||
Yuya Nishihara
|
r34327 | return func(context, mapping, data) | ||
def evalfuncarg(context, mapping, arg): | ||||
"""Evaluate given argument as value type""" | ||||
thing = evalrawexp(context, mapping, arg) | ||||
Yuya Nishihara
|
r34331 | thing = templatekw.unwrapvalue(thing) | ||
Yuya Nishihara
|
r34327 | # evalrawexp() may return string, generator of strings or arbitrary object | ||
# such as date tuple, but filter does not want generator. | ||||
Yuya Nishihara
|
r26124 | if isinstance(thing, types.GeneratorType): | ||
thing = stringify(thing) | ||||
return thing | ||||
Yuya Nishihara
|
r29816 | def evalboolean(context, mapping, arg): | ||
Yuya Nishihara
|
r29817 | """Evaluate given argument as boolean, but also takes boolean literals""" | ||
Yuya Nishihara
|
r29816 | func, data = arg | ||
Yuya Nishihara
|
r29817 | if func is runsymbol: | ||
thing = func(context, mapping, data, default=None) | ||||
if thing is None: | ||||
# not a template keyword, takes as a boolean literal | ||||
thing = util.parsebool(data) | ||||
else: | ||||
thing = func(context, mapping, data) | ||||
Yuya Nishihara
|
r34331 | thing = templatekw.unwrapvalue(thing) | ||
Yuya Nishihara
|
r29816 | 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)) | ||||
Yuya Nishihara
|
r34582 | def evalinteger(context, mapping, arg, err=None): | ||
Yuya Nishihara
|
r28344 | v = evalfuncarg(context, mapping, arg) | ||
Yuya Nishihara
|
r28343 | try: | ||
Yuya Nishihara
|
r28344 | return int(v) | ||
except (TypeError, ValueError): | ||||
Yuya Nishihara
|
r34582 | raise error.ParseError(err or _('not an integer')) | ||
Yuya Nishihara
|
r28343 | |||
Yuya Nishihara
|
r28348 | def evalstring(context, mapping, arg): | ||
Yuya Nishihara
|
r34327 | return stringify(evalrawexp(context, mapping, arg)) | ||
Yuya Nishihara
|
r28348 | |||
Yuya Nishihara
|
r28373 | 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) | ||||
Yuya Nishihara
|
r34582 | _evalfuncbytype = { | ||
bool: evalboolean, | ||||
bytes: evalstring, | ||||
int: evalinteger, | ||||
} | ||||
def evalastype(context, mapping, arg, typ): | ||||
"""Evaluate given argument and coerce its type""" | ||||
try: | ||||
f = _evalfuncbytype[typ] | ||||
except KeyError: | ||||
raise error.ProgrammingError('invalid type specified: %r' % typ) | ||||
return f(context, mapping, arg) | ||||
Yuya Nishihara
|
r25002 | def runinteger(context, mapping, data): | ||
return int(data) | ||||
Matt Mackall
|
r13176 | def runstring(context, mapping, data): | ||
return data | ||||
Yuya Nishihara
|
r27939 | def _recursivesymbolblocker(key): | ||
def showrecursion(**args): | ||||
raise error.Abort(_("recursive reference '%s' in template") % key) | ||||
return showrecursion | ||||
Yuya Nishihara
|
r27940 | def _runrecursivesymbol(context, mapping, key): | ||
raise error.Abort(_("recursive reference '%s' in template") % key) | ||||
Yuya Nishihara
|
r28373 | def runsymbol(context, mapping, key, default=''): | ||
Yuya Nishihara
|
r35483 | v = context.symbol(mapping, key) | ||
Alexander Plavin
|
r19770 | if v is None: | ||
Yuya Nishihara
|
r27939 | # 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) | ||||
Alexander Plavin
|
r19770 | try: | ||
Yuya Nishihara
|
r27939 | v = context.process(key, safemapping) | ||
Alexander Plavin
|
r19770 | except TemplateNotFound: | ||
Yuya Nishihara
|
r28373 | v = default | ||
Augie Fackler
|
r21798 | if callable(v): | ||
Yuya Nishihara
|
r35484 | # TODO: templatekw functions will be updated to take (context, mapping) | ||
# pair instead of **props | ||||
props = context._resources.copy() | ||||
props.update(mapping) | ||||
Pulkit Goyal
|
r35606 | return v(**pycompat.strkwargs(props)) | ||
Matt Mackall
|
r13176 | return v | ||
Yuya Nishihara
|
r25596 | def buildtemplate(exp, context): | ||
Yuya Nishihara
|
r28547 | ctmpl = [compileexp(e, context, methods) for e in exp[1:]] | ||
Yuya Nishihara
|
r25596 | return (runtemplate, ctmpl) | ||
Yuya Nishihara
|
r25595 | def runtemplate(context, mapping, template): | ||
Yuya Nishihara
|
r34327 | for arg in template: | ||
yield evalrawexp(context, mapping, arg) | ||||
Yuya Nishihara
|
r25595 | |||
Matt Mackall
|
r13176 | def buildfilter(exp, context): | ||
Yuya Nishihara
|
r26104 | n = getsymbol(exp[2]) | ||
if n in context._filters: | ||||
filt = context._filters[n] | ||||
Yuya Nishihara
|
r31886 | arg = compileexp(exp[1], context, methods) | ||
Yuya Nishihara
|
r26125 | return (runfilter, (arg, filt)) | ||
Yuya Nishihara
|
r26105 | if n in funcs: | ||
f = funcs[n] | ||||
Yuya Nishihara
|
r31886 | args = _buildfuncargs(exp[1], context, methods, n, f._argspec) | ||
return (f, args) | ||||
Yuya Nishihara
|
r26104 | raise error.ParseError(_("unknown function '%s'") % n) | ||
Matt Mackall
|
r13176 | |||
def runfilter(context, mapping, data): | ||||
Yuya Nishihara
|
r26125 | arg, filt = data | ||
thing = evalfuncarg(context, mapping, arg) | ||||
Neil Kodner
|
r17383 | try: | ||
Yuya Nishihara
|
r24280 | return filt(thing) | ||
Neil Kodner
|
r17383 | except (ValueError, AttributeError, TypeError): | ||
Yuya Nishihara
|
r31927 | sym = findsymbolicname(arg) | ||
if sym: | ||||
msg = (_("template filter '%s' is not compatible with keyword '%s'") | ||||
Augie Fackler
|
r34839 | % (pycompat.sysbytes(filt.__name__), sym)) | ||
Neil Kodner
|
r17383 | else: | ||
Augie Fackler
|
r34839 | msg = (_("incompatible use of template filter '%s'") | ||
% pycompat.sysbytes(filt.__name__)) | ||||
Yuya Nishihara
|
r31927 | raise error.Abort(msg) | ||
Matt Mackall
|
r13176 | |||
def buildmap(exp, context): | ||||
Yuya Nishihara
|
r34326 | darg = compileexp(exp[1], context, methods) | ||
targ = gettemplate(exp[2], context) | ||||
return (runmap, (darg, targ)) | ||||
Matt Mackall
|
r13176 | |||
def runmap(context, mapping, data): | ||||
Yuya Nishihara
|
r34327 | darg, targ = data | ||
d = evalrawexp(context, mapping, darg) | ||||
Yuya Nishihara
|
r27891 | if util.safehasattr(d, 'itermaps'): | ||
Yuya Nishihara
|
r28349 | diter = d.itermaps() | ||
else: | ||||
try: | ||||
diter = iter(d) | ||||
except TypeError: | ||||
Yuya Nishihara
|
r34327 | sym = findsymbolicname(darg) | ||
Yuya Nishihara
|
r34325 | if sym: | ||
raise error.ParseError(_("keyword '%s' is not iterable") % sym) | ||||
Yuya Nishihara
|
r28349 | else: | ||
raise error.ParseError(_("%r is not iterable") % d) | ||||
Matt Mackall
|
r17631 | |||
Yuya Nishihara
|
r31807 | for i, v in enumerate(diter): | ||
Kostia Balytskyi
|
r28225 | lm = mapping.copy() | ||
Yuya Nishihara
|
r31807 | lm['index'] = i | ||
Yuya Nishihara
|
r31806 | if isinstance(v, dict): | ||
lm.update(v) | ||||
Weiwen
|
r17991 | lm['originalnode'] = mapping.get('node') | ||
Yuya Nishihara
|
r34327 | yield evalrawexp(context, lm, targ) | ||
Matt Mackall
|
r13176 | else: | ||
# v is not an iterable of dicts, this happen when 'key' | ||||
# has been fully expanded already and format is useless. | ||||
# If so, return the expanded value. | ||||
Yuya Nishihara
|
r31806 | yield v | ||
Matt Mackall
|
r13176 | |||
Yuya Nishihara
|
r34536 | def buildmember(exp, context): | ||
darg = compileexp(exp[1], context, methods) | ||||
memb = getsymbol(exp[2]) | ||||
return (runmember, (darg, memb)) | ||||
def runmember(context, mapping, data): | ||||
darg, memb = data | ||||
d = evalrawexp(context, mapping, darg) | ||||
if util.safehasattr(d, 'tomap'): | ||||
lm = mapping.copy() | ||||
lm.update(d.tomap()) | ||||
return runsymbol(context, lm, memb) | ||||
Yuya Nishihara
|
r34537 | if util.safehasattr(d, 'get'): | ||
return _getdictitem(d, memb) | ||||
Yuya Nishihara
|
r34536 | |||
sym = findsymbolicname(darg) | ||||
if sym: | ||||
raise error.ParseError(_("keyword '%s' has no member") % sym) | ||||
else: | ||||
raise error.ParseError(_("%r has no member") % d) | ||||
Simon Farnsworth
|
r30115 | def buildnegate(exp, context): | ||
arg = compileexp(exp[1], context, exprmethods) | ||||
return (runnegate, arg) | ||||
def runnegate(context, mapping, data): | ||||
data = evalinteger(context, mapping, data, | ||||
_('negation needs an integer argument')) | ||||
return -data | ||||
def buildarithmetic(exp, context, func): | ||||
left = compileexp(exp[1], context, exprmethods) | ||||
right = compileexp(exp[2], context, exprmethods) | ||||
return (runarithmetic, (func, left, right)) | ||||
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')) | ||||
Simon Farnsworth
|
r30116 | try: | ||
return func(left, right) | ||||
except ZeroDivisionError: | ||||
raise error.Abort(_('division by zero is not defined')) | ||||
Simon Farnsworth
|
r30115 | |||
Matt Mackall
|
r13176 | def buildfunc(exp, context): | ||
n = getsymbol(exp[1]) | ||||
Matt Mackall
|
r14925 | if n in funcs: | ||
f = funcs[n] | ||||
Yuya Nishihara
|
r31886 | args = _buildfuncargs(exp[2], context, exprmethods, n, f._argspec) | ||
Matt Mackall
|
r14925 | return (f, args) | ||
Matt Mackall
|
r13176 | if n in context._filters: | ||
Yuya Nishihara
|
r31886 | args = _buildfuncargs(exp[2], context, exprmethods, n, argspec=None) | ||
Matt Mackall
|
r13176 | if len(args) != 1: | ||
raise error.ParseError(_("filter %s expects one argument") % n) | ||||
f = context._filters[n] | ||||
Yuya Nishihara
|
r26125 | return (runfilter, (args[0], f)) | ||
Sean Farley
|
r20857 | raise error.ParseError(_("unknown function '%s'") % n) | ||
Matt Mackall
|
r13176 | |||
Yuya Nishihara
|
r31886 | def _buildfuncargs(exp, context, curmethods, funcname, argspec): | ||
"""Compile parsed tree of function arguments into list or dict of | ||||
Yuya Nishihara
|
r31921 | (func, data) pairs | ||
>>> context = engine(lambda t: (runsymbol, t)) | ||||
>>> def fargs(expr, argspec): | ||||
... x = _parseexpr(expr) | ||||
... n = getsymbol(x[1]) | ||||
... return _buildfuncargs(x[2], context, exprmethods, n, argspec) | ||||
Yuya Nishihara
|
r34141 | >>> list(fargs(b'a(l=1, k=2)', b'k l m').keys()) | ||
Yuya Nishihara
|
r31922 | ['l', 'k'] | ||
Yuya Nishihara
|
r34133 | >>> args = fargs(b'a(opts=1, k=2)', b'**opts') | ||
Yuya Nishihara
|
r34141 | >>> list(args.keys()), list(args[b'opts'].keys()) | ||
Yuya Nishihara
|
r31922 | (['opts'], ['opts', 'k']) | ||
Yuya Nishihara
|
r31921 | """ | ||
Yuya Nishihara
|
r31886 | def compiledict(xs): | ||
Yuya Nishihara
|
r31922 | return util.sortdict((k, compileexp(x, context, curmethods)) | ||
for k, x in xs.iteritems()) | ||||
Yuya Nishihara
|
r31886 | def compilelist(xs): | ||
return [compileexp(x, context, curmethods) for x in xs] | ||||
if not argspec: | ||||
# filter or function with no argspec: return list of positional args | ||||
return compilelist(getlist(exp)) | ||||
# function with argspec: return dict of named args | ||||
Yuya Nishihara
|
r31921 | _poskeys, varkey, _keys, optkey = argspec = parser.splitargspec(argspec) | ||
Yuya Nishihara
|
r31886 | treeargs = parser.buildargsdict(getlist(exp), funcname, argspec, | ||
keyvaluenode='keyvalue', keynode='symbol') | ||||
Yuya Nishihara
|
r31922 | compargs = util.sortdict() | ||
Yuya Nishihara
|
r31886 | if varkey: | ||
compargs[varkey] = compilelist(treeargs.pop(varkey)) | ||||
Yuya Nishihara
|
r31921 | if optkey: | ||
compargs[optkey] = compiledict(treeargs.pop(optkey)) | ||||
Yuya Nishihara
|
r31886 | compargs.update(compiledict(treeargs)) | ||
return compargs | ||||
Yuya Nishihara
|
r31885 | def buildkeyvaluepair(exp, content): | ||
raise error.ParseError(_("can't use a key-value pair in this context")) | ||||
FUJIWARA Katsunori
|
r28696 | # dict of template built-in functions | ||
funcs = {} | ||||
templatefunc = registrar.templatefunc(funcs) | ||||
@templatefunc('date(date[, fmt])') | ||||
Alexander Plavin
|
r19390 | def date(context, mapping, args): | ||
FUJIWARA Katsunori
|
r28696 | """Format a date. See :hg:`help dates` for formatting | ||
Yuya Nishihara
|
r26106 | strings. The default is a Unix date format, including the timezone: | ||
"Mon Sep 04 15:13:13 2006 0700".""" | ||||
Alexander Plavin
|
r19390 | if not (1 <= len(args) <= 2): | ||
FUJIWARA Katsunori
|
r23112 | # i18n: "date" is a keyword | ||
Alexander Plavin
|
r19390 | raise error.ParseError(_("date expects one or two arguments")) | ||
Yuya Nishihara
|
r28334 | date = evalfuncarg(context, mapping, args[0]) | ||
Yuya Nishihara
|
r24903 | fmt = None | ||
Alexander Plavin
|
r19390 | if len(args) == 2: | ||
Yuya Nishihara
|
r28348 | fmt = evalstring(context, mapping, args[1]) | ||
Yuya Nishihara
|
r24903 | try: | ||
if fmt is None: | ||||
return util.datestr(date) | ||||
else: | ||||
return util.datestr(date, fmt) | ||||
except (TypeError, ValueError): | ||||
# i18n: "date" is a keyword | ||||
raise error.ParseError(_("date expects a date information")) | ||||
Alexander Plavin
|
r19390 | |||
Yuya Nishihara
|
r31928 | @templatefunc('dict([[key=]value...])', argspec='*args **kwargs') | ||
Yuya Nishihara
|
r31926 | def dict_(context, mapping, args): | ||
Yuya Nishihara
|
r31928 | """Construct a dict from key-value pairs. A key may be omitted if | ||
a value expression can provide an unambiguous name.""" | ||||
Yuya Nishihara
|
r31926 | data = util.sortdict() | ||
Yuya Nishihara
|
r31928 | |||
for v in args['args']: | ||||
k = findsymbolicname(v) | ||||
if not k: | ||||
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) | ||||
Yuya Nishihara
|
r31926 | data.update((k, evalfuncarg(context, mapping, v)) | ||
for k, v in args['kwargs'].iteritems()) | ||||
return templatekw.hybriddict(data) | ||||
FUJIWARA Katsunori
|
r28696 | @templatefunc('diff([includepattern [, excludepattern]])') | ||
FUJIWARA Katsunori
|
r22434 | def diff(context, mapping, args): | ||
FUJIWARA Katsunori
|
r28696 | """Show a diff, optionally | ||
Gregory Szorc
|
r24586 | specifying files to include or exclude.""" | ||
FUJIWARA Katsunori
|
r22434 | if len(args) > 2: | ||
# i18n: "diff" is a keyword | ||||
timeless
|
r27293 | raise error.ParseError(_("diff expects zero, one, or two arguments")) | ||
FUJIWARA Katsunori
|
r22434 | |||
def getpatterns(i): | ||||
if i < len(args): | ||||
Yuya Nishihara
|
r28348 | s = evalstring(context, mapping, args[i]).strip() | ||
FUJIWARA Katsunori
|
r22434 | if s: | ||
return [s] | ||||
return [] | ||||
Yuya Nishihara
|
r35483 | ctx = context.resource(mapping, 'ctx') | ||
FUJIWARA Katsunori
|
r22434 | chunks = ctx.diff(match=ctx.match([], getpatterns(0), getpatterns(1))) | ||
return ''.join(chunks) | ||||
Yuya Nishihara
|
r34459 | @templatefunc('extdata(source)', argspec='source') | ||
def extdata(context, mapping, args): | ||||
"""Show a text read from the specified extdata source. (EXPERIMENTAL)""" | ||||
if 'source' not in args: | ||||
# i18n: "extdata" is a keyword | ||||
raise error.ParseError(_('extdata expects one argument')) | ||||
source = evalstring(context, mapping, args['source']) | ||||
Yuya Nishihara
|
r35483 | cache = context.resource(mapping, 'cache').setdefault('extdata', {}) | ||
ctx = context.resource(mapping, 'ctx') | ||||
Yuya Nishihara
|
r34459 | if source in cache: | ||
data = cache[source] | ||||
else: | ||||
data = cache[source] = scmutil.extdatasource(ctx.repo(), source) | ||||
return data.get(ctx.rev(), '') | ||||
Hannes Oldenburg
|
r30008 | @templatefunc('files(pattern)') | ||
def files(context, mapping, args): | ||||
"""All files of the current changeset matching the pattern. See | ||||
:hg:`help patterns`.""" | ||||
if not len(args) == 1: | ||||
# i18n: "files" is a keyword | ||||
raise error.ParseError(_("files expects one argument")) | ||||
raw = evalstring(context, mapping, args[0]) | ||||
Yuya Nishihara
|
r35483 | ctx = context.resource(mapping, 'ctx') | ||
Hannes Oldenburg
|
r30008 | m = ctx.match([raw]) | ||
files = list(ctx.matches(m)) | ||||
Yuya Nishihara
|
r35484 | # TODO: pass (context, mapping) pair to keyword function | ||
props = context._resources.copy() | ||||
props.update(mapping) | ||||
return templatekw.showlist("file", files, props) | ||||
Hannes Oldenburg
|
r30008 | |||
FUJIWARA Katsunori
|
r28696 | @templatefunc('fill(text[, width[, initialident[, hangindent]]])') | ||
Alexander Plavin
|
r19390 | def fill(context, mapping, args): | ||
FUJIWARA Katsunori
|
r28696 | """Fill many | ||
Gregory Szorc
|
r24586 | paragraphs with optional indentation. See the "fill" filter.""" | ||
Alexander Plavin
|
r19390 | if not (1 <= len(args) <= 4): | ||
FUJIWARA Katsunori
|
r23112 | # i18n: "fill" is a keyword | ||
Alexander Plavin
|
r19390 | raise error.ParseError(_("fill expects one to four arguments")) | ||
Yuya Nishihara
|
r28348 | text = evalstring(context, mapping, args[0]) | ||
Alexander Plavin
|
r19390 | width = 76 | ||
initindent = '' | ||||
hangindent = '' | ||||
if 2 <= len(args) <= 4: | ||||
Yuya Nishihara
|
r28343 | width = evalinteger(context, mapping, args[1], | ||
# i18n: "fill" is a keyword | ||||
_("fill expects an integer width")) | ||||
Alexander Plavin
|
r19390 | try: | ||
Yuya Nishihara
|
r28348 | initindent = evalstring(context, mapping, args[2]) | ||
hangindent = evalstring(context, mapping, args[3]) | ||||
Alexander Plavin
|
r19390 | except IndexError: | ||
pass | ||||
return templatefilters.fill(text, width, initindent, hangindent) | ||||
Yuya Nishihara
|
r31169 | @templatefunc('formatnode(node)') | ||
def formatnode(context, mapping, args): | ||||
"""Obtain the preferred form of a changeset hash. (DEPRECATED)""" | ||||
if len(args) != 1: | ||||
# i18n: "formatnode" is a keyword | ||||
raise error.ParseError(_("formatnode expects one argument")) | ||||
Yuya Nishihara
|
r35483 | ui = context.resource(mapping, 'ui') | ||
Yuya Nishihara
|
r31169 | node = evalstring(context, mapping, args[0]) | ||
if ui.debugflag: | ||||
return node | ||||
return templatefilters.short(node) | ||||
Yuya Nishihara
|
r31887 | @templatefunc('pad(text, width[, fillchar=\' \'[, left=False]])', | ||
argspec='text width fillchar left') | ||||
Durham Goode
|
r20370 | def pad(context, mapping, args): | ||
FUJIWARA Katsunori
|
r28696 | """Pad text with a | ||
Gregory Szorc
|
r24586 | fill character.""" | ||
Yuya Nishihara
|
r31887 | if 'text' not in args or 'width' not in args: | ||
FUJIWARA Katsunori
|
r23112 | # i18n: "pad" is a keyword | ||
Durham Goode
|
r20370 | raise error.ParseError(_("pad() expects two to four arguments")) | ||
Yuya Nishihara
|
r31887 | width = evalinteger(context, mapping, args['width'], | ||
Yuya Nishihara
|
r28345 | # i18n: "pad" is a keyword | ||
_("pad() expects an integer width")) | ||||
Durham Goode
|
r20370 | |||
Yuya Nishihara
|
r31887 | text = evalstring(context, mapping, args['text']) | ||
Durham Goode
|
r20370 | |||
Yuya Nishihara
|
r29818 | left = False | ||
Durham Goode
|
r20370 | fillchar = ' ' | ||
Yuya Nishihara
|
r31887 | if 'fillchar' in args: | ||
fillchar = evalstring(context, mapping, args['fillchar']) | ||||
Yuya Nishihara
|
r31521 | if len(color.stripeffects(fillchar)) != 1: | ||
Yuya Nishihara
|
r31519 | # i18n: "pad" is a keyword | ||
raise error.ParseError(_("pad() expects a single fill character")) | ||||
Yuya Nishihara
|
r31887 | if 'left' in args: | ||
left = evalboolean(context, mapping, args['left']) | ||||
Durham Goode
|
r20370 | |||
Yuya Nishihara
|
r31521 | fillwidth = width - encoding.colwidth(color.stripeffects(text)) | ||
Yuya Nishihara
|
r31520 | if fillwidth <= 0: | ||
return text | ||||
Yuya Nishihara
|
r29818 | if left: | ||
Yuya Nishihara
|
r31520 | return fillchar * fillwidth + text | ||
Durham Goode
|
r20370 | else: | ||
Yuya Nishihara
|
r31520 | return text + fillchar * fillwidth | ||
Durham Goode
|
r20370 | |||
FUJIWARA Katsunori
|
r28696 | @templatefunc('indent(text, indentchars[, firstline])') | ||
Ryan McElroy
|
r25489 | def indent(context, mapping, args): | ||
FUJIWARA Katsunori
|
r28696 | """Indents all non-empty lines | ||
Ryan McElroy
|
r25489 | with the characters given in the indentchars string. An optional | ||
third parameter will override the indent for the first line only | ||||
if present.""" | ||||
if not (2 <= len(args) <= 3): | ||||
# i18n: "indent" is a keyword | ||||
raise error.ParseError(_("indent() expects two or three arguments")) | ||||
Yuya Nishihara
|
r28348 | text = evalstring(context, mapping, args[0]) | ||
indent = evalstring(context, mapping, args[1]) | ||||
Ryan McElroy
|
r25489 | |||
if len(args) == 3: | ||||
Yuya Nishihara
|
r28348 | firstline = evalstring(context, mapping, args[2]) | ||
Ryan McElroy
|
r25489 | else: | ||
firstline = indent | ||||
# the indent function doesn't indent the first line, so we do it here | ||||
return templatefilters.indent(firstline + text, indent) | ||||
FUJIWARA Katsunori
|
r28696 | @templatefunc('get(dict, key)') | ||
Benoit Boissinot
|
r18582 | def get(context, mapping, args): | ||
FUJIWARA Katsunori
|
r28696 | """Get an attribute/key from an object. Some keywords | ||
Gregory Szorc
|
r24586 | are complex types. This function allows you to obtain the value of an | ||
timeless@mozdev.org
|
r26197 | attribute on these types.""" | ||
Benoit Boissinot
|
r18582 | if len(args) != 2: | ||
# i18n: "get" is a keyword | ||||
raise error.ParseError(_("get() expects two arguments")) | ||||
Yuya Nishihara
|
r28331 | dictarg = evalfuncarg(context, mapping, args[0]) | ||
Benoit Boissinot
|
r18582 | if not util.safehasattr(dictarg, 'get'): | ||
# i18n: "get" is a keyword | ||||
raise error.ParseError(_("get() expects a dict as first argument")) | ||||
Yuya Nishihara
|
r28331 | key = evalfuncarg(context, mapping, args[1]) | ||
Yuya Nishihara
|
r34537 | return _getdictitem(dictarg, key) | ||
def _getdictitem(dictarg, key): | ||||
Yuya Nishihara
|
r34535 | val = dictarg.get(key) | ||
if val is None: | ||||
return | ||||
return templatekw.wraphybridvalue(dictarg, key, val) | ||||
Benoit Boissinot
|
r18582 | |||
FUJIWARA Katsunori
|
r28696 | @templatefunc('if(expr, then[, else])') | ||
Matt Mackall
|
r17636 | def if_(context, mapping, args): | ||
FUJIWARA Katsunori
|
r28696 | """Conditionally execute based on the result of | ||
Gregory Szorc
|
r24586 | an expression.""" | ||
Matt Mackall
|
r17636 | if not (2 <= len(args) <= 3): | ||
FUJIWARA Katsunori
|
r17890 | # i18n: "if" is a keyword | ||
Matt Mackall
|
r17636 | raise error.ParseError(_("if expects two or three arguments")) | ||
Yuya Nishihara
|
r29816 | test = evalboolean(context, mapping, args[0]) | ||
Matt Mackall
|
r17636 | if test: | ||
Yuya Nishihara
|
r34327 | yield evalrawexp(context, mapping, args[1]) | ||
Matt Mackall
|
r17636 | elif len(args) == 3: | ||
Yuya Nishihara
|
r34327 | yield evalrawexp(context, mapping, args[2]) | ||
Matt Mackall
|
r17636 | |||
r30049 | @templatefunc('ifcontains(needle, haystack, then[, else])') | |||
Durham Goode
|
r20518 | def ifcontains(context, mapping, args): | ||
FUJIWARA Katsunori
|
r28696 | """Conditionally execute based | ||
r30049 | on whether the item "needle" is in "haystack".""" | |||
Durham Goode
|
r20518 | if not (3 <= len(args) <= 4): | ||
# i18n: "ifcontains" is a keyword | ||||
raise error.ParseError(_("ifcontains expects three or four arguments")) | ||||
r30049 | haystack = evalfuncarg(context, mapping, args[1]) | |||
Yuya Nishihara
|
r34660 | try: | ||
needle = evalastype(context, mapping, args[0], | ||||
getattr(haystack, 'keytype', None) or bytes) | ||||
found = (needle in haystack) | ||||
except error.ParseError: | ||||
found = False | ||||
Durham Goode
|
r20518 | |||
Yuya Nishihara
|
r34660 | if found: | ||
Yuya Nishihara
|
r34327 | yield evalrawexp(context, mapping, args[2]) | ||
Durham Goode
|
r20518 | elif len(args) == 4: | ||
Yuya Nishihara
|
r34327 | yield evalrawexp(context, mapping, args[3]) | ||
Durham Goode
|
r20518 | |||
FUJIWARA Katsunori
|
r28696 | @templatefunc('ifeq(expr1, expr2, then[, else])') | ||
Matt Mackall
|
r17636 | def ifeq(context, mapping, args): | ||
FUJIWARA Katsunori
|
r28696 | """Conditionally execute based on | ||
Gregory Szorc
|
r24586 | whether 2 items are equivalent.""" | ||
Matt Mackall
|
r17636 | if not (3 <= len(args) <= 4): | ||
FUJIWARA Katsunori
|
r17890 | # i18n: "ifeq" is a keyword | ||
Matt Mackall
|
r17636 | raise error.ParseError(_("ifeq expects three or four arguments")) | ||
Yuya Nishihara
|
r28348 | test = evalstring(context, mapping, args[0]) | ||
match = evalstring(context, mapping, args[1]) | ||||
Matt Mackall
|
r17636 | if test == match: | ||
Yuya Nishihara
|
r34327 | yield evalrawexp(context, mapping, args[2]) | ||
Matt Mackall
|
r17636 | elif len(args) == 4: | ||
Yuya Nishihara
|
r34327 | yield evalrawexp(context, mapping, args[3]) | ||
Matt Mackall
|
r17636 | |||
FUJIWARA Katsunori
|
r28696 | @templatefunc('join(list, sep)') | ||
Alexander Plavin
|
r19390 | def join(context, mapping, args): | ||
FUJIWARA Katsunori
|
r28696 | """Join items in a list with a delimiter.""" | ||
Alexander Plavin
|
r19390 | if not (1 <= len(args) <= 2): | ||
# i18n: "join" is a keyword | ||||
raise error.ParseError(_("join expects one or two arguments")) | ||||
Yuya Nishihara
|
r34327 | # TODO: perhaps this should be evalfuncarg(), but it can't because hgweb | ||
# abuses generator as a keyword that returns a list of dicts. | ||||
joinset = evalrawexp(context, mapping, args[0]) | ||||
Yuya Nishihara
|
r34331 | joinset = templatekw.unwrapvalue(joinset) | ||
Yuya Nishihara
|
r34329 | joinfmt = getattr(joinset, 'joinfmt', pycompat.identity) | ||
Alexander Plavin
|
r19390 | joiner = " " | ||
if len(args) > 1: | ||||
Yuya Nishihara
|
r28348 | joiner = evalstring(context, mapping, args[1]) | ||
Alexander Plavin
|
r19390 | |||
first = True | ||||
for x in joinset: | ||||
if first: | ||||
first = False | ||||
else: | ||||
yield joiner | ||||
Yuya Nishihara
|
r34329 | yield joinfmt(x) | ||
Alexander Plavin
|
r19390 | |||
FUJIWARA Katsunori
|
r28696 | @templatefunc('label(label, expr)') | ||
Sean Farley
|
r18289 | def label(context, mapping, args): | ||
FUJIWARA Katsunori
|
r28696 | """Apply a label to generated content. Content with | ||
Gregory Szorc
|
r24586 | a label applied can result in additional post-processing, such as | ||
automatic colorization.""" | ||||
Sean Farley
|
r18289 | if len(args) != 2: | ||
# i18n: "label" is a keyword | ||||
raise error.ParseError(_("label expects two arguments")) | ||||
Yuya Nishihara
|
r35483 | ui = context.resource(mapping, 'ui') | ||
Yuya Nishihara
|
r28374 | thing = evalstring(context, mapping, args[1]) | ||
# preserve unknown symbol as literal so effects like 'red', 'bold', | ||||
# etc. don't need to be quoted | ||||
label = evalstringliteral(context, mapping, args[0]) | ||||
Kostia Balytskyi
|
r28384 | return ui.label(thing, label) | ||
Sean Farley
|
r18289 | |||
FUJIWARA Katsunori
|
r28696 | @templatefunc('latesttag([pattern])') | ||
Matt Harbison
|
r26485 | def latesttag(context, mapping, args): | ||
FUJIWARA Katsunori
|
r28696 | """The global tags matching the given pattern on the | ||
Matt Harbison
|
r31850 | most recent globally tagged ancestor of this changeset. | ||
If no such tags exist, the "{tag}" template resolves to | ||||
the string "null".""" | ||||
Matt Harbison
|
r26485 | if len(args) > 1: | ||
# i18n: "latesttag" is a keyword | ||||
raise error.ParseError(_("latesttag expects at most one argument")) | ||||
pattern = None | ||||
if len(args) == 1: | ||||
Yuya Nishihara
|
r28348 | pattern = evalstring(context, mapping, args[0]) | ||
Matt Harbison
|
r26485 | |||
Yuya Nishihara
|
r35484 | # TODO: pass (context, mapping) pair to keyword function | ||
props = context._resources.copy() | ||||
props.update(mapping) | ||||
return templatekw.showlatesttags(pattern, **pycompat.strkwargs(props)) | ||||
Matt Harbison
|
r26485 | |||
FUJIWARA Katsunori
|
r28696 | @templatefunc('localdate(date[, tz])') | ||
Yuya Nishihara
|
r26127 | def localdate(context, mapping, args): | ||
FUJIWARA Katsunori
|
r28696 | """Converts a date to the specified timezone. | ||
Yuya Nishihara
|
r26128 | The default is local date.""" | ||
if not (1 <= len(args) <= 2): | ||||
Yuya Nishihara
|
r26127 | # i18n: "localdate" is a keyword | ||
Yuya Nishihara
|
r26128 | raise error.ParseError(_("localdate expects one or two arguments")) | ||
Yuya Nishihara
|
r26127 | |||
date = evalfuncarg(context, mapping, args[0]) | ||||
try: | ||||
date = util.parsedate(date) | ||||
except AttributeError: # not str nor date tuple | ||||
# i18n: "localdate" is a keyword | ||||
raise error.ParseError(_("localdate expects a date information")) | ||||
Yuya Nishihara
|
r26128 | if len(args) >= 2: | ||
tzoffset = None | ||||
tz = evalfuncarg(context, mapping, args[1]) | ||||
if isinstance(tz, str): | ||||
Matt Mackall
|
r29636 | tzoffset, remainder = util.parsetimezone(tz) | ||
if remainder: | ||||
tzoffset = None | ||||
Yuya Nishihara
|
r26128 | if tzoffset is None: | ||
try: | ||||
tzoffset = int(tz) | ||||
except (TypeError, ValueError): | ||||
# i18n: "localdate" is a keyword | ||||
raise error.ParseError(_("localdate expects a timezone")) | ||||
else: | ||||
tzoffset = util.makedate()[1] | ||||
Yuya Nishihara
|
r26127 | return (date[0], tzoffset) | ||
Boris Feld
|
r33997 | @templatefunc('max(iterable)') | ||
def max_(context, mapping, args, **kwargs): | ||||
"""Return the max of an iterable""" | ||||
if len(args) != 1: | ||||
# i18n: "max" is a keyword | ||||
r35387 | raise error.ParseError(_("max expects one argument")) | |||
Boris Feld
|
r33997 | |||
iterable = evalfuncarg(context, mapping, args[0]) | ||||
try: | ||||
Yuya Nishihara
|
r34535 | x = max(iterable) | ||
Boris Feld
|
r33997 | except (TypeError, ValueError): | ||
# i18n: "max" is a keyword | ||||
raise error.ParseError(_("max first argument should be an iterable")) | ||||
Yuya Nishihara
|
r34535 | return templatekw.wraphybridvalue(iterable, x, x) | ||
Boris Feld
|
r33997 | |||
@templatefunc('min(iterable)') | ||||
def min_(context, mapping, args, **kwargs): | ||||
"""Return the min of an iterable""" | ||||
if len(args) != 1: | ||||
# i18n: "min" is a keyword | ||||
r35387 | raise error.ParseError(_("min expects one argument")) | |||
Boris Feld
|
r33997 | |||
iterable = evalfuncarg(context, mapping, args[0]) | ||||
try: | ||||
Yuya Nishihara
|
r34535 | x = min(iterable) | ||
Boris Feld
|
r33997 | except (TypeError, ValueError): | ||
# i18n: "min" is a keyword | ||||
raise error.ParseError(_("min first argument should be an iterable")) | ||||
Yuya Nishihara
|
r34535 | return templatekw.wraphybridvalue(iterable, x, x) | ||
Boris Feld
|
r33997 | |||
Simon Farnsworth
|
r30115 | @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")) | ||||
Simon Farnsworth
|
r30116 | func = lambda a, b: a % b | ||
return runarithmetic(context, mapping, (func, args[0], args[1])) | ||||
Simon Farnsworth
|
r30115 | |||
Martin von Zweigbergk
|
r34288 | @templatefunc('obsfateoperations(markers)') | ||
def obsfateoperations(context, mapping, args): | ||||
"""Compute obsfate related information based on markers (EXPERIMENTAL)""" | ||||
if len(args) != 1: | ||||
# i18n: "obsfateoperations" is a keyword | ||||
r35387 | raise error.ParseError(_("obsfateoperations expects one argument")) | |||
Martin von Zweigbergk
|
r34288 | |||
markers = evalfuncarg(context, mapping, args[0]) | ||||
try: | ||||
data = obsutil.markersoperations(markers) | ||||
return templatekw.hybridlist(data, name='operation') | ||||
except (TypeError, KeyError): | ||||
# i18n: "obsfateoperations" is a keyword | ||||
errmsg = _("obsfateoperations first argument should be an iterable") | ||||
raise error.ParseError(errmsg) | ||||
Boris Feld
|
r33997 | @templatefunc('obsfatedate(markers)') | ||
def obsfatedate(context, mapping, args): | ||||
"""Compute obsfate related information based on markers (EXPERIMENTAL)""" | ||||
if len(args) != 1: | ||||
# i18n: "obsfatedate" is a keyword | ||||
r35387 | raise error.ParseError(_("obsfatedate expects one argument")) | |||
Boris Feld
|
r33997 | |||
markers = evalfuncarg(context, mapping, args[0]) | ||||
try: | ||||
data = obsutil.markersdates(markers) | ||||
return templatekw.hybridlist(data, name='date', fmt='%d %d') | ||||
except (TypeError, KeyError): | ||||
# i18n: "obsfatedate" is a keyword | ||||
errmsg = _("obsfatedate first argument should be an iterable") | ||||
raise error.ParseError(errmsg) | ||||
Boris Feld
|
r33996 | @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 | ||||
r35387 | raise error.ParseError(_("obsfateusers expects one argument")) | |||
Boris Feld
|
r33996 | |||
markers = evalfuncarg(context, mapping, args[0]) | ||||
try: | ||||
data = obsutil.markersusers(markers) | ||||
return templatekw.hybridlist(data, name='user') | ||||
except (TypeError, KeyError, ValueError): | ||||
# i18n: "obsfateusers" is a keyword | ||||
msg = _("obsfateusers first argument should be an iterable of " | ||||
"obsmakers") | ||||
raise error.ParseError(msg) | ||||
Boris Feld
|
r35011 | @templatefunc('obsfateverb(successors, markers)') | ||
Boris Feld
|
r33995 | def obsfateverb(context, mapping, args): | ||
"""Compute obsfate related information based on successors (EXPERIMENTAL)""" | ||||
Boris Feld
|
r35011 | if len(args) != 2: | ||
Boris Feld
|
r33995 | # i18n: "obsfateverb" is a keyword | ||
Boris Feld
|
r35011 | raise error.ParseError(_("obsfateverb expects two arguments")) | ||
Boris Feld
|
r33995 | |||
successors = evalfuncarg(context, mapping, args[0]) | ||||
Boris Feld
|
r35011 | markers = evalfuncarg(context, mapping, args[1]) | ||
Boris Feld
|
r33995 | |||
try: | ||||
Boris Feld
|
r35011 | return obsutil.obsfateverb(successors, markers) | ||
Boris Feld
|
r33995 | except TypeError: | ||
# i18n: "obsfateverb" is a keyword | ||||
errmsg = _("obsfateverb first argument should be countable") | ||||
raise error.ParseError(errmsg) | ||||
Yuya Nishihara
|
r30083 | @templatefunc('relpath(path)') | ||
def relpath(context, mapping, args): | ||||
"""Convert a repository-absolute path into a filesystem path relative to | ||||
the current working directory.""" | ||||
if len(args) != 1: | ||||
# i18n: "relpath" is a keyword | ||||
raise error.ParseError(_("relpath expects one argument")) | ||||
Yuya Nishihara
|
r35483 | repo = context.resource(mapping, 'ctx').repo() | ||
Yuya Nishihara
|
r30083 | path = evalstring(context, mapping, args[0]) | ||
return repo.pathto(path) | ||||
FUJIWARA Katsunori
|
r28696 | @templatefunc('revset(query[, formatargs...])') | ||
Durham Goode
|
r20519 | def revset(context, mapping, args): | ||
FUJIWARA Katsunori
|
r28696 | """Execute a revision set query. See | ||
Gregory Szorc
|
r24586 | :hg:`help revset`.""" | ||
Durham Goode
|
r20519 | if not len(args) > 0: | ||
# i18n: "revset" is a keyword | ||||
raise error.ParseError(_("revset expects one or more arguments")) | ||||
Yuya Nishihara
|
r28348 | raw = evalstring(context, mapping, args[0]) | ||
Yuya Nishihara
|
r35483 | ctx = context.resource(mapping, 'ctx') | ||
Matt Harbison
|
r24337 | repo = ctx.repo() | ||
Durham Goode
|
r20519 | |||
FUJIWARA Katsunori
|
r22304 | def query(expr): | ||
Gregory Szorc
|
r33554 | m = revsetmod.match(repo.ui, expr, repo=repo) | ||
Yuya Nishihara
|
r24114 | return m(repo) | ||
FUJIWARA Katsunori
|
r22304 | |||
Durham Goode
|
r20519 | if len(args) > 1: | ||
Yuya Nishihara
|
r28333 | formatargs = [evalfuncarg(context, mapping, a) for a in args[1:]] | ||
Yuya Nishihara
|
r31024 | revs = query(revsetlang.formatspec(raw, *formatargs)) | ||
Yuya Nishihara
|
r28178 | revs = list(revs) | ||
Durham Goode
|
r20519 | else: | ||
Yuya Nishihara
|
r35483 | cache = context.resource(mapping, 'cache') | ||
revsetcache = cache.setdefault("revsetcache", {}) | ||||
Durham Goode
|
r20519 | if raw in revsetcache: | ||
revs = revsetcache[raw] | ||||
else: | ||||
FUJIWARA Katsunori
|
r22304 | revs = query(raw) | ||
Yuya Nishihara
|
r28178 | revs = list(revs) | ||
Durham Goode
|
r20519 | revsetcache[raw] = revs | ||
Yuya Nishihara
|
r35484 | # TODO: pass (context, mapping) pair to keyword function | ||
props = context._resources.copy() | ||||
props.update(mapping) | ||||
Pulkit Goyal
|
r35373 | return templatekw.showrevslist("revision", revs, | ||
Yuya Nishihara
|
r35484 | **pycompat.strkwargs(props)) | ||
Durham Goode
|
r20519 | |||
FUJIWARA Katsunori
|
r28696 | @templatefunc('rstdoc(text, style)') | ||
Dan Villiom Podlaski Christiansen
|
r18747 | def rstdoc(context, mapping, args): | ||
Mads Kiilerich
|
r30332 | """Format reStructuredText.""" | ||
Dan Villiom Podlaski Christiansen
|
r18747 | if len(args) != 2: | ||
# i18n: "rstdoc" is a keyword | ||||
raise error.ParseError(_("rstdoc expects two arguments")) | ||||
Yuya Nishihara
|
r28348 | text = evalstring(context, mapping, args[0]) | ||
style = evalstring(context, mapping, args[1]) | ||||
Dan Villiom Podlaski Christiansen
|
r18747 | |||
Alexander Plavin
|
r19079 | return minirst.format(text, style=style, keep=['verbose']) | ||
Dan Villiom Podlaski Christiansen
|
r18747 | |||
Yuya Nishihara
|
r31886 | @templatefunc('separate(sep, args)', argspec='sep *args') | ||
Martin von Zweigbergk
|
r29085 | def separate(context, mapping, args): | ||
"""Add a separator between non-empty arguments.""" | ||||
Yuya Nishihara
|
r31886 | if 'sep' not in args: | ||
Martin von Zweigbergk
|
r29085 | # i18n: "separate" is a keyword | ||
raise error.ParseError(_("separate expects at least one argument")) | ||||
Yuya Nishihara
|
r31886 | sep = evalstring(context, mapping, args['sep']) | ||
Martin von Zweigbergk
|
r29085 | first = True | ||
Yuya Nishihara
|
r31886 | for arg in args['args']: | ||
Martin von Zweigbergk
|
r29085 | argstr = evalstring(context, mapping, arg) | ||
if not argstr: | ||||
continue | ||||
if first: | ||||
first = False | ||||
else: | ||||
yield sep | ||||
yield argstr | ||||
FUJIWARA Katsunori
|
r28696 | @templatefunc('shortest(node, minlength=4)') | ||
Durham Goode
|
r20369 | def shortest(context, mapping, args): | ||
FUJIWARA Katsunori
|
r28696 | """Obtain the shortest representation of | ||
Gregory Szorc
|
r24586 | a node.""" | ||
Durham Goode
|
r20369 | if not (1 <= len(args) <= 2): | ||
FUJIWARA Katsunori
|
r23112 | # i18n: "shortest" is a keyword | ||
Durham Goode
|
r20369 | raise error.ParseError(_("shortest() expects one or two arguments")) | ||
Yuya Nishihara
|
r28348 | node = evalstring(context, mapping, args[0]) | ||
Durham Goode
|
r20369 | |||
minlength = 4 | ||||
if len(args) > 1: | ||||
Yuya Nishihara
|
r28346 | minlength = evalinteger(context, mapping, args[1], | ||
# i18n: "shortest" is a keyword | ||||
_("shortest() expects an integer minlength")) | ||||
Durham Goode
|
r20369 | |||
Yuya Nishihara
|
r30232 | # _partialmatch() of filtered changelog could take O(len(repo)) time, | ||
# which would be unacceptably slow. so we look for hash collision in | ||||
# unfiltered space, which means some hashes may be slightly longer. | ||||
Yuya Nishihara
|
r35483 | cl = context.resource(mapping, 'ctx')._repo.unfiltered().changelog | ||
Martin von Zweigbergk
|
r34247 | return cl.shortest(node, minlength) | ||
Durham Goode
|
r20369 | |||
FUJIWARA Katsunori
|
r28696 | @templatefunc('strip(text[, chars])') | ||
Alexander Plavin
|
r19330 | def strip(context, mapping, args): | ||
FUJIWARA Katsunori
|
r28696 | """Strip characters from a string. By default, | ||
Yuya Nishihara
|
r26106 | strips all leading and trailing whitespace.""" | ||
Alexander Plavin
|
r19330 | if not (1 <= len(args) <= 2): | ||
FUJIWARA Katsunori
|
r23112 | # i18n: "strip" is a keyword | ||
Alexander Plavin
|
r19330 | raise error.ParseError(_("strip expects one or two arguments")) | ||
Yuya Nishihara
|
r28348 | text = evalstring(context, mapping, args[0]) | ||
Alexander Plavin
|
r19330 | if len(args) == 2: | ||
Yuya Nishihara
|
r28348 | chars = evalstring(context, mapping, args[1]) | ||
Alexander Plavin
|
r19330 | return text.strip(chars) | ||
return text.strip() | ||||
FUJIWARA Katsunori
|
r28696 | @templatefunc('sub(pattern, replacement, expression)') | ||
Alexander Plavin
|
r19390 | def sub(context, mapping, args): | ||
FUJIWARA Katsunori
|
r28696 | """Perform text substitution | ||
Gregory Szorc
|
r24586 | using regular expressions.""" | ||
Alexander Plavin
|
r19390 | if len(args) != 3: | ||
# i18n: "sub" is a keyword | ||||
raise error.ParseError(_("sub expects three arguments")) | ||||
Yuya Nishihara
|
r28348 | pat = evalstring(context, mapping, args[0]) | ||
rpl = evalstring(context, mapping, args[1]) | ||||
src = evalstring(context, mapping, args[2]) | ||||
Yuya Nishihara
|
r26188 | try: | ||
patre = re.compile(pat) | ||||
except re.error: | ||||
# i18n: "sub" is a keyword | ||||
raise error.ParseError(_("sub got an invalid pattern: %s") % pat) | ||||
try: | ||||
yield patre.sub(rpl, src) | ||||
except re.error: | ||||
# i18n: "sub" is a keyword | ||||
raise error.ParseError(_("sub got an invalid replacement: %s") % rpl) | ||||
Alexander Plavin
|
r19390 | |||
FUJIWARA Katsunori
|
r28696 | @templatefunc('startswith(pattern, text)') | ||
Ryan McElroy
|
r21821 | def startswith(context, mapping, args): | ||
FUJIWARA Katsunori
|
r28696 | """Returns the value from the "text" argument | ||
Gregory Szorc
|
r24586 | if it begins with the content from the "pattern" argument.""" | ||
Ryan McElroy
|
r21821 | if len(args) != 2: | ||
FUJIWARA Katsunori
|
r21960 | # i18n: "startswith" is a keyword | ||
Ryan McElroy
|
r21821 | raise error.ParseError(_("startswith expects two arguments")) | ||
Yuya Nishihara
|
r28348 | patn = evalstring(context, mapping, args[0]) | ||
text = evalstring(context, mapping, args[1]) | ||||
Ryan McElroy
|
r21821 | if text.startswith(patn): | ||
return text | ||||
return '' | ||||
FUJIWARA Katsunori
|
r28696 | @templatefunc('word(number, text[, separator])') | ||
Ryan McElroy
|
r21846 | def word(context, mapping, args): | ||
FUJIWARA Katsunori
|
r28696 | """Return the nth word from a string.""" | ||
Ryan McElroy
|
r21846 | if not (2 <= len(args) <= 3): | ||
FUJIWARA Katsunori
|
r21960 | # i18n: "word" is a keyword | ||
Ryan McElroy
|
r21846 | raise error.ParseError(_("word expects two or three arguments, got %d") | ||
% len(args)) | ||||
Yuya Nishihara
|
r28343 | num = evalinteger(context, mapping, args[0], | ||
# i18n: "word" is a keyword | ||||
_("word expects an integer index")) | ||||
Yuya Nishihara
|
r28348 | text = evalstring(context, mapping, args[1]) | ||
Ryan McElroy
|
r21846 | if len(args) == 3: | ||
Yuya Nishihara
|
r28348 | splitter = evalstring(context, mapping, args[2]) | ||
Ryan McElroy
|
r21846 | else: | ||
splitter = None | ||||
tokens = text.split(splitter) | ||||
Matt Harbison
|
r26502 | if num >= len(tokens) or num < -len(tokens): | ||
Ryan McElroy
|
r21846 | return '' | ||
else: | ||||
return tokens[num] | ||||
Yuya Nishihara
|
r25001 | # methods to interpret function arguments or inner expressions (e.g. {_(x)}) | ||
exprmethods = { | ||||
Yuya Nishihara
|
r25002 | "integer": lambda e, c: (runinteger, e[1]), | ||
Matt Mackall
|
r13176 | "string": lambda e, c: (runstring, e[1]), | ||
"symbol": lambda e, c: (runsymbol, e[1]), | ||||
Yuya Nishihara
|
r25596 | "template": buildtemplate, | ||
Yuya Nishihara
|
r25001 | "group": lambda e, c: compileexp(e[1], c, exprmethods), | ||
Yuya Nishihara
|
r34536 | ".": buildmember, | ||
Matt Mackall
|
r13176 | "|": buildfilter, | ||
"%": buildmap, | ||||
"func": buildfunc, | ||||
Yuya Nishihara
|
r31885 | "keyvalue": buildkeyvaluepair, | ||
Simon Farnsworth
|
r30115 | "+": lambda e, c: buildarithmetic(e, c, lambda a, b: a + b), | ||
"-": lambda e, c: buildarithmetic(e, c, lambda a, b: a - b), | ||||
"negate": buildnegate, | ||||
"*": lambda e, c: buildarithmetic(e, c, lambda a, b: a * b), | ||||
"/": lambda e, c: buildarithmetic(e, c, lambda a, b: a // b), | ||||
Matt Mackall
|
r13176 | } | ||
Yuya Nishihara
|
r25001 | # methods to interpret top-level template (e.g. {x}, {x|_}, {x % "y"}) | ||
methods = exprmethods.copy() | ||||
Yuya Nishihara
|
r25002 | methods["integer"] = exprmethods["symbol"] # '{1}' as variable | ||
Yuya Nishihara
|
r25001 | |||
Yuya Nishihara
|
r28912 | class _aliasrules(parser.basealiasrules): | ||
"""Parsing and expansion rule set of template aliases""" | ||||
_section = _('template alias') | ||||
_parse = staticmethod(_parseexpr) | ||||
@staticmethod | ||||
def _trygetfunc(tree): | ||||
"""Return (name, args) if tree is func(...) or ...|filter; otherwise | ||||
None""" | ||||
if tree[0] == 'func' and tree[1][0] == 'symbol': | ||||
return tree[1][1], getlist(tree[2]) | ||||
if tree[0] == '|' and tree[2][0] == 'symbol': | ||||
return tree[2][1], [tree[1]] | ||||
def expandaliases(tree, aliases): | ||||
"""Return new tree of aliases are expanded""" | ||||
aliasmap = _aliasrules.buildmap(aliases) | ||||
return _aliasrules.expand(aliasmap, tree) | ||||
Matt Mackall
|
r13176 | # template engine | ||
Vadim Gelfer
|
r1901 | |||
Dirkjan Ochtman
|
r8360 | stringify = templatefilters.stringify | ||
Brendan Cully
|
r7107 | |||
Matt Mackall
|
r10850 | def _flatten(thing): | ||
'''yield a single stream from a possibly nested set of iterators''' | ||||
Yuya Nishihara
|
r31880 | thing = templatekw.unwraphybrid(thing) | ||
Pulkit Goyal
|
r32970 | if isinstance(thing, bytes): | ||
Matt Mackall
|
r10850 | yield thing | ||
Augie Fackler
|
r34724 | 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') | ||||
Yuya Nishihara
|
r29815 | elif thing is None: | ||
pass | ||||
Augie Fackler
|
r14944 | elif not util.safehasattr(thing, '__iter__'): | ||
Pulkit Goyal
|
r32974 | yield pycompat.bytestr(thing) | ||
Matt Mackall
|
r10852 | else: | ||
Matt Mackall
|
r10850 | for i in thing: | ||
Yuya Nishihara
|
r31880 | i = templatekw.unwraphybrid(i) | ||
Pulkit Goyal
|
r32970 | if isinstance(i, bytes): | ||
Matt Mackall
|
r10850 | yield i | ||
Yuya Nishihara
|
r29815 | elif i is None: | ||
pass | ||||
Augie Fackler
|
r14944 | elif not util.safehasattr(i, '__iter__'): | ||
Pulkit Goyal
|
r32974 | yield pycompat.bytestr(i) | ||
Yuya Nishihara
|
r29815 | else: | ||
Matt Mackall
|
r10850 | for j in _flatten(i): | ||
yield j | ||||
Yuya Nishihara
|
r24988 | def unquotestring(s): | ||
Yuya Nishihara
|
r28630 | '''unwrap quotes if any; otherwise returns unmodified string''' | ||
Yuya Nishihara
|
r28687 | if len(s) < 2 or s[0] not in "'\"" or s[0] != s[-1]: | ||
Yuya Nishihara
|
r28630 | return s | ||
Yuya Nishihara
|
r25696 | return s[1:-1] | ||
Vadim Gelfer
|
r1896 | |||
Dirkjan Ochtman
|
r8218 | class engine(object): | ||
Vadim Gelfer
|
r1909 | '''template expansion engine. | ||
template expansion works like this. a map file contains key=value | ||||
pairs. if value is quoted, it is treated as string. otherwise, it | ||||
is treated as name of template file. | ||||
templater is asked to expand a key in map. it looks up key, and | ||||
TK Soh
|
r4334 | looks for strings like this: {foo}. it expands {foo} by looking up | ||
Vadim Gelfer
|
r1909 | foo in map, and substituting it. expansion is recursive: it stops | ||
when there is no more {foo} to replace. | ||||
expansion also allows formatting and filtering. | ||||
format uses key to expand each item in list. syntax is | ||||
{key%format}. | ||||
filter uses function to transform value. syntax is | ||||
{key|filter1|filter2|...}.''' | ||||
Yuya Nishihara
|
r35484 | def __init__(self, loader, filters=None, defaults=None, resources=None, | ||
aliases=()): | ||||
Matt Mackall
|
r10848 | self._loader = loader | ||
Pierre-Yves David
|
r26330 | if filters is None: | ||
filters = {} | ||||
Matt Mackall
|
r10848 | self._filters = filters | ||
Pierre-Yves David
|
r26331 | if defaults is None: | ||
defaults = {} | ||||
Yuya Nishihara
|
r35484 | if resources is None: | ||
resources = {} | ||||
Matt Mackall
|
r10848 | self._defaults = defaults | ||
Yuya Nishihara
|
r35484 | self._resources = resources | ||
Yuya Nishihara
|
r28957 | self._aliasmap = _aliasrules.buildmap(aliases) | ||
Yuya Nishihara
|
r28545 | self._cache = {} # key: (func, data) | ||
Dirkjan Ochtman
|
r8218 | |||
Yuya Nishihara
|
r35483 | def symbol(self, mapping, key): | ||
"""Resolve symbol to value or function; None if nothing found""" | ||||
Yuya Nishihara
|
r35486 | v = None | ||
if key not in self._resources: | ||||
v = mapping.get(key) | ||||
Yuya Nishihara
|
r35483 | if v is None: | ||
v = self._defaults.get(key) | ||||
return v | ||||
def resource(self, mapping, key): | ||||
"""Return internal data (e.g. cache) used for keyword/function | ||||
evaluation""" | ||||
Yuya Nishihara
|
r35486 | v = None | ||
if key in self._resources: | ||||
v = mapping.get(key) | ||||
Yuya Nishihara
|
r35484 | if v is None: | ||
v = self._resources.get(key) | ||||
if v is None: | ||||
Yuya Nishihara
|
r35486 | raise error.Abort(_('template resource not available: %s') % key) | ||
Yuya Nishihara
|
r35484 | return v | ||
Yuya Nishihara
|
r35483 | |||
Matt Mackall
|
r13176 | def _load(self, t): | ||
'''load, parse, and cache a template''' | ||||
if t not in self._cache: | ||||
Yuya Nishihara
|
r27940 | # put poison to cut recursion while compiling 't' | ||
Yuya Nishihara
|
r28545 | self._cache[t] = (_runrecursivesymbol, t) | ||
Yuya Nishihara
|
r27940 | try: | ||
Yuya Nishihara
|
r28956 | x = parse(self._loader(t)) | ||
Yuya Nishihara
|
r28957 | if self._aliasmap: | ||
x = _aliasrules.expand(self._aliasmap, x) | ||||
Yuya Nishihara
|
r28956 | self._cache[t] = compileexp(x, self, methods) | ||
Yuya Nishihara
|
r27940 | except: # re-raises | ||
del self._cache[t] | ||||
raise | ||||
Matt Mackall
|
r13176 | return self._cache[t] | ||
Matt Mackall
|
r10853 | def process(self, t, mapping): | ||
'''Perform expansion. t is name of map element to expand. | ||||
mapping contains added elements for use during expansion. Is a | ||||
generator.''' | ||||
Yuya Nishihara
|
r28545 | func, data = self._load(t) | ||
return _flatten(func(self, mapping, data)) | ||||
Dirkjan Ochtman
|
r8218 | |||
Dirkjan Ochtman
|
r8361 | engines = {'default': engine} | ||
Iulian Stana
|
r19125 | def stylelist(): | ||
Mads Kiilerich
|
r22634 | paths = templatepaths() | ||
Simon Heimberg
|
r20312 | if not paths: | ||
return _('no templates found, try `hg debuginstall` for more info') | ||||
timeless
|
r27637 | dirlist = os.listdir(paths[0]) | ||
Iulian Stana
|
r19125 | stylelist = [] | ||
for file in dirlist: | ||||
split = file.split(".") | ||||
timeless
|
r28403 | if split[-1] in ('orig', 'rej'): | ||
continue | ||||
Iulian Stana
|
r19125 | if split[0] == "map-cmdline": | ||
stylelist.append(split[1]) | ||||
Augie Fackler
|
r19127 | return ", ".join(sorted(stylelist)) | ||
Iulian Stana
|
r19125 | |||
Yuya Nishihara
|
r28953 | def _readmapfile(mapfile): | ||
"""Load template elements from the given map file""" | ||||
if not os.path.exists(mapfile): | ||||
raise error.Abort(_("style '%s' not found") % mapfile, | ||||
hint=_("available styles: %s") % stylelist()) | ||||
base = os.path.dirname(mapfile) | ||||
conf = config.config(includepaths=templatepaths()) | ||||
Yuya Nishihara
|
r34715 | conf.read(mapfile, remap={'': 'templates'}) | ||
Yuya Nishihara
|
r28953 | |||
cache = {} | ||||
tmap = {} | ||||
Yuya Nishihara
|
r34716 | aliases = [] | ||
Yuya Nishihara
|
r34713 | |||
Yuya Nishihara
|
r34715 | val = conf.get('templates', '__base__') | ||
Yuya Nishihara
|
r34713 | if val and val[0] not in "'\"": | ||
# treat as a pointer to a base class for this style | ||||
path = util.normpath(os.path.join(base, val)) | ||||
# fallback check in template paths | ||||
if not os.path.exists(path): | ||||
for p in templatepaths(): | ||||
p2 = util.normpath(os.path.join(p, val)) | ||||
if os.path.isfile(p2): | ||||
path = p2 | ||||
break | ||||
p3 = util.normpath(os.path.join(p2, "map")) | ||||
if os.path.isfile(p3): | ||||
path = p3 | ||||
break | ||||
Yuya Nishihara
|
r34716 | cache, tmap, aliases = _readmapfile(path) | ||
Yuya Nishihara
|
r34713 | |||
Yuya Nishihara
|
r34715 | for key, val in conf['templates'].items(): | ||
Yuya Nishihara
|
r28953 | if not val: | ||
Yuya Nishihara
|
r34715 | raise error.ParseError(_('missing value'), | ||
conf.source('templates', key)) | ||||
Yuya Nishihara
|
r28953 | if val[0] in "'\"": | ||
if val[0] != val[-1]: | ||||
raise error.ParseError(_('unmatched quotes'), | ||||
Yuya Nishihara
|
r34715 | conf.source('templates', key)) | ||
Yuya Nishihara
|
r28953 | cache[key] = unquotestring(val) | ||
Yuya Nishihara
|
r34713 | elif key != '__base__': | ||
Yuya Nishihara
|
r28953 | val = 'default', val | ||
if ':' in val[1]: | ||||
val = val[1].split(':', 1) | ||||
tmap[key] = val[0], os.path.join(base, val[1]) | ||||
Yuya Nishihara
|
r34716 | aliases.extend(conf['templatealias'].items()) | ||
return cache, tmap, aliases | ||||
Yuya Nishihara
|
r28953 | |||
Pierre-Yves David
|
r26587 | class TemplateNotFound(error.Abort): | ||
Alexander Plavin
|
r19770 | pass | ||
Dirkjan Ochtman
|
r8218 | class templater(object): | ||
Yuya Nishihara
|
r35484 | def __init__(self, filters=None, defaults=None, resources=None, | ||
cache=None, aliases=(), minchunk=1024, maxchunk=65536): | ||||
Yuya Nishihara
|
r35497 | """Create template engine optionally with preloaded template fragments | ||
- ``filters``: a dict of functions to transform a value into another. | ||||
- ``defaults``: a dict of symbol values/functions; may be overridden | ||||
by a ``mapping`` dict. | ||||
- ``resources``: a dict of internal data (e.g. cache), inaccessible | ||||
from user template; may be overridden by a ``mapping`` dict. | ||||
- ``cache``: a dict of preloaded template fragments. | ||||
- ``aliases``: a list of alias (name, replacement) pairs. | ||||
self.cache may be updated later to register additional template | ||||
fragments. | ||||
""" | ||||
Pierre-Yves David
|
r26332 | if filters is None: | ||
filters = {} | ||||
Pierre-Yves David
|
r26333 | if defaults is None: | ||
defaults = {} | ||||
Yuya Nishihara
|
r35484 | if resources is None: | ||
resources = {} | ||||
Pierre-Yves David
|
r26334 | if cache is None: | ||
cache = {} | ||||
Shun-ichi Goto
|
r1975 | self.cache = cache.copy() | ||
Vadim Gelfer
|
r1896 | self.map = {} | ||
Dirkjan Ochtman
|
r8360 | self.filters = templatefilters.filters.copy() | ||
self.filters.update(filters) | ||||
Vadim Gelfer
|
r1964 | self.defaults = defaults | ||
Yuya Nishihara
|
r35484 | self._resources = {'templ': self} | ||
self._resources.update(resources) | ||||
Yuya Nishihara
|
r28957 | self._aliases = aliases | ||
Brendan Cully
|
r7396 | self.minchunk, self.maxchunk = minchunk, maxchunk | ||
Matt Mackall
|
r13187 | self.ecache = {} | ||
Vadim Gelfer
|
r1896 | |||
Yuya Nishihara
|
r28954 | @classmethod | ||
Yuya Nishihara
|
r35484 | def frommapfile(cls, mapfile, filters=None, defaults=None, resources=None, | ||
cache=None, minchunk=1024, maxchunk=65536): | ||||
Yuya Nishihara
|
r28954 | """Create templater from the specified map file""" | ||
Yuya Nishihara
|
r35484 | t = cls(filters, defaults, resources, cache, [], minchunk, maxchunk) | ||
Yuya Nishihara
|
r34716 | cache, tmap, aliases = _readmapfile(mapfile) | ||
Yuya Nishihara
|
r28954 | t.cache.update(cache) | ||
t.map = tmap | ||||
Yuya Nishihara
|
r34716 | t._aliases = aliases | ||
Yuya Nishihara
|
r28954 | return t | ||
Vadim Gelfer
|
r1896 | |||
Vadim Gelfer
|
r1899 | def __contains__(self, key): | ||
Matt Mackall
|
r3637 | return key in self.cache or key in self.map | ||
Vadim Gelfer
|
r1899 | |||
Dirkjan Ochtman
|
r8218 | def load(self, t): | ||
Dirkjan Ochtman
|
r6783 | '''Get the template for the given template name. Use a local cache.''' | ||
Brodie Rao
|
r16686 | if t not in self.cache: | ||
Vadim Gelfer
|
r1905 | try: | ||
Dan Villiom Podlaski Christiansen
|
r14168 | self.cache[t] = util.readfile(self.map[t][1]) | ||
Gregory Szorc
|
r25660 | except KeyError as inst: | ||
Alexander Plavin
|
r19770 | raise TemplateNotFound(_('"%s" not in template map') % | ||
inst.args[0]) | ||||
Gregory Szorc
|
r25660 | except IOError as inst: | ||
Vadim Gelfer
|
r1905 | raise IOError(inst.args[0], _('template file %s: %s') % | ||
Dirkjan Ochtman
|
r8361 | (self.map[t][1], inst.args[1])) | ||
Dirkjan Ochtman
|
r6783 | return self.cache[t] | ||
Vadim Gelfer
|
r1896 | |||
Yuya Nishihara
|
r32873 | def render(self, mapping): | ||
"""Render the default unnamed template and return result as string""" | ||||
Pulkit Goyal
|
r34348 | mapping = pycompat.strkwargs(mapping) | ||
Yuya Nishihara
|
r32873 | return stringify(self('', **mapping)) | ||
Matt Mackall
|
r10847 | def __call__(self, t, **mapping): | ||
Pulkit Goyal
|
r33016 | mapping = pycompat.byteskwargs(mapping) | ||
Dirkjan Ochtman
|
r8361 | ttype = t in self.map and self.map[t][0] or 'default' | ||
Matt Mackall
|
r13187 | if ttype not in self.ecache: | ||
Yuya Nishihara
|
r28831 | try: | ||
ecls = engines[ttype] | ||||
except KeyError: | ||||
raise error.Abort(_('invalid template engine: %s') % ttype) | ||||
Yuya Nishihara
|
r28957 | self.ecache[ttype] = ecls(self.load, self.filters, self.defaults, | ||
Yuya Nishihara
|
r35484 | self._resources, self._aliases) | ||
Matt Mackall
|
r13187 | proc = self.ecache[ttype] | ||
Dirkjan Ochtman
|
r8361 | |||
Matt Mackall
|
r10847 | stream = proc.process(t, mapping) | ||
Brendan Cully
|
r7396 | if self.minchunk: | ||
stream = util.increasingchunks(stream, min=self.minchunk, | ||||
max=self.maxchunk) | ||||
return stream | ||||
Dirkjan Ochtman
|
r7434 | |||
Mads Kiilerich
|
r22634 | def templatepaths(): | ||
'''return locations used for template files.''' | ||||
Mads Kiilerich
|
r22636 | pathsrel = ['templates'] | ||
Mads Kiilerich
|
r22635 | paths = [os.path.normpath(os.path.join(util.datapath, f)) | ||
for f in pathsrel] | ||||
return [p for p in paths if os.path.isdir(p)] | ||||
Vadim Gelfer
|
r2189 | |||
Mads Kiilerich
|
r22634 | def templatepath(name): | ||
'''return location of template file. returns None if not found.''' | ||||
for p in templatepaths(): | ||||
f = os.path.join(p, name) | ||||
if os.path.exists(f): | ||||
return f | ||||
return None | ||||
Vadim Gelfer
|
r2189 | |||
Dirkjan Ochtman
|
r9842 | def stylemap(styles, paths=None): | ||
Dirkjan Ochtman
|
r7966 | """Return path to mapfile for a given style. | ||
Searches mapfile in the following locations: | ||||
1. templatepath/style/map | ||||
2. templatepath/map-style | ||||
3. templatepath/map | ||||
""" | ||||
if paths is None: | ||||
Mads Kiilerich
|
r22634 | paths = templatepaths() | ||
Dirkjan Ochtman
|
r7966 | elif isinstance(paths, str): | ||
Dirkjan Ochtman
|
r8223 | paths = [paths] | ||
Dirkjan Ochtman
|
r7966 | |||
Dirkjan Ochtman
|
r9842 | if isinstance(styles, str): | ||
styles = [styles] | ||||
for style in styles: | ||||
Yuya Nishihara
|
r24296 | # only plain name is allowed to honor template paths | ||
if (not style | ||||
or style in (os.curdir, os.pardir) | ||||
Pulkit Goyal
|
r30615 | or pycompat.ossep in style | ||
Pulkit Goyal
|
r30625 | or pycompat.osaltsep and pycompat.osaltsep in style): | ||
Dirkjan Ochtman
|
r9842 | continue | ||
locations = [os.path.join(style, 'map'), 'map-' + style] | ||||
locations.append('map') | ||||
for path in paths: | ||||
for location in locations: | ||||
mapfile = os.path.join(path, location) | ||||
if os.path.isfile(mapfile): | ||||
return style, mapfile | ||||
Dirkjan Ochtman
|
r7966 | |||
raise RuntimeError("No hgweb templates found in %r" % paths) | ||||
Yuya Nishihara
|
r24601 | |||
FUJIWARA Katsunori
|
r28695 | def loadfunction(ui, extname, registrarobj): | ||
"""Load template function from specified registrarobj | ||||
""" | ||||
for name, func in registrarobj._table.iteritems(): | ||||
funcs[name] = func | ||||
Yuya Nishihara
|
r24601 | # tell hggettext to extract docstrings from these functions: | ||
i18nfunctions = funcs.values() | ||||