templater.py
291 lines
| 9.0 KiB
| text/x-python
|
PythonLexer
/ mercurial / templater.py
|
r1909 | # templater.py - template expansion for output | ||
# | ||||
# Copyright 2005, 2006 Matt Mackall <mpm@selenic.com> | ||||
# | ||||
# This software may be used and distributed according to the terms | ||||
# of the GNU General Public License, incorporated herein by reference. | ||||
|
r1896 | from demandload import demandload | ||
|
r1901 | from i18n import gettext as _ | ||
|
r2189 | from node import * | ||
|
r3643 | demandload(globals(), "cgi re sys os time urllib util textwrap") | ||
|
r1901 | |||
|
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 | |||
class templater(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+)*))[#}]") | ||||
|
r1964 | def __init__(self, mapfile, filters={}, defaults={}, cache={}): | ||
|
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 | ||
|
r1896 | |||
|
r1905 | if not mapfile: | ||
return | ||||
|
r1901 | i = 0 | ||
|
r1896 | for l in file(mapfile): | ||
|
r1914 | l = l.strip() | ||
|
r1901 | i += 1 | ||
|
r1914 | if not l or l[0] in '#;': continue | ||
|
r1905 | m = re.match(r'([a-zA-Z_][a-zA-Z0-9_]*)\s*=\s*(.+)$', l) | ||
|
r1896 | if m: | ||
|
r1905 | key, val = m.groups() | ||
if val[0] in "'\"": | ||||
try: | ||||
self.cache[key] = parsestring(val) | ||||
except SyntaxError, inst: | ||||
raise SyntaxError('%s:%s: %s' % | ||||
(mapfile, i, inst.args[0])) | ||||
else: | ||||
self.map[key] = os.path.join(self.base, val) | ||||
|
r1896 | else: | ||
|
r1905 | raise SyntaxError(_("%s:%s: parse error") % (mapfile, i)) | ||
|
r1896 | |||
|
r1899 | def __contains__(self, key): | ||
|
r3637 | return key in self.cache or key in self.map | ||
|
r1899 | |||
|
r1896 | def __call__(self, t, **map): | ||
|
r1909 | '''perform expansion. | ||
t is name of map element to expand. | ||||
map is added elements to use during expansion.''' | ||||
|
r3637 | if not self.cache.has_key(t): | ||
|
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])) | ||||
|
r3638 | tmpl = self.cache[t] | ||
|
r1896 | |||
while tmpl: | ||||
|
r1900 | m = self.template_re.search(tmpl) | ||
|
r3638 | if not m: | ||
yield tmpl | ||||
break | ||||
|
r1896 | |||
|
r3638 | start, end = m.span(0) | ||
key, format, fl = m.groups() | ||||
|
r3636 | |||
|
r3638 | if start: | ||
yield tmpl[:start] | ||||
tmpl = tmpl[end:] | ||||
|
r3636 | |||
|
r3638 | 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(format, **lm) | ||||
else: | ||||
if fl: | ||||
|
r1896 | for f in fl.split("|")[1:]: | ||
|
r3637 | v = self.filters[f](v) | ||
|
r1896 | yield v | ||
|
r1900 | |||
agescales = [("second", 1), | ||||
("minute", 60), | ||||
("hour", 3600), | ||||
("day", 3600 * 24), | ||||
("week", 3600 * 24 * 7), | ||||
("month", 3600 * 24 * 30), | ||||
("year", 3600 * 24 * 365)] | ||||
agescales.reverse() | ||||
|
r1896 | |||
|
r1909 | def age(date): | ||
'''turn a (timestamp, tzoff) tuple into an age string.''' | ||||
|
r1896 | def plural(t, c): | ||
if c == 1: | ||||
return t | ||||
return t + "s" | ||||
def fmt(t, c): | ||||
return "%d %s" % (c, plural(t, c)) | ||||
now = time.time() | ||||
|
r1909 | then = date[0] | ||
|
r1896 | delta = max(1, int(now - then)) | ||
|
r1900 | for t, s in agescales: | ||
|
r1896 | n = delta / s | ||
if n >= 2 or s == 1: | ||||
return fmt(t, n) | ||||
|
r1987 | def stringify(thing): | ||
'''turn nested template iterator into string.''' | ||||
|
r3641 | if hasattr(thing, '__iter__'): | ||
|
r3647 | return "".join([stringify(t) for t in thing if t is not None]) | ||
|
r3641 | return str(thing) | ||
|
r1987 | |||
|
r2470 | para_re = None | ||
space_re = None | ||||
|
r1987 | |||
def fill(text, width): | ||||
'''fill many paragraphs.''' | ||||
|
r2470 | global para_re, space_re | ||
if para_re is None: | ||||
para_re = re.compile('(\n\n|\n\\s*[-*]\\s*)', re.M) | ||||
space_re = re.compile(r' +') | ||||
|
r2535 | |||
|
r1987 | def findparas(): | ||
start = 0 | ||||
while True: | ||||
m = para_re.search(text, start) | ||||
if not m: | ||||
w = len(text) | ||||
while w > start and text[w-1].isspace(): w -= 1 | ||||
yield text[start:w], text[w:] | ||||
break | ||||
yield text[start:m.start(0)], m.group(1) | ||||
start = m.end(1) | ||||
|
r2189 | |||
|
r3633 | return "".join([space_re.sub(' ', textwrap.fill(para, width)) + rest | ||
for para, rest in findparas()]) | ||||
|
r1987 | |||
|
r2559 | def firstline(text): | ||
'''return the first line of text''' | ||||
try: | ||||
return text.splitlines(1)[0].rstrip('\r\n') | ||||
except IndexError: | ||||
return '' | ||||
|
r1906 | def isodate(date): | ||
|
r1987 | '''turn a (timestamp, tzoff) tuple into an iso 8631 date and time.''' | ||
|
r1906 | return util.datestr(date, format='%Y-%m-%d %H:%M') | ||
|
r2519 | def hgdate(date): | ||
'''turn a (timestamp, tzoff) tuple into an hg cset timestamp.''' | ||||
return "%d %d" % date | ||||
|
r1896 | def nl2br(text): | ||
|
r1909 | '''replace raw newlines with xhtml line breaks.''' | ||
|
r1896 | return text.replace('\n', '<br/>\n') | ||
def obfuscate(text): | ||||
|
r3904 | text = unicode(text, util._encoding, 'replace') | ||
|
r1896 | return ''.join(['&#%d;' % ord(c) for c in text]) | ||
|
r1904 | def domain(author): | ||
|
r1909 | '''get domain of author, or empty string if none.''' | ||
|
r1904 | f = author.find('@') | ||
if f == -1: return '' | ||||
author = author[f+1:] | ||||
f = author.find('>') | ||||
if f >= 0: author = author[:f] | ||||
return author | ||||
|
r1987 | def email(author): | ||
'''get email of author.''' | ||||
r = author.find('>') | ||||
if r == -1: r = None | ||||
return author[author.find('<')+1:r] | ||||
|
r2189 | |||
|
r1904 | def person(author): | ||
|
r1909 | '''get name of author, or else username.''' | ||
|
r1904 | f = author.find('<') | ||
if f == -1: return util.shortuser(author) | ||||
return author[:f].rstrip() | ||||
|
r1987 | def shortdate(date): | ||
'''turn (timestamp, tzoff) tuple into iso 8631 date.''' | ||||
return util.datestr(date, format='%Y-%m-%d', timezone=False) | ||||
def indent(text, prefix): | ||||
'''indent each non-empty line of text after first with prefix.''' | ||||
lines = text.splitlines() | ||||
num_lines = len(lines) | ||||
|
r3635 | def indenter(): | ||
for i in xrange(num_lines): | ||||
l = lines[i] | ||||
if i and l.strip(): | ||||
yield prefix | ||||
yield l | ||||
if i < num_lines - 1 or text.endswith('\n'): | ||||
yield '\n' | ||||
return "".join(indenter()) | ||||
|
r1987 | |||
|
r1896 | common_filters = { | ||
|
r1904 | "addbreaks": nl2br, | ||
|
r2191 | "basename": os.path.basename, | ||
|
r1896 | "age": age, | ||
"date": lambda x: util.datestr(x), | ||||
|
r1905 | "domain": domain, | ||
|
r1987 | "email": email, | ||
|
r1904 | "escape": lambda x: cgi.escape(x, True), | ||
|
r1987 | "fill68": lambda x: fill(x, width=68), | ||
"fill76": lambda x: fill(x, width=76), | ||||
|
r2559 | "firstline": firstline, | ||
|
r1987 | "tabindent": lambda x: indent(x, '\t'), | ||
|
r2519 | "hgdate": hgdate, | ||
|
r1906 | "isodate": isodate, | ||
|
r1896 | "obfuscate": obfuscate, | ||
|
r1912 | "permissions": lambda x: x and "-rwxr-xr-x" or "-rw-r--r--", | ||
|
r1904 | "person": person, | ||
"rfc822date": lambda x: util.datestr(x, "%a, %d %b %Y %H:%M:%S"), | ||||
|
r1912 | "short": lambda x: x[:12], | ||
|
r1987 | "shortdate": shortdate, | ||
"stringify": stringify, | ||||
|
r1904 | "strip": lambda x: x.strip(), | ||
|
r1912 | "urlescape": lambda x: urllib.quote(x), | ||
"user": lambda x: util.shortuser(x), | ||||
|
r3462 | "stringescape": lambda x: x.encode('string_escape'), | ||
|
r1896 | } | ||
|
r1897 | |||
|
r1899 | def templatepath(name=None): | ||
|
r1909 | '''return location of template file or directory (if no name). | ||
returns None if not found.''' | ||||
|
r2189 | |||
|
r2001 | # executable version (py2exe) doesn't support __file__ | ||
if hasattr(sys, 'frozen'): | ||||
module = sys.executable | ||||
else: | ||||
module = __file__ | ||||
|
r1899 | for f in 'templates', '../templates': | ||
fl = f.split('/') | ||||
if name: fl.append(name) | ||||
|
r2001 | p = os.path.join(os.path.dirname(module), *fl) | ||
|
r1899 | if (name and os.path.exists(p)) or os.path.isdir(p): | ||
|
r1897 | return os.path.normpath(p) | ||
|
r2189 | |||