templater.py
903 lines
| 30.6 KiB
| text/x-python
|
PythonLexer
/ mercurial / templater.py
|
r1909 | # templater.py - template expansion for output | ||
# | ||||
# Copyright 2005, 2006 Matt Mackall <mpm@selenic.com> | ||||
# | ||||
|
r8225 | # This software may be used and distributed according to the terms of the | ||
|
r10263 | # GNU General Public License version 2 or any later version. | ||
|
r1909 | |||
|
r3891 | from i18n import _ | ||
|
r22633 | import os, re | ||
|
r20519 | import util, config, templatefilters, templatekw, parser, error | ||
|
r22304 | import revset as revsetmod | ||
|
r17982 | import types | ||
|
r18747 | import minirst | ||
|
r13176 | |||
# template parsing | ||||
elements = { | ||||
|
r25815 | # token-type: binding-strength, primary, prefix, infix, suffix | ||
"(": (20, None, ("group", 1, ")"), ("func", 1, ")"), None), | ||||
",": (2, None, None, ("list", 2), None), | ||||
"|": (5, None, None, ("|", 5), None), | ||||
"%": (6, None, None, ("%", 6), None), | ||||
")": (0, None, None, None, None), | ||||
"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), | ||||
|
r13176 | } | ||
|
r25654 | def tokenize(program, start, end): | ||
|
r13176 | pos = start | ||
while pos < end: | ||||
c = program[pos] | ||||
if c.isspace(): # skip inter-token whitespace | ||||
pass | ||||
elif c in "(,)%|": # handle simple operators | ||||
yield (c, None, pos) | ||||
|
r25783 | elif c in '"\'': # handle quoted templates | ||
s = pos + 1 | ||||
data, pos = _parsetemplate(program, s, end, c) | ||||
yield ('template', data, s) | ||||
pos -= 1 | ||||
|
r25784 | elif c == 'r' and program[pos:pos + 2] in ("r'", 'r"'): | ||
# handle quoted strings | ||||
c = program[pos + 1] | ||||
s = pos = pos + 2 | ||||
|
r13176 | while pos < end: # find closing quote | ||
d = program[pos] | ||||
|
r25638 | if d == '\\': # skip over escaped characters | ||
|
r13176 | pos += 2 | ||
continue | ||||
if d == c: | ||||
|
r25785 | yield ('string', program[s:pos], s) | ||
|
r13176 | break | ||
pos += 1 | ||||
else: | ||||
raise error.ParseError(_("unterminated string"), s) | ||||
|
r25002 | elif c.isdigit() or c == '-': | ||
s = pos | ||||
if c == '-': # simply take negate operator as part of integer | ||||
pos += 1 | ||||
if pos >= end or not program[pos].isdigit(): | ||||
raise error.ParseError(_("integer literal without digits"), s) | ||||
pos += 1 | ||||
while pos < end: | ||||
d = program[pos] | ||||
if not d.isdigit(): | ||||
break | ||||
pos += 1 | ||||
yield ('integer', program[s:pos], s) | ||||
pos -= 1 | ||||
|
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 | ||||
|
r25785 | token = 'string' | ||
|
r25676 | else: | ||
|
r25783 | token = 'template' | ||
|
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): | ||||
try: | ||||
# interpret as if it were a part of an outer string | ||||
data = program[s:pos].decode('string-escape') | ||||
except ValueError: # unbalanced escapes | ||||
raise error.ParseError(_("syntax error"), s) | ||||
|
r25783 | if token == 'template': | ||
data = _parsetemplate(data, 0, len(data))[0] | ||||
|
r25676 | yield (token, data, s) | ||
pos += 1 | ||||
break | ||||
pos += 1 | ||||
else: | ||||
raise error.ParseError(_("unterminated string"), s) | ||||
|
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] | ||||
|
r18893 | yield ('symbol', sym, s) | ||
|
r13176 | pos -= 1 | ||
elif c == '}': | ||||
|
r25782 | yield ('end', None, pos + 1) | ||
return | ||||
|
r13176 | else: | ||
raise error.ParseError(_("syntax error"), pos) | ||||
pos += 1 | ||||
|
r25782 | raise error.ParseError(_("unterminated template expansion"), start) | ||
|
r13176 | |||
|
r25783 | def _parsetemplate(tmpl, start, stop, quote=''): | ||
r""" | ||||
>>> _parsetemplate('foo{bar}"baz', 0, 12) | ||||
([('string', 'foo'), ('symbol', 'bar'), ('string', '"baz')], 12) | ||||
>>> _parsetemplate('foo{bar}"baz', 0, 12, quote='"') | ||||
([('string', 'foo'), ('symbol', 'bar')], 9) | ||||
>>> _parsetemplate('foo"{bar}', 0, 9, quote='"') | ||||
([('string', 'foo')], 4) | ||||
>>> _parsetemplate(r'foo\"bar"baz', 0, 12, quote='"') | ||||
([('string', 'foo"'), ('string', 'bar')], 9) | ||||
>>> _parsetemplate(r'foo\\"bar', 0, 10, quote='"') | ||||
|
r25785 | ([('string', 'foo\\')], 6) | ||
|
r25783 | """ | ||
|
r13176 | parsed = [] | ||
|
r25783 | sepchars = '{' + quote | ||
|
r25781 | pos = start | ||
|
r25654 | p = parser.parser(elements) | ||
|
r13176 | while pos < stop: | ||
|
r25783 | n = min((tmpl.find(c, pos, stop) for c in sepchars), | ||
key=lambda n: (n < 0, n)) | ||||
|
r13176 | if n < 0: | ||
|
r25785 | parsed.append(('string', tmpl[pos:stop].decode('string-escape'))) | ||
|
r25780 | pos = stop | ||
|
r13176 | break | ||
|
r25783 | c = tmpl[n] | ||
|
r24949 | bs = (n - pos) - len(tmpl[pos:n].rstrip('\\')) | ||
|
r25598 | if bs % 2 == 1: | ||
# escaped (e.g. '\{', '\\\{', but not '\\{') | ||||
|
r25785 | parsed.append(('string', | ||
tmpl[pos:n - 1].decode('string-escape') + c)) | ||||
|
r13176 | pos = n + 1 | ||
continue | ||||
if n > pos: | ||||
|
r25785 | parsed.append(('string', tmpl[pos:n].decode('string-escape'))) | ||
|
r25783 | if c == quote: | ||
return parsed, n + 1 | ||||
|
r13176 | |||
|
r25654 | parseres, pos = p.parse(tokenize(tmpl, n + 1, stop)) | ||
|
r13665 | parsed.append(parseres) | ||
|
r25783 | |||
if quote: | ||||
raise error.ParseError(_("unterminated string"), start) | ||||
|
r25781 | return parsed, pos | ||
|
r13176 | |||
|
r25781 | def compiletemplate(tmpl, context): | ||
parsed, pos = _parsetemplate(tmpl, 0, len(tmpl)) | ||||
|
r25001 | return [compileexp(e, context, methods) for e in parsed] | ||
|
r13176 | |||
|
r25001 | def compileexp(exp, context, curmethods): | ||
|
r13176 | t = exp[0] | ||
|
r25001 | if t in curmethods: | ||
return curmethods[t](exp, context) | ||||
|
r13176 | raise error.ParseError(_("unknown method '%s'") % t) | ||
# template evaluation | ||||
def getsymbol(exp): | ||||
if exp[0] == 'symbol': | ||||
return exp[1] | ||||
|
r21822 | raise error.ParseError(_("expected a symbol, got '%s'") % exp[0]) | ||
|
r13176 | |||
def getlist(x): | ||||
if not x: | ||||
return [] | ||||
if x[0] == 'list': | ||||
return getlist(x[1]) + [x[2]] | ||||
return [x] | ||||
def getfilter(exp, context): | ||||
f = getsymbol(exp) | ||||
if f not in context._filters: | ||||
raise error.ParseError(_("unknown function '%s'") % f) | ||||
return context._filters[f] | ||||
def gettemplate(exp, context): | ||||
|
r25596 | if exp[0] == 'template': | ||
|
r25783 | return [compileexp(e, context, methods) for e in exp[1]] | ||
|
r13176 | if exp[0] == 'symbol': | ||
|
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. | ||||
|
r13176 | return context._load(exp[1]) | ||
raise error.ParseError(_("expected template specifier")) | ||||
|
r25002 | def runinteger(context, mapping, data): | ||
return int(data) | ||||
|
r13176 | def runstring(context, mapping, data): | ||
return data | ||||
def runsymbol(context, mapping, key): | ||||
v = mapping.get(key) | ||||
if v is None: | ||||
|
r19770 | v = context._defaults.get(key) | ||
if v is None: | ||||
try: | ||||
v = context.process(key, mapping) | ||||
except TemplateNotFound: | ||||
v = '' | ||||
|
r21798 | if callable(v): | ||
|
r13176 | return v(**mapping) | ||
|
r17982 | if isinstance(v, types.GeneratorType): | ||
v = list(v) | ||||
|
r13176 | return v | ||
|
r25596 | def buildtemplate(exp, context): | ||
|
r25783 | ctmpl = [compileexp(e, context, methods) for e in exp[1]] | ||
|
r25596 | if len(ctmpl) == 1: | ||
return ctmpl[0] # fast path for string with no template fragment | ||||
return (runtemplate, ctmpl) | ||||
|
r25595 | def runtemplate(context, mapping, template): | ||
for func, data in template: | ||||
yield func(context, mapping, data) | ||||
|
r13176 | def buildfilter(exp, context): | ||
|
r25001 | func, data = compileexp(exp[1], context, methods) | ||
|
r13176 | filt = getfilter(exp[2], context) | ||
return (runfilter, (func, data, filt)) | ||||
def runfilter(context, mapping, data): | ||||
func, data, filt = data | ||||
|
r24280 | # func() may return string, generator of strings or arbitrary object such | ||
# as date tuple, but filter does not want generator. | ||||
thing = func(context, mapping, data) | ||||
if isinstance(thing, types.GeneratorType): | ||||
thing = stringify(thing) | ||||
|
r17383 | try: | ||
|
r24280 | return filt(thing) | ||
|
r17383 | except (ValueError, AttributeError, TypeError): | ||
if isinstance(data, tuple): | ||||
dt = data[1] | ||||
else: | ||||
dt = data | ||||
raise util.Abort(_("template filter '%s' is not compatible with " | ||||
"keyword '%s'") % (filt.func_name, dt)) | ||||
|
r13176 | |||
def buildmap(exp, context): | ||||
|
r25001 | func, data = compileexp(exp[1], context, methods) | ||
|
r13176 | ctmpl = gettemplate(exp[2], context) | ||
return (runmap, (func, data, ctmpl)) | ||||
def runmap(context, mapping, data): | ||||
func, data, ctmpl = data | ||||
d = func(context, mapping, data) | ||||
|
r21798 | if callable(d): | ||
|
r17631 | d = d() | ||
|
r13176 | lm = mapping.copy() | ||
for i in d: | ||||
if isinstance(i, dict): | ||||
lm.update(i) | ||||
|
r17991 | lm['originalnode'] = mapping.get('node') | ||
|
r17632 | yield runtemplate(context, lm, ctmpl) | ||
|
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. | ||||
yield i | ||||
def buildfunc(exp, context): | ||||
n = getsymbol(exp[1]) | ||||
|
r25001 | args = [compileexp(x, context, exprmethods) for x in getlist(exp[2])] | ||
|
r14925 | if n in funcs: | ||
f = funcs[n] | ||||
return (f, args) | ||||
|
r13176 | if n in context._filters: | ||
if len(args) != 1: | ||||
raise error.ParseError(_("filter %s expects one argument") % n) | ||||
f = context._filters[n] | ||||
return (runfilter, (args[0][0], args[0][1], f)) | ||||
|
r20857 | raise error.ParseError(_("unknown function '%s'") % n) | ||
|
r13176 | |||
|
r19390 | def date(context, mapping, args): | ||
|
r24586 | """:date(date[, fmt]): Format a date. See :hg:`help dates` for formatting | ||
strings.""" | ||||
|
r19390 | if not (1 <= len(args) <= 2): | ||
|
r23112 | # i18n: "date" is a keyword | ||
|
r19390 | raise error.ParseError(_("date expects one or two arguments")) | ||
date = args[0][0](context, mapping, args[0][1]) | ||||
|
r24903 | fmt = None | ||
|
r19390 | if len(args) == 2: | ||
fmt = stringify(args[1][0](context, mapping, args[1][1])) | ||||
|
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")) | ||||
|
r19390 | |||
|
r22434 | def diff(context, mapping, args): | ||
|
r24586 | """:diff([includepattern [, excludepattern]]): Show a diff, optionally | ||
specifying files to include or exclude.""" | ||||
|
r22434 | if len(args) > 2: | ||
# i18n: "diff" is a keyword | ||||
raise error.ParseError(_("diff expects one, two or no arguments")) | ||||
def getpatterns(i): | ||||
if i < len(args): | ||||
|
r25562 | s = stringify(args[i][0](context, mapping, args[i][1])).strip() | ||
|
r22434 | if s: | ||
return [s] | ||||
return [] | ||||
ctx = mapping['ctx'] | ||||
chunks = ctx.diff(match=ctx.match([], getpatterns(0), getpatterns(1))) | ||||
return ''.join(chunks) | ||||
|
r19390 | def fill(context, mapping, args): | ||
|
r24586 | """:fill(text[, width[, initialident[, hangindent]]]): Fill many | ||
paragraphs with optional indentation. See the "fill" filter.""" | ||||
|
r19390 | if not (1 <= len(args) <= 4): | ||
|
r23112 | # i18n: "fill" is a keyword | ||
|
r19390 | raise error.ParseError(_("fill expects one to four arguments")) | ||
text = stringify(args[0][0](context, mapping, args[0][1])) | ||||
width = 76 | ||||
initindent = '' | ||||
hangindent = '' | ||||
if 2 <= len(args) <= 4: | ||||
try: | ||||
width = int(stringify(args[1][0](context, mapping, args[1][1]))) | ||||
except ValueError: | ||||
|
r23112 | # i18n: "fill" is a keyword | ||
|
r19390 | raise error.ParseError(_("fill expects an integer width")) | ||
try: | ||||
|
r25597 | initindent = stringify(args[2][0](context, mapping, args[2][1])) | ||
hangindent = stringify(args[3][0](context, mapping, args[3][1])) | ||||
|
r19390 | except IndexError: | ||
pass | ||||
return templatefilters.fill(text, width, initindent, hangindent) | ||||
|
r20370 | def pad(context, mapping, args): | ||
|
r24586 | """:pad(text, width[, fillchar=' '[, right=False]]): Pad text with a | ||
fill character.""" | ||||
|
r20370 | if not (2 <= len(args) <= 4): | ||
|
r23112 | # i18n: "pad" is a keyword | ||
|
r20370 | raise error.ParseError(_("pad() expects two to four arguments")) | ||
width = int(args[1][1]) | ||||
text = stringify(args[0][0](context, mapping, args[0][1])) | ||||
right = False | ||||
fillchar = ' ' | ||||
if len(args) > 2: | ||||
fillchar = stringify(args[2][0](context, mapping, args[2][1])) | ||||
if len(args) > 3: | ||||
right = util.parsebool(args[3][1]) | ||||
if right: | ||||
return text.rjust(width, fillchar) | ||||
else: | ||||
return text.ljust(width, fillchar) | ||||
|
r25489 | def indent(context, mapping, args): | ||
""":indent(text, indentchars[, firstline]): 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 | ||||
if present.""" | ||||
if not (2 <= len(args) <= 3): | ||||
# i18n: "indent" is a keyword | ||||
raise error.ParseError(_("indent() expects two or three arguments")) | ||||
text = stringify(args[0][0](context, mapping, args[0][1])) | ||||
indent = stringify(args[1][0](context, mapping, args[1][1])) | ||||
if len(args) == 3: | ||||
firstline = stringify(args[2][0](context, mapping, args[2][1])) | ||||
else: | ||||
firstline = indent | ||||
# the indent function doesn't indent the first line, so we do it here | ||||
return templatefilters.indent(firstline + text, indent) | ||||
|
r18582 | def get(context, mapping, args): | ||
|
r24586 | """:get(dict, key): 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 type.""" | ||||
|
r18582 | if len(args) != 2: | ||
# i18n: "get" is a keyword | ||||
raise error.ParseError(_("get() expects two arguments")) | ||||
dictarg = args[0][0](context, mapping, args[0][1]) | ||||
if not util.safehasattr(dictarg, 'get'): | ||||
# i18n: "get" is a keyword | ||||
raise error.ParseError(_("get() expects a dict as first argument")) | ||||
key = args[1][0](context, mapping, args[1][1]) | ||||
yield dictarg.get(key) | ||||
|
r17636 | def if_(context, mapping, args): | ||
|
r24586 | """:if(expr, then[, else]): Conditionally execute based on the result of | ||
an expression.""" | ||||
|
r17636 | if not (2 <= len(args) <= 3): | ||
|
r17890 | # i18n: "if" is a keyword | ||
|
r17636 | raise error.ParseError(_("if expects two or three arguments")) | ||
test = stringify(args[0][0](context, mapping, args[0][1])) | ||||
if test: | ||||
|
r25597 | yield args[1][0](context, mapping, args[1][1]) | ||
|
r17636 | elif len(args) == 3: | ||
|
r25597 | yield args[2][0](context, mapping, args[2][1]) | ||
|
r17636 | |||
|
r20518 | def ifcontains(context, mapping, args): | ||
|
r24586 | """:ifcontains(search, thing, then[, else]): Conditionally execute based | ||
on whether the item "search" is in "thing".""" | ||||
|
r20518 | if not (3 <= len(args) <= 4): | ||
# i18n: "ifcontains" is a keyword | ||||
raise error.ParseError(_("ifcontains expects three or four arguments")) | ||||
item = stringify(args[0][0](context, mapping, args[0][1])) | ||||
items = args[1][0](context, mapping, args[1][1]) | ||||
|
r24240 | if item in items: | ||
|
r25597 | yield args[2][0](context, mapping, args[2][1]) | ||
|
r20518 | elif len(args) == 4: | ||
|
r25597 | yield args[3][0](context, mapping, args[3][1]) | ||
|
r20518 | |||
|
r17636 | def ifeq(context, mapping, args): | ||
|
r24586 | """:ifeq(expr1, expr2, then[, else]): Conditionally execute based on | ||
whether 2 items are equivalent.""" | ||||
|
r17636 | if not (3 <= len(args) <= 4): | ||
|
r17890 | # i18n: "ifeq" is a keyword | ||
|
r17636 | raise error.ParseError(_("ifeq expects three or four arguments")) | ||
test = stringify(args[0][0](context, mapping, args[0][1])) | ||||
match = stringify(args[1][0](context, mapping, args[1][1])) | ||||
if test == match: | ||||
|
r25597 | yield args[2][0](context, mapping, args[2][1]) | ||
|
r17636 | elif len(args) == 4: | ||
|
r25597 | yield args[3][0](context, mapping, args[3][1]) | ||
|
r17636 | |||
|
r19390 | def join(context, mapping, args): | ||
|
r24586 | """:join(list, sep): Join items in a list with a delimiter.""" | ||
|
r19390 | if not (1 <= len(args) <= 2): | ||
# i18n: "join" is a keyword | ||||
raise error.ParseError(_("join expects one or two arguments")) | ||||
joinset = args[0][0](context, mapping, args[0][1]) | ||||
|
r21798 | if callable(joinset): | ||
|
r19390 | jf = joinset.joinfmt | ||
joinset = [jf(x) for x in joinset()] | ||||
joiner = " " | ||||
if len(args) > 1: | ||||
|
r20662 | joiner = stringify(args[1][0](context, mapping, args[1][1])) | ||
|
r19390 | |||
first = True | ||||
for x in joinset: | ||||
if first: | ||||
first = False | ||||
else: | ||||
yield joiner | ||||
yield x | ||||
|
r18289 | def label(context, mapping, args): | ||
|
r24586 | """:label(label, expr): Apply a label to generated content. Content with | ||
a label applied can result in additional post-processing, such as | ||||
automatic colorization.""" | ||||
|
r18289 | if len(args) != 2: | ||
# i18n: "label" is a keyword | ||||
raise error.ParseError(_("label expects two arguments")) | ||||
# ignore args[0] (the label string) since this is supposed to be a a no-op | ||||
|
r25597 | yield args[1][0](context, mapping, args[1][1]) | ||
|
r18289 | |||
|
r20519 | def revset(context, mapping, args): | ||
|
r24586 | """:revset(query[, formatargs...]): Execute a revision set query. See | ||
:hg:`help revset`.""" | ||||
|
r20519 | if not len(args) > 0: | ||
# i18n: "revset" is a keyword | ||||
raise error.ParseError(_("revset expects one or more arguments")) | ||||
|
r25637 | raw = stringify(args[0][0](context, mapping, args[0][1])) | ||
|
r20519 | ctx = mapping['ctx'] | ||
|
r24337 | repo = ctx.repo() | ||
|
r20519 | |||
|
r22304 | def query(expr): | ||
m = revsetmod.match(repo.ui, expr) | ||||
|
r24114 | return m(repo) | ||
|
r22304 | |||
|
r20519 | if len(args) > 1: | ||
formatargs = list([a[0](context, mapping, a[1]) for a in args[1:]]) | ||||
|
r22304 | revs = query(revsetmod.formatspec(raw, *formatargs)) | ||
|
r20519 | revs = list([str(r) for r in revs]) | ||
else: | ||||
revsetcache = mapping['cache'].setdefault("revsetcache", {}) | ||||
if raw in revsetcache: | ||||
revs = revsetcache[raw] | ||||
else: | ||||
|
r22304 | revs = query(raw) | ||
|
r20519 | revs = list([str(r) for r in revs]) | ||
revsetcache[raw] = revs | ||||
return templatekw.showlist("revision", revs, **mapping) | ||||
|
r18747 | def rstdoc(context, mapping, args): | ||
|
r24586 | """:rstdoc(text, style): Format ReStructuredText.""" | ||
|
r18747 | if len(args) != 2: | ||
# i18n: "rstdoc" is a keyword | ||||
raise error.ParseError(_("rstdoc expects two arguments")) | ||||
text = stringify(args[0][0](context, mapping, args[0][1])) | ||||
style = stringify(args[1][0](context, mapping, args[1][1])) | ||||
|
r19079 | return minirst.format(text, style=style, keep=['verbose']) | ||
|
r18747 | |||
|
r20369 | def shortest(context, mapping, args): | ||
|
r24586 | """:shortest(node, minlength=4): Obtain the shortest representation of | ||
a node.""" | ||||
|
r20369 | if not (1 <= len(args) <= 2): | ||
|
r23112 | # i18n: "shortest" is a keyword | ||
|
r20369 | raise error.ParseError(_("shortest() expects one or two arguments")) | ||
node = stringify(args[0][0](context, mapping, args[0][1])) | ||||
minlength = 4 | ||||
if len(args) > 1: | ||||
minlength = int(args[1][1]) | ||||
cl = mapping['ctx']._repo.changelog | ||||
def isvalid(test): | ||||
try: | ||||
|
r20371 | try: | ||
cl.index.partialmatch(test) | ||||
except AttributeError: | ||||
# Pure mercurial doesn't support partialmatch on the index. | ||||
# Fallback to the slow way. | ||||
if cl._partialmatch(test) is None: | ||||
return False | ||||
|
r20369 | try: | ||
|
r20539 | i = int(test) | ||
# if we are a pure int, then starting with zero will not be | ||||
# confused as a rev; or, obviously, if the int is larger than | ||||
# the value of the tip rev | ||||
if test[0] == '0' or i > len(cl): | ||||
return True | ||||
|
r20369 | return False | ||
except ValueError: | ||||
return True | ||||
except error.RevlogError: | ||||
return False | ||||
shortest = node | ||||
startlength = max(6, minlength) | ||||
length = startlength | ||||
while True: | ||||
test = node[:length] | ||||
if isvalid(test): | ||||
shortest = test | ||||
if length == minlength or length > startlength: | ||||
return shortest | ||||
length -= 1 | ||||
else: | ||||
length += 1 | ||||
if len(shortest) <= length: | ||||
return shortest | ||||
|
r19330 | def strip(context, mapping, args): | ||
|
r24586 | """:strip(text[, chars]): Strip characters from a string.""" | ||
|
r19330 | if not (1 <= len(args) <= 2): | ||
|
r23112 | # i18n: "strip" is a keyword | ||
|
r19330 | raise error.ParseError(_("strip expects one or two arguments")) | ||
|
r20662 | text = stringify(args[0][0](context, mapping, args[0][1])) | ||
|
r19330 | if len(args) == 2: | ||
|
r20662 | chars = stringify(args[1][0](context, mapping, args[1][1])) | ||
|
r19330 | return text.strip(chars) | ||
return text.strip() | ||||
|
r19390 | def sub(context, mapping, args): | ||
|
r24586 | """:sub(pattern, replacement, expression): Perform text substitution | ||
using regular expressions.""" | ||||
|
r19390 | if len(args) != 3: | ||
# i18n: "sub" is a keyword | ||||
raise error.ParseError(_("sub expects three arguments")) | ||||
pat = stringify(args[0][0](context, mapping, args[0][1])) | ||||
rpl = stringify(args[1][0](context, mapping, args[1][1])) | ||||
|
r25597 | src = stringify(args[2][0](context, mapping, args[2][1])) | ||
|
r19390 | yield re.sub(pat, rpl, src) | ||
|
r21821 | def startswith(context, mapping, args): | ||
|
r24586 | """:startswith(pattern, text): Returns the value from the "text" argument | ||
if it begins with the content from the "pattern" argument.""" | ||||
|
r21821 | if len(args) != 2: | ||
|
r21960 | # i18n: "startswith" is a keyword | ||
|
r21821 | raise error.ParseError(_("startswith expects two arguments")) | ||
patn = stringify(args[0][0](context, mapping, args[0][1])) | ||||
text = stringify(args[1][0](context, mapping, args[1][1])) | ||||
if text.startswith(patn): | ||||
return text | ||||
return '' | ||||
|
r21846 | def word(context, mapping, args): | ||
|
r24586 | """:word(number, text[, separator]): Return the nth word from a string.""" | ||
|
r21846 | if not (2 <= len(args) <= 3): | ||
|
r21960 | # i18n: "word" is a keyword | ||
|
r21846 | raise error.ParseError(_("word expects two or three arguments, got %d") | ||
% len(args)) | ||||
|
r24886 | try: | ||
num = int(stringify(args[0][0](context, mapping, args[0][1]))) | ||||
except ValueError: | ||||
# i18n: "word" is a keyword | ||||
|
r25003 | raise error.ParseError(_("word expects an integer index")) | ||
|
r21846 | text = stringify(args[1][0](context, mapping, args[1][1])) | ||
if len(args) == 3: | ||||
splitter = stringify(args[2][0](context, mapping, args[2][1])) | ||||
else: | ||||
splitter = None | ||||
tokens = text.split(splitter) | ||||
if num >= len(tokens): | ||||
return '' | ||||
else: | ||||
return tokens[num] | ||||
|
r25001 | # methods to interpret function arguments or inner expressions (e.g. {_(x)}) | ||
exprmethods = { | ||||
|
r25002 | "integer": lambda e, c: (runinteger, e[1]), | ||
|
r13176 | "string": lambda e, c: (runstring, e[1]), | ||
"symbol": lambda e, c: (runsymbol, e[1]), | ||||
|
r25596 | "template": buildtemplate, | ||
|
r25001 | "group": lambda e, c: compileexp(e[1], c, exprmethods), | ||
|
r13176 | # ".": buildmember, | ||
"|": buildfilter, | ||||
"%": buildmap, | ||||
"func": buildfunc, | ||||
} | ||||
|
r25001 | # methods to interpret top-level template (e.g. {x}, {x|_}, {x % "y"}) | ||
methods = exprmethods.copy() | ||||
|
r25002 | methods["integer"] = exprmethods["symbol"] # '{1}' as variable | ||
|
r25001 | |||
|
r14925 | funcs = { | ||
|
r19390 | "date": date, | ||
|
r22434 | "diff": diff, | ||
|
r19390 | "fill": fill, | ||
|
r18582 | "get": get, | ||
|
r17636 | "if": if_, | ||
|
r20518 | "ifcontains": ifcontains, | ||
|
r17636 | "ifeq": ifeq, | ||
|
r25489 | "indent": indent, | ||
|
r17633 | "join": join, | ||
|
r18582 | "label": label, | ||
|
r20370 | "pad": pad, | ||
|
r20519 | "revset": revset, | ||
|
r18747 | "rstdoc": rstdoc, | ||
|
r20369 | "shortest": shortest, | ||
|
r21821 | "startswith": startswith, | ||
|
r19390 | "strip": strip, | ||
|
r17635 | "sub": sub, | ||
|
r21846 | "word": word, | ||
|
r14925 | } | ||
|
r13176 | # template engine | ||
|
r1901 | |||
|
r8360 | stringify = templatefilters.stringify | ||
|
r7107 | |||
|
r10850 | def _flatten(thing): | ||
'''yield a single stream from a possibly nested set of iterators''' | ||||
if isinstance(thing, str): | ||||
yield thing | ||||
|
r14944 | elif not util.safehasattr(thing, '__iter__'): | ||
|
r11305 | if thing is not None: | ||
|
r10852 | yield str(thing) | ||
else: | ||||
|
r10850 | for i in thing: | ||
if isinstance(i, str): | ||||
yield i | ||||
|
r14944 | elif not util.safehasattr(i, '__iter__'): | ||
|
r10852 | if i is not None: | ||
yield str(i) | ||||
|
r10850 | elif i is not None: | ||
for j in _flatten(i): | ||||
yield j | ||||
|
r24988 | def unquotestring(s): | ||
|
r24987 | '''unwrap quotes''' | ||
if len(s) < 2 or s[0] != s[-1]: | ||||
raise SyntaxError(_('unmatched quotes')) | ||||
|
r25696 | return s[1:-1] | ||
|
r1896 | |||
|
r8218 | class engine(object): | ||
|
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 | ||||
|
r4334 | looks for strings like this: {foo}. it expands {foo} by looking up | ||
|
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|...}.''' | ||||
|
r8218 | def __init__(self, loader, filters={}, defaults={}): | ||
|
r10848 | self._loader = loader | ||
self._filters = filters | ||||
self._defaults = defaults | ||||
self._cache = {} | ||||
|
r8218 | |||
|
r13176 | def _load(self, t): | ||
'''load, parse, and cache a template''' | ||||
if t not in self._cache: | ||||
self._cache[t] = compiletemplate(self._loader(t), self) | ||||
return self._cache[t] | ||||
|
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.''' | ||||
|
r17632 | return _flatten(runtemplate(self, mapping, self._load(t))) | ||
|
r8218 | |||
|
r8361 | engines = {'default': engine} | ||
|
r19125 | def stylelist(): | ||
|
r22634 | paths = templatepaths() | ||
|
r20312 | if not paths: | ||
return _('no templates found, try `hg debuginstall` for more info') | ||||
dirlist = os.listdir(paths[0]) | ||||
|
r19125 | stylelist = [] | ||
for file in dirlist: | ||||
split = file.split(".") | ||||
if split[0] == "map-cmdline": | ||||
stylelist.append(split[1]) | ||||
|
r19127 | return ", ".join(sorted(stylelist)) | ||
|
r19125 | |||
|
r19770 | class TemplateNotFound(util.Abort): | ||
pass | ||||
|
r8218 | class templater(object): | ||
|
r7396 | def __init__(self, mapfile, filters={}, defaults={}, cache={}, | ||
minchunk=1024, maxchunk=65536): | ||||
|
r1909 | '''set up template engine. | ||
mapfile is name of file to read map definitions from. | ||||
filters is dict of functions. each transforms a value into another. | ||||
defaults is dict of default map definitions.''' | ||||
|
r1905 | self.mapfile = mapfile or 'template' | ||
|
r1975 | self.cache = cache.copy() | ||
|
r1896 | self.map = {} | ||
|
r24306 | if mapfile: | ||
self.base = os.path.dirname(mapfile) | ||||
else: | ||||
self.base = '' | ||||
|
r8360 | self.filters = templatefilters.filters.copy() | ||
self.filters.update(filters) | ||||
|
r1964 | self.defaults = defaults | ||
|
r7396 | self.minchunk, self.maxchunk = minchunk, maxchunk | ||
|
r13187 | self.ecache = {} | ||
|
r1896 | |||
|
r1905 | if not mapfile: | ||
return | ||||
|
r6337 | if not os.path.exists(mapfile): | ||
|
r19125 | raise util.Abort(_("style '%s' not found") % mapfile, | ||
hint=_("available styles: %s") % stylelist()) | ||||
|
r6337 | |||
|
r25096 | conf = config.config(includepaths=templatepaths()) | ||
|
r8194 | conf.read(mapfile) | ||
for key, val in conf[''].items(): | ||||
|
r17334 | if not val: | ||
raise SyntaxError(_('%s: missing value') % conf.source('', key)) | ||||
|
r8194 | if val[0] in "'\"": | ||
try: | ||||
|
r24988 | self.cache[key] = unquotestring(val) | ||
|
r25660 | except SyntaxError as inst: | ||
|
r8194 | raise SyntaxError('%s: %s' % | ||
|
r8198 | (conf.source('', key), inst.args[0])) | ||
|
r1896 | else: | ||
|
r8361 | val = 'default', val | ||
if ':' in val[1]: | ||||
val = val[1].split(':', 1) | ||||
self.map[key] = val[0], os.path.join(self.base, val[1]) | ||||
|
r1896 | |||
|
r1899 | def __contains__(self, key): | ||
|
r3637 | return key in self.cache or key in self.map | ||
|
r1899 | |||
|
r8218 | def load(self, t): | ||
|
r6783 | '''Get the template for the given template name. Use a local cache.''' | ||
|
r16686 | if t not in self.cache: | ||
|
r1905 | try: | ||
|
r14168 | self.cache[t] = util.readfile(self.map[t][1]) | ||
|
r25660 | except KeyError as inst: | ||
|
r19770 | raise TemplateNotFound(_('"%s" not in template map') % | ||
inst.args[0]) | ||||
|
r25660 | except IOError as inst: | ||
|
r1905 | raise IOError(inst.args[0], _('template file %s: %s') % | ||
|
r8361 | (self.map[t][1], inst.args[1])) | ||
|
r6783 | return self.cache[t] | ||
|
r1896 | |||
|
r10847 | def __call__(self, t, **mapping): | ||
|
r8361 | ttype = t in self.map and self.map[t][0] or 'default' | ||
|
r13187 | if ttype not in self.ecache: | ||
self.ecache[ttype] = engines[ttype](self.load, | ||||
self.filters, self.defaults) | ||||
proc = self.ecache[ttype] | ||||
|
r8361 | |||
|
r10847 | stream = proc.process(t, mapping) | ||
|
r7396 | if self.minchunk: | ||
stream = util.increasingchunks(stream, min=self.minchunk, | ||||
max=self.maxchunk) | ||||
return stream | ||||
|
r7434 | |||
|
r22634 | def templatepaths(): | ||
'''return locations used for template files.''' | ||||
|
r22636 | pathsrel = ['templates'] | ||
|
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)] | ||||
|
r2189 | |||
|
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 | ||||
|
r2189 | |||
|
r9842 | def stylemap(styles, paths=None): | ||
|
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: | ||||
|
r22634 | paths = templatepaths() | ||
|
r7966 | elif isinstance(paths, str): | ||
|
r8223 | paths = [paths] | ||
|
r7966 | |||
|
r9842 | if isinstance(styles, str): | ||
styles = [styles] | ||||
for style in styles: | ||||
|
r24296 | # only plain name is allowed to honor template paths | ||
if (not style | ||||
or style in (os.curdir, os.pardir) | ||||
or os.sep in style | ||||
or os.altsep and os.altsep in style): | ||||
|
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 | ||||
|
r7966 | |||
raise RuntimeError("No hgweb templates found in %r" % paths) | ||||
|
r24601 | |||
# tell hggettext to extract docstrings from these functions: | ||||
i18nfunctions = funcs.values() | ||||