templater.py
215 lines
| 7.0 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 | ||
# GNU General Public License version 2, incorporated herein by reference. | ||||
|
r1909 | |||
|
r3891 | from i18n import _ | ||
|
r5976 | import re, sys, os | ||
|
r8194 | from mercurial import util, config | ||
|
r1901 | |||
|
r7107 | path = ['templates', '../templates'] | ||
|
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|...}.''' | ||||
|
r3638 | template_re = re.compile(r"(?:(?:#(?=[\w\|%]+#))|(?:{(?=[\w\|%]+})))" | ||
r"(\w+)(?:(?:%(\w+))|((?:\|\w+)*))[#}]") | ||||
|
r8218 | def __init__(self, loader, filters={}, defaults={}): | ||
self.loader = loader | ||||
self.filters = filters | ||||
self.defaults = defaults | ||||
def process(self, t, map): | ||||
'''Perform expansion. t is name of map element to expand. map contains | ||||
added elements for use during expansion. Is a generator.''' | ||||
tmpl = self.loader(t) | ||||
iters = [self._process(tmpl, map)] | ||||
while iters: | ||||
try: | ||||
item = iters[0].next() | ||||
except StopIteration: | ||||
iters.pop(0) | ||||
continue | ||||
if isinstance(item, str): | ||||
yield item | ||||
elif item is None: | ||||
yield '' | ||||
elif hasattr(item, '__iter__'): | ||||
iters.insert(0, iter(item)) | ||||
else: | ||||
yield str(item) | ||||
def _process(self, tmpl, map): | ||||
'''Render a template. Returns a generator.''' | ||||
while tmpl: | ||||
m = self.template_re.search(tmpl) | ||||
if not m: | ||||
yield tmpl | ||||
break | ||||
start, end = m.span(0) | ||||
key, format, fl = m.groups() | ||||
if start: | ||||
yield tmpl[:start] | ||||
tmpl = tmpl[end:] | ||||
if key in map: | ||||
v = map[key] | ||||
else: | ||||
v = self.defaults.get(key, "") | ||||
if callable(v): | ||||
v = v(**map) | ||||
if format: | ||||
if not hasattr(v, '__iter__'): | ||||
raise SyntaxError(_("Error expanding '%s%%%s'") | ||||
% (key, format)) | ||||
lm = map.copy() | ||||
for i in v: | ||||
lm.update(i) | ||||
yield self.process(format, lm) | ||||
else: | ||||
if fl: | ||||
for f in fl.split("|")[1:]: | ||||
v = self.filters[f](v) | ||||
yield v | ||||
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 '' | ||
|
r1896 | self.filters = filters | ||
|
r1964 | self.defaults = defaults | ||
|
r7396 | self.minchunk, self.maxchunk = minchunk, maxchunk | ||
|
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(): | ||||
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: | ||
|
r8194 | self.map[key] = os.path.join(self.base, val) | ||
|
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.''' | ||
|
r5915 | if not t in self.cache: | ||
|
r1905 | try: | ||
|
r3637 | self.cache[t] = file(self.map[t]).read() | ||
|
r1905 | except IOError, inst: | ||
raise IOError(inst.args[0], _('template file %s: %s') % | ||||
(self.map[t], inst.args[1])) | ||||
|
r6783 | return self.cache[t] | ||
|
r1896 | |||
|
r6783 | def __call__(self, t, **map): | ||
|
r8218 | proc = engine(self.load, self.filters, self.defaults) | ||
stream = proc.process(t, map) | ||||
|
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__ | ||
if hasattr(sys, 'frozen'): | ||||
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 | |||
|
r7966 | def stylemap(style, paths=None): | ||
"""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 | |||
locations = style and [os.path.join(style, "map"), "map-" + style] or [] | ||||
locations.append("map") | ||||
for path in paths: | ||||
for location in locations: | ||||
mapfile = os.path.join(path, location) | ||||
if os.path.isfile(mapfile): | ||||
return mapfile | ||||
raise RuntimeError("No hgweb templates found in %r" % paths) | ||||
|
r5976 | def stringify(thing): | ||
'''turn nested template iterator into string.''' | ||||
|
r8015 | if hasattr(thing, '__iter__') and not isinstance(thing, str): | ||
|
r5976 | return "".join([stringify(t) for t in thing if t is not None]) | ||
return str(thing) | ||||