templater.py
402 lines
| 12.3 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 _ | ||
|
r10843 | import sys, os | ||
|
r13176 | import util, config, templatefilters, parser, error | ||
# template parsing | ||||
elements = { | ||||
"(": (20, ("group", 1, ")"), ("func", 1, ")")), | ||||
",": (2, None, ("list", 2)), | ||||
"|": (5, None, ("|", 5)), | ||||
"%": (6, None, ("%", 6)), | ||||
")": (0, None, None), | ||||
"symbol": (0, ("symbol",), None), | ||||
"string": (0, ("string",), None), | ||||
"end": (0, None, None), | ||||
} | ||||
def tokenizer(data): | ||||
program, start, end = data | ||||
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) | ||||
elif (c in '"\'' or c == 'r' and | ||||
program[pos:pos + 2] in ("r'", 'r"')): # handle quoted strings | ||||
if c == 'r': | ||||
pos += 1 | ||||
c = program[pos] | ||||
decode = lambda x: x | ||||
else: | ||||
decode = lambda x: x.decode('string-escape') | ||||
pos += 1 | ||||
s = pos | ||||
while pos < end: # find closing quote | ||||
d = program[pos] | ||||
if d == '\\': # skip over escaped characters | ||||
pos += 2 | ||||
continue | ||||
if d == c: | ||||
yield ('string', decode(program[s:pos]), s) | ||||
break | ||||
pos += 1 | ||||
else: | ||||
raise error.ParseError(_("unterminated string"), s) | ||||
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] | ||||
yield ('symbol', sym, s) | ||||
pos -= 1 | ||||
elif c == '}': | ||||
pos += 1 | ||||
break | ||||
else: | ||||
raise error.ParseError(_("syntax error"), pos) | ||||
pos += 1 | ||||
yield ('end', None, pos) | ||||
def compiletemplate(tmpl, context): | ||||
parsed = [] | ||||
pos, stop = 0, len(tmpl) | ||||
p = parser.parser(tokenizer, elements) | ||||
while pos < stop: | ||||
n = tmpl.find('{', pos) | ||||
if n < 0: | ||||
parsed.append(("string", tmpl[pos:])) | ||||
break | ||||
if n > 0 and tmpl[n - 1] == '\\': | ||||
# escaped | ||||
parsed.append(("string", tmpl[pos:n - 1] + "{")) | ||||
pos = n + 1 | ||||
continue | ||||
if n > pos: | ||||
parsed.append(("string", tmpl[pos:n])) | ||||
pd = [tmpl, n + 1, stop] | ||||
|
r13665 | parseres, pos = p.parse(pd) | ||
parsed.append(parseres) | ||||
|
r13176 | |||
return [compileexp(e, context) for e in parsed] | ||||
def compileexp(exp, context): | ||||
t = exp[0] | ||||
if t in methods: | ||||
return methods[t](exp, context) | ||||
raise error.ParseError(_("unknown method '%s'") % t) | ||||
# template evaluation | ||||
def getsymbol(exp): | ||||
if exp[0] == 'symbol': | ||||
return exp[1] | ||||
raise error.ParseError(_("expected a symbol")) | ||||
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): | ||||
if exp[0] == 'string': | ||||
return compiletemplate(exp[1], context) | ||||
if exp[0] == 'symbol': | ||||
return context._load(exp[1]) | ||||
raise error.ParseError(_("expected template specifier")) | ||||
def runstring(context, mapping, data): | ||||
return data | ||||
def runsymbol(context, mapping, key): | ||||
v = mapping.get(key) | ||||
if v is None: | ||||
v = context._defaults.get(key, '') | ||||
|
r14943 | if util.safehasattr(v, '__call__'): | ||
|
r13176 | return v(**mapping) | ||
return v | ||||
def buildfilter(exp, context): | ||||
func, data = compileexp(exp[1], context) | ||||
filt = getfilter(exp[2], context) | ||||
return (runfilter, (func, data, filt)) | ||||
def runfilter(context, mapping, data): | ||||
func, data, filt = data | ||||
|
r17383 | try: | ||
return filt(func(context, mapping, data)) | ||||
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): | ||||
func, data = compileexp(exp[1], context) | ||||
ctmpl = gettemplate(exp[2], context) | ||||
return (runmap, (func, data, ctmpl)) | ||||
def runmap(context, mapping, data): | ||||
func, data, ctmpl = data | ||||
d = func(context, mapping, data) | ||||
lm = mapping.copy() | ||||
for i in d: | ||||
if isinstance(i, dict): | ||||
lm.update(i) | ||||
for f, d in ctmpl: | ||||
yield f(context, lm, d) | ||||
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]) | ||||
args = [compileexp(x, context) 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)) | ||||
methods = { | ||||
"string": lambda e, c: (runstring, e[1]), | ||||
"symbol": lambda e, c: (runsymbol, e[1]), | ||||
"group": lambda e, c: compileexp(e[1], c), | ||||
# ".": buildmember, | ||||
"|": buildfilter, | ||||
"%": buildmap, | ||||
"func": buildfunc, | ||||
} | ||||
|
r14925 | funcs = { | ||
} | ||||
|
r13176 | # template engine | ||
|
r1901 | |||
|
r7107 | path = ['templates', '../templates'] | ||
|
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 | ||||
|
r1902 | def parsestring(s, quoted=True): | ||
|
r1909 | '''parse a string using simple c-like syntax. | ||
string must be in quotes if quoted is True.''' | ||||
|
r1902 | if quoted: | ||
|
r3639 | if len(s) < 2 or s[0] != s[-1]: | ||
raise SyntaxError(_('unmatched quotes')) | ||||
return s[1:-1].decode('string_escape') | ||||
|
r3632 | |||
return s.decode('string_escape') | ||||
|
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.''' | ||||
|
r13176 | return _flatten(func(self, mapping, data) for func, data in | ||
self._load(t)) | ||||
|
r8218 | |||
|
r8361 | engines = {'default': engine} | ||
|
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 = {} | ||
|
r1905 | self.base = (mapfile and os.path.dirname(mapfile)) or '' | ||
|
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): | ||
raise util.Abort(_('style not found: %s') % mapfile) | ||||
|
r8194 | conf = config.config() | ||
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: | ||||
self.cache[key] = parsestring(val) | ||||
except SyntaxError, inst: | ||||
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]) | ||
|
r13175 | except KeyError, inst: | ||
raise util.Abort(_('"%s" not in template map') % inst.args[0]) | ||||
|
r1905 | except IOError, inst: | ||
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 | |||
|
r1899 | def templatepath(name=None): | ||
|
r1909 | '''return location of template file or directory (if no name). | ||
returns None if not found.''' | ||||
|
r7107 | normpaths = [] | ||
|
r2189 | |||
|
r2001 | # executable version (py2exe) doesn't support __file__ | ||
|
r14941 | if util.mainfrozen(): | ||
|
r2001 | module = sys.executable | ||
else: | ||||
module = __file__ | ||||
|
r7107 | for f in path: | ||
if f.startswith('/'): | ||||
p = f | ||||
else: | ||||
fl = f.split('/') | ||||
p = os.path.join(os.path.dirname(module), *fl) | ||||
if name: | ||||
p = os.path.join(p, name) | ||||
if name and os.path.exists(p): | ||||
|
r1897 | return os.path.normpath(p) | ||
|
r7107 | elif os.path.isdir(p): | ||
normpaths.append(os.path.normpath(p)) | ||||
return normpaths | ||||
|
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: | ||||
paths = templatepath() | ||||
elif isinstance(paths, str): | ||||
|
r8223 | paths = [paths] | ||
|
r7966 | |||
|
r9842 | if isinstance(styles, str): | ||
styles = [styles] | ||||
for style in styles: | ||||
if not style: | ||||
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) | ||||