|
|
# 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.
|
|
|
|
|
|
from demandload import demandload
|
|
|
from i18n import gettext as _
|
|
|
from node import *
|
|
|
demandload(globals(), "cStringIO cgi re sys os time urllib util textwrap")
|
|
|
|
|
|
def parsestring(s, quoted=True):
|
|
|
'''parse a string using simple c-like syntax.
|
|
|
string must be in quotes if quoted is True.'''
|
|
|
if quoted:
|
|
|
if len(s) < 2 or s[0] != s[-1]:
|
|
|
raise SyntaxError(_('unmatched quotes'))
|
|
|
return s[1:-1].decode('string_escape')
|
|
|
|
|
|
return s.decode('string_escape')
|
|
|
|
|
|
class templater(object):
|
|
|
'''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
|
|
|
looks for atrings like this: {foo}. it expands {foo} by looking up
|
|
|
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|...}.'''
|
|
|
|
|
|
template_re = re.compile(r"(?:(?:#(?=[\w\|%]+#))|(?:{(?=[\w\|%]+})))"
|
|
|
r"(\w+)(?:(?:%(\w+))|((?:\|\w+)*))[#}]")
|
|
|
|
|
|
def __init__(self, mapfile, filters={}, defaults={}, cache={}):
|
|
|
'''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.'''
|
|
|
self.mapfile = mapfile or 'template'
|
|
|
self.cache = cache.copy()
|
|
|
self.map = {}
|
|
|
self.base = (mapfile and os.path.dirname(mapfile)) or ''
|
|
|
self.filters = filters
|
|
|
self.defaults = defaults
|
|
|
|
|
|
if not mapfile:
|
|
|
return
|
|
|
i = 0
|
|
|
for l in file(mapfile):
|
|
|
l = l.strip()
|
|
|
i += 1
|
|
|
if not l or l[0] in '#;': continue
|
|
|
m = re.match(r'([a-zA-Z_][a-zA-Z0-9_]*)\s*=\s*(.+)$', l)
|
|
|
if m:
|
|
|
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)
|
|
|
else:
|
|
|
raise SyntaxError(_("%s:%s: parse error") % (mapfile, i))
|
|
|
|
|
|
def __contains__(self, key):
|
|
|
return key in self.cache or key in self.map
|
|
|
|
|
|
def __call__(self, t, **map):
|
|
|
'''perform expansion.
|
|
|
t is name of map element to expand.
|
|
|
map is added elements to use during expansion.'''
|
|
|
if not self.cache.has_key(t):
|
|
|
try:
|
|
|
self.cache[t] = file(self.map[t]).read()
|
|
|
except IOError, inst:
|
|
|
raise IOError(inst.args[0], _('template file %s: %s') %
|
|
|
(self.map[t], inst.args[1]))
|
|
|
tmpl = self.cache[t]
|
|
|
|
|
|
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(format, **lm)
|
|
|
else:
|
|
|
if fl:
|
|
|
for f in fl.split("|")[1:]:
|
|
|
v = self.filters[f](v)
|
|
|
yield v
|
|
|
|
|
|
agescales = [("second", 1),
|
|
|
("minute", 60),
|
|
|
("hour", 3600),
|
|
|
("day", 3600 * 24),
|
|
|
("week", 3600 * 24 * 7),
|
|
|
("month", 3600 * 24 * 30),
|
|
|
("year", 3600 * 24 * 365)]
|
|
|
|
|
|
agescales.reverse()
|
|
|
|
|
|
def age(date):
|
|
|
'''turn a (timestamp, tzoff) tuple into an age string.'''
|
|
|
|
|
|
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()
|
|
|
then = date[0]
|
|
|
delta = max(1, int(now - then))
|
|
|
|
|
|
for t, s in agescales:
|
|
|
n = delta / s
|
|
|
if n >= 2 or s == 1:
|
|
|
return fmt(t, n)
|
|
|
|
|
|
def stringify(thing):
|
|
|
'''turn nested template iterator into string.'''
|
|
|
if hasattr(thing, '__iter__'):
|
|
|
return "".join([stringify(t) for t in thing])
|
|
|
return str(thing)
|
|
|
|
|
|
para_re = None
|
|
|
space_re = None
|
|
|
|
|
|
def fill(text, width):
|
|
|
'''fill many paragraphs.'''
|
|
|
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' +')
|
|
|
|
|
|
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)
|
|
|
|
|
|
return "".join([space_re.sub(' ', textwrap.fill(para, width)) + rest
|
|
|
for para, rest in findparas()])
|
|
|
|
|
|
def firstline(text):
|
|
|
'''return the first line of text'''
|
|
|
try:
|
|
|
return text.splitlines(1)[0].rstrip('\r\n')
|
|
|
except IndexError:
|
|
|
return ''
|
|
|
|
|
|
def isodate(date):
|
|
|
'''turn a (timestamp, tzoff) tuple into an iso 8631 date and time.'''
|
|
|
return util.datestr(date, format='%Y-%m-%d %H:%M')
|
|
|
|
|
|
def hgdate(date):
|
|
|
'''turn a (timestamp, tzoff) tuple into an hg cset timestamp.'''
|
|
|
return "%d %d" % date
|
|
|
|
|
|
def nl2br(text):
|
|
|
'''replace raw newlines with xhtml line breaks.'''
|
|
|
return text.replace('\n', '<br/>\n')
|
|
|
|
|
|
def obfuscate(text):
|
|
|
text = unicode(text, 'utf-8', 'replace')
|
|
|
return ''.join(['&#%d;' % ord(c) for c in text])
|
|
|
|
|
|
def domain(author):
|
|
|
'''get domain of author, or empty string if none.'''
|
|
|
f = author.find('@')
|
|
|
if f == -1: return ''
|
|
|
author = author[f+1:]
|
|
|
f = author.find('>')
|
|
|
if f >= 0: author = author[:f]
|
|
|
return author
|
|
|
|
|
|
def email(author):
|
|
|
'''get email of author.'''
|
|
|
r = author.find('>')
|
|
|
if r == -1: r = None
|
|
|
return author[author.find('<')+1:r]
|
|
|
|
|
|
def person(author):
|
|
|
'''get name of author, or else username.'''
|
|
|
f = author.find('<')
|
|
|
if f == -1: return util.shortuser(author)
|
|
|
return author[:f].rstrip()
|
|
|
|
|
|
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)
|
|
|
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())
|
|
|
|
|
|
common_filters = {
|
|
|
"addbreaks": nl2br,
|
|
|
"basename": os.path.basename,
|
|
|
"age": age,
|
|
|
"date": lambda x: util.datestr(x),
|
|
|
"domain": domain,
|
|
|
"email": email,
|
|
|
"escape": lambda x: cgi.escape(x, True),
|
|
|
"fill68": lambda x: fill(x, width=68),
|
|
|
"fill76": lambda x: fill(x, width=76),
|
|
|
"firstline": firstline,
|
|
|
"tabindent": lambda x: indent(x, '\t'),
|
|
|
"hgdate": hgdate,
|
|
|
"isodate": isodate,
|
|
|
"obfuscate": obfuscate,
|
|
|
"permissions": lambda x: x and "-rwxr-xr-x" or "-rw-r--r--",
|
|
|
"person": person,
|
|
|
"rfc822date": lambda x: util.datestr(x, "%a, %d %b %Y %H:%M:%S"),
|
|
|
"short": lambda x: x[:12],
|
|
|
"shortdate": shortdate,
|
|
|
"stringify": stringify,
|
|
|
"strip": lambda x: x.strip(),
|
|
|
"urlescape": lambda x: urllib.quote(x),
|
|
|
"user": lambda x: util.shortuser(x),
|
|
|
"stringescape": lambda x: x.encode('string_escape'),
|
|
|
}
|
|
|
|
|
|
def templatepath(name=None):
|
|
|
'''return location of template file or directory (if no name).
|
|
|
returns None if not found.'''
|
|
|
|
|
|
# executable version (py2exe) doesn't support __file__
|
|
|
if hasattr(sys, 'frozen'):
|
|
|
module = sys.executable
|
|
|
else:
|
|
|
module = __file__
|
|
|
for f in 'templates', '../templates':
|
|
|
fl = f.split('/')
|
|
|
if name: fl.append(name)
|
|
|
p = os.path.join(os.path.dirname(module), *fl)
|
|
|
if (name and os.path.exists(p)) or os.path.isdir(p):
|
|
|
return os.path.normpath(p)
|
|
|
|
|
|
class changeset_templater(object):
|
|
|
'''format changeset information.'''
|
|
|
|
|
|
def __init__(self, ui, repo, mapfile, dest=None):
|
|
|
self.t = templater(mapfile, common_filters,
|
|
|
cache={'parent': '{rev}:{node|short} ',
|
|
|
'manifest': '{rev}:{node|short}',
|
|
|
'filecopy': '{name} ({source})'})
|
|
|
self.ui = ui
|
|
|
self.dest = dest
|
|
|
self.repo = repo
|
|
|
|
|
|
def use_template(self, t):
|
|
|
'''set template string to use'''
|
|
|
self.t.cache['changeset'] = t
|
|
|
|
|
|
def show(self, rev=0, changenode=None, brinfo=None, copies=[], **props):
|
|
|
'''show a single changeset or file revision'''
|
|
|
log = self.repo.changelog
|
|
|
if changenode is None:
|
|
|
changenode = log.node(rev)
|
|
|
elif not rev:
|
|
|
rev = log.rev(changenode)
|
|
|
|
|
|
changes = log.read(changenode)
|
|
|
|
|
|
def showlist(name, values, plural=None, **args):
|
|
|
'''expand set of values.
|
|
|
name is name of key in template map.
|
|
|
values is list of strings or dicts.
|
|
|
plural is plural of name, if not simply name + 's'.
|
|
|
|
|
|
expansion works like this, given name 'foo'.
|
|
|
|
|
|
if values is empty, expand 'no_foos'.
|
|
|
|
|
|
if 'foo' not in template map, return values as a string,
|
|
|
joined by space.
|
|
|
|
|
|
expand 'start_foos'.
|
|
|
|
|
|
for each value, expand 'foo'. if 'last_foo' in template
|
|
|
map, expand it instead of 'foo' for last key.
|
|
|
|
|
|
expand 'end_foos'.
|
|
|
'''
|
|
|
if plural: names = plural
|
|
|
else: names = name + 's'
|
|
|
if not values:
|
|
|
noname = 'no_' + names
|
|
|
if noname in self.t:
|
|
|
yield self.t(noname, **args)
|
|
|
return
|
|
|
if name not in self.t:
|
|
|
if isinstance(values[0], str):
|
|
|
yield ' '.join(values)
|
|
|
else:
|
|
|
for v in values:
|
|
|
yield dict(v, **args)
|
|
|
return
|
|
|
startname = 'start_' + names
|
|
|
if startname in self.t:
|
|
|
yield self.t(startname, **args)
|
|
|
vargs = args.copy()
|
|
|
def one(v, tag=name):
|
|
|
try:
|
|
|
vargs.update(v)
|
|
|
except (AttributeError, ValueError):
|
|
|
try:
|
|
|
for a, b in v:
|
|
|
vargs[a] = b
|
|
|
except ValueError:
|
|
|
vargs[name] = v
|
|
|
return self.t(tag, **vargs)
|
|
|
lastname = 'last_' + name
|
|
|
if lastname in self.t:
|
|
|
last = values.pop()
|
|
|
else:
|
|
|
last = None
|
|
|
for v in values:
|
|
|
yield one(v)
|
|
|
if last is not None:
|
|
|
yield one(last, tag=lastname)
|
|
|
endname = 'end_' + names
|
|
|
if endname in self.t:
|
|
|
yield self.t(endname, **args)
|
|
|
|
|
|
def showbranches(**args):
|
|
|
branch = changes[5].get("branch")
|
|
|
if branch:
|
|
|
yield showlist('branch', [branch], plural='branches', **args)
|
|
|
# add old style branches if requested
|
|
|
if brinfo and changenode in brinfo:
|
|
|
for x in showlist('branch', brinfo[changenode],
|
|
|
plural='branches', **args):
|
|
|
yield x
|
|
|
|
|
|
if self.ui.debugflag:
|
|
|
def showmanifest(**args):
|
|
|
args = args.copy()
|
|
|
args.update(dict(rev=self.repo.manifest.rev(changes[0]),
|
|
|
node=hex(changes[0])))
|
|
|
yield self.t('manifest', **args)
|
|
|
else:
|
|
|
showmanifest = ''
|
|
|
|
|
|
def showparents(**args):
|
|
|
parents = [[('rev', log.rev(p)), ('node', hex(p))]
|
|
|
for p in log.parents(changenode)
|
|
|
if self.ui.debugflag or p != nullid]
|
|
|
if (not self.ui.debugflag and len(parents) == 1 and
|
|
|
parents[0][0][1] == rev - 1):
|
|
|
return
|
|
|
for x in showlist('parent', parents, **args):
|
|
|
yield x
|
|
|
|
|
|
def showtags(**args):
|
|
|
for x in showlist('tag', self.repo.nodetags(changenode), **args):
|
|
|
yield x
|
|
|
|
|
|
def showextras(**args):
|
|
|
extras = changes[5].items()
|
|
|
extras.sort()
|
|
|
for key, value in extras:
|
|
|
args = args.copy()
|
|
|
args.update(dict(key=key, value=value))
|
|
|
yield self.t('extra', **args)
|
|
|
|
|
|
if self.ui.debugflag:
|
|
|
files = self.repo.status(log.parents(changenode)[0], changenode)[:3]
|
|
|
def showfiles(**args):
|
|
|
for x in showlist('file', files[0], **args): yield x
|
|
|
def showadds(**args):
|
|
|
for x in showlist('file_add', files[1], **args): yield x
|
|
|
def showdels(**args):
|
|
|
for x in showlist('file_del', files[2], **args): yield x
|
|
|
else:
|
|
|
def showfiles(**args):
|
|
|
for x in showlist('file', changes[3], **args): yield x
|
|
|
showadds = ''
|
|
|
showdels = ''
|
|
|
|
|
|
copies = [{'name': x[0], 'source': x[1]}
|
|
|
for x in copies]
|
|
|
def showcopies(**args):
|
|
|
for x in showlist('file_copy', copies, plural='file_copies',
|
|
|
**args):
|
|
|
yield x
|
|
|
|
|
|
defprops = {
|
|
|
'author': changes[1],
|
|
|
'branches': showbranches,
|
|
|
'date': changes[2],
|
|
|
'desc': changes[4],
|
|
|
'file_adds': showadds,
|
|
|
'file_dels': showdels,
|
|
|
'files': showfiles,
|
|
|
'file_copies': showcopies,
|
|
|
'manifest': showmanifest,
|
|
|
'node': hex(changenode),
|
|
|
'parents': showparents,
|
|
|
'rev': rev,
|
|
|
'tags': showtags,
|
|
|
'extras': showextras,
|
|
|
}
|
|
|
props = props.copy()
|
|
|
props.update(defprops)
|
|
|
|
|
|
try:
|
|
|
dest = self.dest or self.ui
|
|
|
if self.ui.debugflag and 'header_debug' in self.t:
|
|
|
key = 'header_debug'
|
|
|
elif self.ui.quiet and 'header_quiet' in self.t:
|
|
|
key = 'header_quiet'
|
|
|
elif self.ui.verbose and 'header_verbose' in self.t:
|
|
|
key = 'header_verbose'
|
|
|
elif 'header' in self.t:
|
|
|
key = 'header'
|
|
|
else:
|
|
|
key = ''
|
|
|
if key:
|
|
|
dest.write_header(stringify(self.t(key, **props)))
|
|
|
if self.ui.debugflag and 'changeset_debug' in self.t:
|
|
|
key = 'changeset_debug'
|
|
|
elif self.ui.quiet and 'changeset_quiet' in self.t:
|
|
|
key = 'changeset_quiet'
|
|
|
elif self.ui.verbose and 'changeset_verbose' in self.t:
|
|
|
key = 'changeset_verbose'
|
|
|
else:
|
|
|
key = 'changeset'
|
|
|
dest.write(stringify(self.t(key, **props)))
|
|
|
except KeyError, inst:
|
|
|
raise util.Abort(_("%s: no key named '%s'") % (self.t.mapfile,
|
|
|
inst.args[0]))
|
|
|
except SyntaxError, inst:
|
|
|
raise util.Abort(_('%s: %s') % (self.t.mapfile, inst.args[0]))
|
|
|
|
|
|
class stringio(object):
|
|
|
'''wrap cStringIO for use by changeset_templater.'''
|
|
|
def __init__(self):
|
|
|
self.fp = cStringIO.StringIO()
|
|
|
|
|
|
def write(self, *args):
|
|
|
for a in args:
|
|
|
self.fp.write(a)
|
|
|
|
|
|
write_header = write
|
|
|
|
|
|
def __getattr__(self, key):
|
|
|
return getattr(self.fp, key)
|
|
|
|