# templatekw.py - common changeset template keywords
#
# Copyright 2005-2009 Matt Mackall <mpm@selenic.com>
#
# This software may be used and distributed according to the terms of the
# GNU General Public License version 2 or any later version.
from node import hex
import patch, util, error
import hbisect
# This helper class allows us to handle both:
# "{files}" (legacy command-line-specific list hack) and
# "{files % '{file}\n'}" (hgweb-style with inlining and function support)
class _hybrid(object):
def __init__(self, gen, values, joinfmt=None):
self.gen = gen
self.values = values
if joinfmt:
self.joinfmt = joinfmt
else:
self.joinfmt = lambda x: x.values()[0]
def __iter__(self):
return self.gen
def __call__(self):
for x in self.values:
yield x
def showlist(name, values, plural=None, element=None, **args):
if not element:
element = name
f = _showlist(name, values, plural, **args)
return _hybrid(f, [{element: x} for x in values])
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'.
'''
templ = args['templ']
if plural:
names = plural
else: names = name + 's'
if not values:
noname = 'no_' + names
if noname in templ:
yield templ(noname, **args)
return
if name not in templ:
if isinstance(values[0], str):
yield ' '.join(values)
else:
for v in values:
yield dict(v, **args)
return
startname = 'start_' + names
if startname in templ:
yield templ(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 templ(tag, **vargs)
lastname = 'last_' + name
if lastname in templ:
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 templ:
yield templ(endname, **args)
def getfiles(repo, ctx, revcache):
if 'files' not in revcache:
revcache['files'] = repo.status(ctx.p1().node(), ctx.node())[:3]
return revcache['files']
def getlatesttags(repo, ctx, cache):
'''return date, distance and name for the latest tag of rev'''
if 'latesttags' not in cache:
# Cache mapping from rev to a tuple with tag date, tag
# distance and tag name
cache['latesttags'] = {-1: (0, 0, 'null')}
latesttags = cache['latesttags']
rev = ctx.rev()
todo = [rev]
while todo:
rev = todo.pop()
if rev in latesttags:
continue
ctx = repo[rev]
tags = [t for t in ctx.tags()
if (repo.tagtype(t) and repo.tagtype(t) != 'local')]
if tags:
latesttags[rev] = ctx.date()[0], 0, ':'.join(sorted(tags))
continue
try:
# The tuples are laid out so the right one can be found by
# comparison.
pdate, pdist, ptag = max(
latesttags[p.rev()] for p in ctx.parents())
except KeyError:
# Cache miss - recurse
todo.append(rev)
todo.extend(p.rev() for p in ctx.parents())
continue
latesttags[rev] = pdate, pdist + 1, ptag
return latesttags[rev]
def getrenamedfn(repo, endrev=None):
rcache = {}
if endrev is None:
endrev = len(repo)
def getrenamed(fn, rev):
'''looks up all renames for a file (up to endrev) the first
time the file is given. It indexes on the changerev and only
parses the manifest if linkrev != changerev.
Returns rename info for fn at changerev rev.'''
if fn not in rcache:
rcache[fn] = {}
fl = repo.file(fn)
for i in fl:
lr = fl.linkrev(i)
renamed = fl.renamed(fl.node(i))
rcache[fn][lr] = renamed
if lr >= endrev:
break
if rev in rcache[fn]:
return rcache[fn][rev]
# If linkrev != rev (i.e. rev not found in rcache) fallback to
# filectx logic.
try:
return repo[rev][fn].renamed()
except error.LookupError:
return None
return getrenamed
def showauthor(repo, ctx, templ, **args):
""":author: String. The unmodified author of the changeset."""
return ctx.user()
def showbisect(repo, ctx, templ, **args):
""":bisect: String. The changeset bisection status."""
return hbisect.label(repo, ctx.node())
def showbranch(**args):
""":branch: String. The name of the branch on which the changeset was
committed.
"""
return args['ctx'].branch()
def showbranches(**args):
""":branches: List of strings. The name of the branch on which the
changeset was committed. Will be empty if the branch name was
default.
"""
branch = args['ctx'].branch()
if branch != 'default':
return showlist('branch', [branch], plural='branches', **args)
return showlist('branch', [], plural='branches', **args)
def showbookmarks(**args):
""":bookmarks: List of strings. Any bookmarks associated with the
changeset.
"""
repo = args['ctx']._repo
bookmarks = args['ctx'].bookmarks()
hybrid = showlist('bookmark', bookmarks, **args)
for value in hybrid.values:
value['current'] = repo._bookmarkcurrent
return hybrid
def showchildren(**args):
""":children: List of strings. The children of the changeset."""
ctx = args['ctx']
childrevs = ['%d:%s' % (cctx, cctx) for cctx in ctx.children()]
return showlist('children', childrevs, element='child', **args)
def showdate(repo, ctx, templ, **args):
""":date: Date information. The date when the changeset was committed."""
return ctx.date()
def showdescription(repo, ctx, templ, **args):
""":desc: String. The text of the changeset description."""
return ctx.description().strip()
def showdiffstat(repo, ctx, templ, **args):
""":diffstat: String. Statistics of changes with the following format:
"modified files: +added/-removed lines"
"""
stats = patch.diffstatdata(util.iterlines(ctx.diff()))
maxname, maxtotal, adds, removes, binary = patch.diffstatsum(stats)
return '%s: +%s/-%s' % (len(stats), adds, removes)
def showextras(**args):
""":extras: List of dicts with key, value entries of the 'extras'
field of this changeset."""
extras = args['ctx'].extra()
c = [{'key': x[0], 'value': x[1]} for x in sorted(extras.items())]
f = _showlist('extra', c, plural='extras', **args)
return _hybrid(f, c, lambda x: '%s=%s' % (x['key'], x['value']))
def showfileadds(**args):
""":file_adds: List of strings. Files added by this changeset."""
repo, ctx, revcache = args['repo'], args['ctx'], args['revcache']
return showlist('file_add', getfiles(repo, ctx, revcache)[1],
element='file', **args)
def showfilecopies(**args):
""":file_copies: List of strings. Files copied in this changeset with
their sources.
"""
cache, ctx = args['cache'], args['ctx']
copies = args['revcache'].get('copies')
if copies is None:
if 'getrenamed' not in cache:
cache['getrenamed'] = getrenamedfn(args['repo'])
copies = []
getrenamed = cache['getrenamed']
for fn in ctx.files():
rename = getrenamed(fn, ctx.rev())
if rename:
copies.append((fn, rename[0]))
c = [{'name': x[0], 'source': x[1]} for x in copies]
f = _showlist('file_copy', c, plural='file_copies', **args)
return _hybrid(f, c, lambda x: '%s (%s)' % (x['name'], x['source']))
# showfilecopiesswitch() displays file copies only if copy records are
# provided before calling the templater, usually with a --copies
# command line switch.
def showfilecopiesswitch(**args):
""":file_copies_switch: List of strings. Like "file_copies" but displayed
only if the --copied switch is set.
"""
copies = args['revcache'].get('copies') or []
c = [{'name': x[0], 'source': x[1]} for x in copies]
f = _showlist('file_copy', c, plural='file_copies', **args)
return _hybrid(f, c, lambda x: '%s (%s)' % (x['name'], x['source']))
def showfiledels(**args):
""":file_dels: List of strings. Files removed by this changeset."""
repo, ctx, revcache = args['repo'], args['ctx'], args['revcache']
return showlist('file_del', getfiles(repo, ctx, revcache)[2],
element='file', **args)
def showfilemods(**args):
""":file_mods: List of strings. Files modified by this changeset."""
repo, ctx, revcache = args['repo'], args['ctx'], args['revcache']
return showlist('file_mod', getfiles(repo, ctx, revcache)[0],
element='file', **args)
def showfiles(**args):
""":files: List of strings. All files modified, added, or removed by this
changeset.
"""
return showlist('file', args['ctx'].files(), **args)
def showlatesttag(repo, ctx, templ, cache, **args):
""":latesttag: String. Most recent global tag in the ancestors of this
changeset.
"""
return getlatesttags(repo, ctx, cache)[2]
def showlatesttagdistance(repo, ctx, templ, cache, **args):
""":latesttagdistance: Integer. Longest path to the latest tag."""
return getlatesttags(repo, ctx, cache)[1]
def showmanifest(**args):
repo, ctx, templ = args['repo'], args['ctx'], args['templ']
args = args.copy()
args.update({'rev': repo.manifest.rev(ctx.changeset()[0]),
'node': hex(ctx.changeset()[0])})
return templ('manifest', **args)
def shownode(repo, ctx, templ, **args):
""":node: String. The changeset identification hash, as a 40 hexadecimal
digit string.
"""
return ctx.hex()
def showp1rev(repo, ctx, templ, **args):
""":p1rev: Integer. The repository-local revision number of the changeset's
first parent, or -1 if the changeset has no parents."""
return ctx.p1().rev()
def showp2rev(repo, ctx, templ, **args):
""":p2rev: Integer. The repository-local revision number of the changeset's
second parent, or -1 if the changeset has no second parent."""
return ctx.p2().rev()
def showp1node(repo, ctx, templ, **args):
""":p1node: String. The identification hash of the changeset's first parent,
as a 40 digit hexadecimal string. If the changeset has no parents, all
digits are 0."""
return ctx.p1().hex()
def showp2node(repo, ctx, templ, **args):
""":p2node: String. The identification hash of the changeset's second
parent, as a 40 digit hexadecimal string. If the changeset has no second
parent, all digits are 0."""
return ctx.p2().hex()
def showphase(repo, ctx, templ, **args):
""":phase: String. The changeset phase name."""
return ctx.phasestr()
def showphaseidx(repo, ctx, templ, **args):
""":phaseidx: Integer. The changeset phase index."""
return ctx.phase()
def showrev(repo, ctx, templ, **args):
""":rev: Integer. The repository-local changeset revision number."""
return ctx.rev()
def showtags(**args):
""":tags: List of strings. Any tags associated with the changeset."""
return showlist('tag', args['ctx'].tags(), **args)
# keywords are callables like:
# fn(repo, ctx, templ, cache, revcache, **args)
# with:
# repo - current repository instance
# ctx - the changectx being displayed
# templ - the templater instance
# cache - a cache dictionary for the whole templater run
# revcache - a cache dictionary for the current revision
keywords = {
'author': showauthor,
'bisect': showbisect,
'branch': showbranch,
'branches': showbranches,
'bookmarks': showbookmarks,
'children': showchildren,
'date': showdate,
'desc': showdescription,
'diffstat': showdiffstat,
'extras': showextras,
'file_adds': showfileadds,
'file_copies': showfilecopies,
'file_copies_switch': showfilecopiesswitch,
'file_dels': showfiledels,
'file_mods': showfilemods,
'files': showfiles,
'latesttag': showlatesttag,
'latesttagdistance': showlatesttagdistance,
'manifest': showmanifest,
'node': shownode,
'p1rev': showp1rev,
'p1node': showp1node,
'p2rev': showp2rev,
'p2node': showp2node,
'phase': showphase,
'phaseidx': showphaseidx,
'rev': showrev,
'tags': showtags,
}
def _showparents(**args):
""":parents: List of strings. The parents of the changeset in "rev:node"
format. If the changeset has only one "natural" parent (the predecessor
revision) nothing is shown."""
pass
dockeywords = {
'parents': _showparents,
}
dockeywords.update(keywords)
del dockeywords['branches']
# tell hggettext to extract docstrings from these functions:
i18nfunctions = dockeywords.values()