templatekw: add helper method to generate a template keyword for a namespace

This marks our second feature of the namespace api: automatic template keyword.
This patch adds a method that takes in a namespace and uses the node-to-name
map to output the list of names.

mercurial/templatekw.py

@@ -1,435 +1,443 b''
 # templatekw.py - common changeset template keywords
 #
 # Copyright 2005-2009 Matt Mackall <[e-mail]>
 #
 # 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 __len__(self):
         return len(self.values)
 
 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 showcurrentbookmark(**args):
     """:currentbookmark: String. The active bookmark, if it is
     associated with the changeset"""
     import bookmarks as bookmarks # to avoid circular import issues
     repo = args['repo']
     if bookmarks.iscurrent(repo):
         current = repo._bookmarkcurrent
         if current in args['ctx'].bookmarks():
             return current
     return ''
 
 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 showsubrepos(**args):
     """:subrepos: List of strings. Updated subrepositories in the changeset."""
     ctx = args['ctx']
     substate = ctx.substate
     if not substate:
         return showlist('subrepo', [], **args)
     psubstate = ctx.parents()[0].substate or {}
     subrepos = []
     for sub in substate:
         if sub not in psubstate or substate[sub] != psubstate[sub]:
             subrepos.append(sub) # modified or newly added in ctx
     for sub in psubstate:
         if sub not in substate:
             subrepos.append(sub) # removed in ctx
     return showlist('subrepo', sorted(subrepos), **args)
 
 def showtags(**args):
     """:tags: List of strings. Any tags associated with the changeset."""
     return showlist('tag', args['ctx'].tags(), **args)
 
+def shownames(namespace, **args):
+    """helper method to generate a template keyword for a namespace"""
+    ctx = args['ctx']
+    repo = ctx._repo
+    names = repo.names.names(repo, namespace, ctx.node())
+    return showlist(repo.names.templatename(namespace), names,
+                    plural=namespace, **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,
     'currentbookmark': showcurrentbookmark,
     '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,
     'subrepos': showsubrepos,
     '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()