hggettext: handle i18nfunctions declaration for docstrings translations

hgext/bookmarks.py

@@ -1,568 +1,571
 # Mercurial extension to provide the 'hg bookmark' command
 #
 # Copyright 2008 David Soria Parra <[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.
 
 '''track a line of development with movable markers
 
 Bookmarks are local movable markers to changesets. Every bookmark
 points to a changeset identified by its hash. If you commit a
 changeset that is based on a changeset that has a bookmark on it, the
 bookmark shifts to the new changeset.
 
 It is possible to use bookmark names in every revision lookup (e.g.
 :hg:`merge`, :hg:`update`).
 
 By default, when several bookmarks point to the same changeset, they
 will all move forward together. It is possible to obtain a more
 git-like experience by adding the following configuration option to
 your configuration file::
 
   [bookmarks]
   track.current = True
 
 This will cause Mercurial to track the bookmark that you are currently
 using, and only update it. This is similar to git's approach to
 branching.
 '''
 
 from mercurial.i18n import _
 from mercurial.node import nullid, nullrev, bin, hex, short
 from mercurial import util, commands, repair, extensions, pushkey, hg, url
 from mercurial import revset
 import os
 
 def write(repo):
     '''Write bookmarks
 
     Write the given bookmark => hash dictionary to the .hg/bookmarks file
     in a format equal to those of localtags.
 
     We also store a backup of the previous state in undo.bookmarks that
     can be copied back on rollback.
     '''
     refs = repo._bookmarks
     if os.path.exists(repo.join('bookmarks')):
         util.copyfile(repo.join('bookmarks'), repo.join('undo.bookmarks'))
     if repo._bookmarkcurrent not in refs:
         setcurrent(repo, None)
     wlock = repo.wlock()
     try:
         file = repo.opener('bookmarks', 'w', atomictemp=True)
         for refspec, node in refs.iteritems():
             file.write("%s %s\n" % (hex(node), refspec))
         file.rename()
 
         # touch 00changelog.i so hgweb reloads bookmarks (no lock needed)
         try:
             os.utime(repo.sjoin('00changelog.i'), None)
         except OSError:
             pass
 
     finally:
         wlock.release()
 
 def setcurrent(repo, mark):
     '''Set the name of the bookmark that we are currently on
 
     Set the name of the bookmark that we are on (hg update <bookmark>).
     The name is recorded in .hg/bookmarks.current
     '''
     current = repo._bookmarkcurrent
     if current == mark:
         return
 
     refs = repo._bookmarks
 
     # do not update if we do update to a rev equal to the current bookmark
     if (mark and mark not in refs and
         current and refs[current] == repo.changectx('.').node()):
         return
     if mark not in refs:
         mark = ''
     wlock = repo.wlock()
     try:
         file = repo.opener('bookmarks.current', 'w', atomictemp=True)
         file.write(mark)
         file.rename()
     finally:
         wlock.release()
     repo._bookmarkcurrent = mark
 
 def bookmark(ui, repo, mark=None, rev=None, force=False, delete=False, rename=None):
     '''track a line of development with movable markers
 
     Bookmarks are pointers to certain commits that move when
     committing. Bookmarks are local. They can be renamed, copied and
     deleted. It is possible to use bookmark names in :hg:`merge` and
     :hg:`update` to merge and update respectively to a given bookmark.
 
     You can use :hg:`bookmark NAME` to set a bookmark on the working
     directory's parent revision with the given name. If you specify
     a revision using -r REV (where REV may be an existing bookmark),
     the bookmark is assigned to that revision.
 
     Bookmarks can be pushed and pulled between repositories (see :hg:`help
     push` and :hg:`help pull`). This requires the bookmark extension to be
     enabled for both the local and remote repositories.
     '''
     hexfn = ui.debugflag and hex or short
     marks = repo._bookmarks
     cur   = repo.changectx('.').node()
 
     if rename:
         if rename not in marks:
             raise util.Abort(_("a bookmark of this name does not exist"))
         if mark in marks and not force:
             raise util.Abort(_("a bookmark of the same name already exists"))
         if mark is None:
             raise util.Abort(_("new bookmark name required"))
         marks[mark] = marks[rename]
         del marks[rename]
         if repo._bookmarkcurrent == rename:
             setcurrent(repo, mark)
         write(repo)
         return
 
     if delete:
         if mark is None:
             raise util.Abort(_("bookmark name required"))
         if mark not in marks:
             raise util.Abort(_("a bookmark of this name does not exist"))
         if mark == repo._bookmarkcurrent:
             setcurrent(repo, None)
         del marks[mark]
         write(repo)
         return
 
     if mark != None:
         if "\n" in mark:
             raise util.Abort(_("bookmark name cannot contain newlines"))
         mark = mark.strip()
         if not mark:
             raise util.Abort(_("bookmark names cannot consist entirely of "
                                "whitespace"))
         if mark in marks and not force:
             raise util.Abort(_("a bookmark of the same name already exists"))
         if ((mark in repo.branchtags() or mark == repo.dirstate.branch())
             and not force):
             raise util.Abort(
                 _("a bookmark cannot have the name of an existing branch"))
         if rev:
             marks[mark] = repo.lookup(rev)
         else:
             marks[mark] = repo.changectx('.').node()
         setcurrent(repo, mark)
         write(repo)
         return
 
     if mark is None:
         if rev:
             raise util.Abort(_("bookmark name required"))
         if len(marks) == 0:
             ui.status(_("no bookmarks set\n"))
         else:
             for bmark, n in marks.iteritems():
                 if ui.configbool('bookmarks', 'track.current'):
                     current = repo._bookmarkcurrent
                     if bmark == current and n == cur:
                         prefix, label = '*', 'bookmarks.current'
                     else:
                         prefix, label = ' ', ''
                 else:
                     if n == cur:
                         prefix, label = '*', 'bookmarks.current'
                     else:
                         prefix, label = ' ', ''
 
                 if ui.quiet:
                     ui.write("%s\n" % bmark, label=label)
                 else:
                     ui.write(" %s %-25s %d:%s\n" % (
                         prefix, bmark, repo.changelog.rev(n), hexfn(n)),
                         label=label)
         return
 
 def _revstostrip(changelog, node):
     srev = changelog.rev(node)
     tostrip = [srev]
     saveheads = []
     for r in xrange(srev, len(changelog)):
         parents = changelog.parentrevs(r)
         if parents[0] in tostrip or parents[1] in tostrip:
             tostrip.append(r)
             if parents[1] != nullrev:
                 for p in parents:
                     if p not in tostrip and p > srev:
                         saveheads.append(p)
     return [r for r in tostrip if r not in saveheads]
 
 def strip(oldstrip, ui, repo, node, backup="all"):
     """Strip bookmarks if revisions are stripped using
     the mercurial.strip method. This usually happens during
     qpush and qpop"""
     revisions = _revstostrip(repo.changelog, node)
     marks = repo._bookmarks
     update = []
     for mark, n in marks.iteritems():
         if repo.changelog.rev(n) in revisions:
             update.append(mark)
     oldstrip(ui, repo, node, backup)
     if len(update) > 0:
         for m in update:
             marks[m] = repo.changectx('.').node()
         write(repo)
 
 def reposetup(ui, repo):
     if not repo.local():
         return
 
     class bookmark_repo(repo.__class__):
 
         @util.propertycache
         def _bookmarks(self):
             '''Parse .hg/bookmarks file and return a dictionary
 
             Bookmarks are stored as {HASH}\\s{NAME}\\n (localtags format) values
             in the .hg/bookmarks file.
             Read the file and return a (name=>nodeid) dictionary
             '''
             try:
                 bookmarks = {}
                 for line in self.opener('bookmarks'):
                     sha, refspec = line.strip().split(' ', 1)
                     bookmarks[refspec] = self.changelog.lookup(sha)
             except:
                 pass
             return bookmarks
 
         @util.propertycache
         def _bookmarkcurrent(self):
             '''Get the current bookmark
 
             If we use gittishsh branches we have a current bookmark that
             we are on. This function returns the name of the bookmark. It
             is stored in .hg/bookmarks.current
             '''
             mark = None
             if os.path.exists(self.join('bookmarks.current')):
                 file = self.opener('bookmarks.current')
                 # No readline() in posixfile_nt, reading everything is cheap
                 mark = (file.readlines() or [''])[0]
                 if mark == '':
                     mark = None
                 file.close()
             return mark
 
         def rollback(self, *args):
             if os.path.exists(self.join('undo.bookmarks')):
                 util.rename(self.join('undo.bookmarks'), self.join('bookmarks'))
             return super(bookmark_repo, self).rollback(*args)
 
         def lookup(self, key):
             if key in self._bookmarks:
                 key = self._bookmarks[key]
             return super(bookmark_repo, self).lookup(key)
 
         def _bookmarksupdate(self, parents, node):
             marks = self._bookmarks
             update = False
             if ui.configbool('bookmarks', 'track.current'):
                 mark = self._bookmarkcurrent
                 if mark and marks[mark] in parents:
                     marks[mark] = node
                     update = True
             else:
                 for mark, n in marks.items():
                     if n in parents:
                         marks[mark] = node
                         update = True
             if update:
                 write(self)
 
         def commitctx(self, ctx, error=False):
             """Add a revision to the repository and
             move the bookmark"""
             wlock = self.wlock() # do both commit and bookmark with lock held
             try:
                 node  = super(bookmark_repo, self).commitctx(ctx, error)
                 if node is None:
                     return None
                 parents = self.changelog.parents(node)
                 if parents[1] == nullid:
                     parents = (parents[0],)
 
                 self._bookmarksupdate(parents, node)
                 return node
             finally:
                 wlock.release()
 
         def pull(self, remote, heads=None, force=False):
             result = super(bookmark_repo, self).pull(remote, heads, force)
 
             self.ui.debug("checking for updated bookmarks\n")
             rb = remote.listkeys('bookmarks')
             changed = False
             for k in rb.keys():
                 if k in self._bookmarks:
                     nr, nl = rb[k], self._bookmarks[k]
                     if nr in self:
                         cr = self[nr]
                         cl = self[nl]
                         if cl.rev() >= cr.rev():
                             continue
                         if cr in cl.descendants():
                             self._bookmarks[k] = cr.node()
                             changed = True
                             self.ui.status(_("updating bookmark %s\n") % k)
                         else:
                             self.ui.warn(_("not updating divergent"
                                            " bookmark %s\n") % k)
             if changed:
                 write(repo)
 
             return result
 
         def push(self, remote, force=False, revs=None, newbranch=False):
             result = super(bookmark_repo, self).push(remote, force, revs,
                                                      newbranch)
 
             self.ui.debug("checking for updated bookmarks\n")
             rb = remote.listkeys('bookmarks')
             for k in rb.keys():
                 if k in self._bookmarks:
                     nr, nl = rb[k], self._bookmarks[k]
                     if nr in self:
                         cr = self[nr]
                         cl = self[nl]
                         if cl in cr.descendants():
                             r = remote.pushkey('bookmarks', k, nr, nl)
                             if r:
                                 self.ui.status(_("updating bookmark %s\n") % k)
                             else:
                                 self.ui.warn(_('updating bookmark %s'
                                                ' failed!\n') % k)
 
             return result
 
         def addchangegroup(self, *args, **kwargs):
             parents = self.dirstate.parents()
 
             result = super(bookmark_repo, self).addchangegroup(*args, **kwargs)
             if result > 1:
                 # We have more heads than before
                 return result
             node = self.changelog.tip()
 
             self._bookmarksupdate(parents, node)
             return result
 
         def _findtags(self):
             """Merge bookmarks with normal tags"""
             (tags, tagtypes) = super(bookmark_repo, self)._findtags()
             tags.update(self._bookmarks)
             return (tags, tagtypes)
 
         if hasattr(repo, 'invalidate'):
             def invalidate(self):
                 super(bookmark_repo, self).invalidate()
                 for attr in ('_bookmarks', '_bookmarkcurrent'):
                     if attr in self.__dict__:
                         delattr(self, attr)
 
     repo.__class__ = bookmark_repo
 
 def listbookmarks(repo):
     # We may try to list bookmarks on a repo type that does not
     # support it (e.g., statichttprepository).
     if not hasattr(repo, '_bookmarks'):
         return {}
 
     d = {}
     for k, v in repo._bookmarks.iteritems():
         d[k] = hex(v)
     return d
 
 def pushbookmark(repo, key, old, new):
     w = repo.wlock()
     try:
         marks = repo._bookmarks
         if hex(marks.get(key, '')) != old:
             return False
         if new == '':
             del marks[key]
         else:
             if new not in repo:
                 return False
             marks[key] = repo[new].node()
         write(repo)
         return True
     finally:
         w.release()
 
 def pull(oldpull, ui, repo, source="default", **opts):
     # translate bookmark args to rev args for actual pull
     if opts.get('bookmark'):
         # this is an unpleasant hack as pull will do this internally
         source, branches = hg.parseurl(ui.expandpath(source),
                                        opts.get('branch'))
         other = hg.repository(hg.remoteui(repo, opts), source)
         rb = other.listkeys('bookmarks')
 
         for b in opts['bookmark']:
             if b not in rb:
                 raise util.Abort(_('remote bookmark %s not found!') % b)
             opts.setdefault('rev', []).append(b)
 
     result = oldpull(ui, repo, source, **opts)
 
     # update specified bookmarks
     if opts.get('bookmark'):
         for b in opts['bookmark']:
             # explicit pull overrides local bookmark if any
             ui.status(_("importing bookmark %s\n") % b)
             repo._bookmarks[b] = repo[rb[b]].node()
         write(repo)
 
     return result
 
 def push(oldpush, ui, repo, dest=None, **opts):
     dopush = True
     if opts.get('bookmark'):
         dopush = False
         for b in opts['bookmark']:
             if b in repo._bookmarks:
                 dopush = True
                 opts.setdefault('rev', []).append(b)
 
     result = 0
     if dopush:
         result = oldpush(ui, repo, dest, **opts)
 
     if opts.get('bookmark'):
         # this is an unpleasant hack as push will do this internally
         dest = ui.expandpath(dest or 'default-push', dest or 'default')
         dest, branches = hg.parseurl(dest, opts.get('branch'))
         other = hg.repository(hg.remoteui(repo, opts), dest)
         rb = other.listkeys('bookmarks')
         for b in opts['bookmark']:
             # explicit push overrides remote bookmark if any
             if b in repo._bookmarks:
                 ui.status(_("exporting bookmark %s\n") % b)
                 new = repo[b].hex()
             elif b in rb:
                 ui.status(_("deleting remote bookmark %s\n") % b)
                 new = '' # delete
             else:
                 ui.warn(_('bookmark %s does not exist on the local '
                           'or remote repository!\n') % b)
                 return 2
             old = rb.get(b, '')
             r = other.pushkey('bookmarks', b, old, new)
             if not r:
                 ui.warn(_('updating bookmark %s failed!\n') % b)
                 if not result:
                     result = 2
 
     return result
 
 def diffbookmarks(ui, repo, remote):
     ui.status(_("searching for changes\n"))
 
     lmarks = repo.listkeys('bookmarks')
     rmarks = remote.listkeys('bookmarks')
 
     diff = sorted(set(rmarks) - set(lmarks))
     for k in diff:
         ui.write("   %-25s %s\n" % (k, rmarks[k][:12]))
 
     if len(diff) <= 0:
         ui.status(_("no changes found\n"))
         return 1
     return 0
 
 def incoming(oldincoming, ui, repo, source="default", **opts):
     if opts.get('bookmarks'):
         source, branches = hg.parseurl(ui.expandpath(source), opts.get('branch'))
         other = hg.repository(hg.remoteui(repo, opts), source)
         ui.status(_('comparing with %s\n') % url.hidepassword(source))
         return diffbookmarks(ui, repo, other)
     else:
         return oldincoming(ui, repo, source, **opts)
 
 def outgoing(oldoutgoing, ui, repo, dest=None, **opts):
     if opts.get('bookmarks'):
         dest = ui.expandpath(dest or 'default-push', dest or 'default')
         dest, branches = hg.parseurl(dest, opts.get('branch'))
         other = hg.repository(hg.remoteui(repo, opts), dest)
         ui.status(_('comparing with %s\n') % url.hidepassword(dest))
         return diffbookmarks(ui, other, repo)
     else:
         return oldoutgoing(ui, repo, dest, **opts)
 
 def uisetup(ui):
     extensions.wrapfunction(repair, "strip", strip)
     if ui.configbool('bookmarks', 'track.current'):
         extensions.wrapcommand(commands.table, 'update', updatecurbookmark)
 
     entry = extensions.wrapcommand(commands.table, 'pull', pull)
     entry[1].append(('B', 'bookmark', [],
                      _("bookmark to import"),
                      _('BOOKMARK')))
     entry = extensions.wrapcommand(commands.table, 'push', push)
     entry[1].append(('B', 'bookmark', [],
                      _("bookmark to export"),
                      _('BOOKMARK')))
     entry = extensions.wrapcommand(commands.table, 'incoming', incoming)
     entry[1].append(('B', 'bookmarks', False,
                      _("compare bookmark")))
     entry = extensions.wrapcommand(commands.table, 'outgoing', outgoing)
     entry[1].append(('B', 'bookmarks', False,
                      _("compare bookmark")))
 
     pushkey.register('bookmarks', pushbookmark, listbookmarks)
 
 def updatecurbookmark(orig, ui, repo, *args, **opts):
     '''Set the current bookmark
 
     If the user updates to a bookmark we update the .hg/bookmarks.current
     file.
     '''
     res = orig(ui, repo, *args, **opts)
     rev = opts['rev']
     if not rev and len(args) > 0:
         rev = args[0]
     setcurrent(repo, rev)
     return res
 
 def bmrevset(repo, subset, x):
     """``bookmark([name])``
     The named bookmark or all bookmarks.
     """
     args = revset.getargs(x, 0, 1, _('bookmark takes one or no arguments'))
     if args:
         bm = revset.getstring(args[0],
                               _('the argument to bookmark must be a string'))
         bmrev = listbookmarks(repo).get(bm, None)
         if bmrev:
             bmrev = repo.changelog.rev(bin(bmrev))
         return [r for r in subset if r == bmrev]
     bms = set([repo.changelog.rev(bin(r)) for r in listbookmarks(repo).values()])
     return [r for r in subset if r in bms]
 
 def extsetup(ui):
     revset.symbols['bookmark'] = bmrevset
 
 cmdtable = {
     "bookmarks":
         (bookmark,
          [('f', 'force', False, _('force')),
           ('r', 'rev', '', _('revision'), _('REV')),
           ('d', 'delete', False, _('delete a given bookmark')),
           ('m', 'rename', '', _('rename a given bookmark'), _('NAME'))],
          _('hg bookmarks [-f] [-d] [-m NAME] [-r REV] [NAME]')),
 }
 
 colortable = {'bookmarks.current': 'green'}
+
+# tell hggettext to extract docstrings from these functions:
+i18nfunctions = [bmrevset]

hgext/transplant.py

@@ -1,627 +1,630
 # Patch transplanting extension for Mercurial
 #
 # Copyright 2006, 2007 Brendan Cully <[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.
 
 '''command to transplant changesets from another branch
 
 This extension allows you to transplant patches from another branch.
 
 Transplanted patches are recorded in .hg/transplant/transplants, as a
 map from a changeset hash to its hash in the source repository.
 '''
 
 from mercurial.i18n import _
 import os, tempfile
 from mercurial import bundlerepo, cmdutil, hg, merge, match
 from mercurial import patch, revlog, util, error
 from mercurial import revset
 
 class transplantentry(object):
     def __init__(self, lnode, rnode):
         self.lnode = lnode
         self.rnode = rnode
 
 class transplants(object):
     def __init__(self, path=None, transplantfile=None, opener=None):
         self.path = path
         self.transplantfile = transplantfile
         self.opener = opener
 
         if not opener:
             self.opener = util.opener(self.path)
         self.transplants = {}
         self.dirty = False
         self.read()
 
     def read(self):
         abspath = os.path.join(self.path, self.transplantfile)
         if self.transplantfile and os.path.exists(abspath):
             for line in self.opener(self.transplantfile).read().splitlines():
                 lnode, rnode = map(revlog.bin, line.split(':'))
                 list = self.transplants.setdefault(rnode, [])
                 list.append(transplantentry(lnode, rnode))
 
     def write(self):
         if self.dirty and self.transplantfile:
             if not os.path.isdir(self.path):
                 os.mkdir(self.path)
             fp = self.opener(self.transplantfile, 'w')
             for list in self.transplants.itervalues():
                 for t in list:
                     l, r = map(revlog.hex, (t.lnode, t.rnode))
                     fp.write(l + ':' + r + '\n')
             fp.close()
         self.dirty = False
 
     def get(self, rnode):
         return self.transplants.get(rnode) or []
 
     def set(self, lnode, rnode):
         list = self.transplants.setdefault(rnode, [])
         list.append(transplantentry(lnode, rnode))
         self.dirty = True
 
     def remove(self, transplant):
         list = self.transplants.get(transplant.rnode)
         if list:
             del list[list.index(transplant)]
             self.dirty = True
 
 class transplanter(object):
     def __init__(self, ui, repo):
         self.ui = ui
         self.path = repo.join('transplant')
         self.opener = util.opener(self.path)
         self.transplants = transplants(self.path, 'transplants',
                                        opener=self.opener)
 
     def applied(self, repo, node, parent):
         '''returns True if a node is already an ancestor of parent
         or has already been transplanted'''
         if hasnode(repo, node):
             if node in repo.changelog.reachable(parent, stop=node):
                 return True
         for t in self.transplants.get(node):
             # it might have been stripped
             if not hasnode(repo, t.lnode):
                 self.transplants.remove(t)
                 return False
             if t.lnode in repo.changelog.reachable(parent, stop=t.lnode):
                 return True
         return False
 
     def apply(self, repo, source, revmap, merges, opts={}):
         '''apply the revisions in revmap one by one in revision order'''
         revs = sorted(revmap)
         p1, p2 = repo.dirstate.parents()
         pulls = []
         diffopts = patch.diffopts(self.ui, opts)
         diffopts.git = True
 
         lock = wlock = None
         try:
             wlock = repo.wlock()
             lock = repo.lock()
             for rev in revs:
                 node = revmap[rev]
                 revstr = '%s:%s' % (rev, revlog.short(node))
 
                 if self.applied(repo, node, p1):
                     self.ui.warn(_('skipping already applied revision %s\n') %
                                  revstr)
                     continue
 
                 parents = source.changelog.parents(node)
                 if not opts.get('filter'):
                     # If the changeset parent is the same as the
                     # wdir's parent, just pull it.
                     if parents[0] == p1:
                         pulls.append(node)
                         p1 = node
                         continue
                     if pulls:
                         if source != repo:
                             repo.pull(source, heads=pulls)
                         merge.update(repo, pulls[-1], False, False, None)
                         p1, p2 = repo.dirstate.parents()
                         pulls = []
 
                 domerge = False
                 if node in merges:
                     # pulling all the merge revs at once would mean we
                     # couldn't transplant after the latest even if
                     # transplants before them fail.
                     domerge = True
                     if not hasnode(repo, node):
                         repo.pull(source, heads=[node])
 
                 if parents[1] != revlog.nullid:
                     self.ui.note(_('skipping merge changeset %s:%s\n')
                                  % (rev, revlog.short(node)))
                     patchfile = None
                 else:
                     fd, patchfile = tempfile.mkstemp(prefix='hg-transplant-')
                     fp = os.fdopen(fd, 'w')
                     gen = patch.diff(source, parents[0], node, opts=diffopts)
                     for chunk in gen:
                         fp.write(chunk)
                     fp.close()
 
                 del revmap[rev]
                 if patchfile or domerge:
                     try:
                         n = self.applyone(repo, node,
                                           source.changelog.read(node),
                                           patchfile, merge=domerge,
                                           log=opts.get('log'),
                                           filter=opts.get('filter'))
                         if n and domerge:
                             self.ui.status(_('%s merged at %s\n') % (revstr,
                                       revlog.short(n)))
                         elif n:
                             self.ui.status(_('%s transplanted to %s\n')
                                            % (revlog.short(node),
                                               revlog.short(n)))
                     finally:
                         if patchfile:
                             os.unlink(patchfile)
             if pulls:
                 repo.pull(source, heads=pulls)
                 merge.update(repo, pulls[-1], False, False, None)
         finally:
             self.saveseries(revmap, merges)
             self.transplants.write()
             lock.release()
             wlock.release()
 
     def filter(self, filter, changelog, patchfile):
         '''arbitrarily rewrite changeset before applying it'''
 
         self.ui.status(_('filtering %s\n') % patchfile)
         user, date, msg = (changelog[1], changelog[2], changelog[4])
 
         fd, headerfile = tempfile.mkstemp(prefix='hg-transplant-')
         fp = os.fdopen(fd, 'w')
         fp.write("# HG changeset patch\n")
         fp.write("# User %s\n" % user)
         fp.write("# Date %d %d\n" % date)
         fp.write(msg + '\n')
         fp.close()
 
         try:
             util.system('%s %s %s' % (filter, util.shellquote(headerfile),
                                    util.shellquote(patchfile)),
                         environ={'HGUSER': changelog[1]},
                         onerr=util.Abort, errprefix=_('filter failed'))
             user, date, msg = self.parselog(file(headerfile))[1:4]
         finally:
             os.unlink(headerfile)
 
         return (user, date, msg)
 
     def applyone(self, repo, node, cl, patchfile, merge=False, log=False,
                  filter=None):
         '''apply the patch in patchfile to the repository as a transplant'''
         (manifest, user, (time, timezone), files, message) = cl[:5]
         date = "%d %d" % (time, timezone)
         extra = {'transplant_source': node}
         if filter:
             (user, date, message) = self.filter(filter, cl, patchfile)
 
         if log:
             # we don't translate messages inserted into commits
             message += '\n(transplanted from %s)' % revlog.hex(node)
 
         self.ui.status(_('applying %s\n') % revlog.short(node))
         self.ui.note('%s %s\n%s\n' % (user, date, message))
 
         if not patchfile and not merge:
             raise util.Abort(_('can only omit patchfile if merging'))
         if patchfile:
             try:
                 files = {}
                 try:
                     patch.patch(patchfile, self.ui, cwd=repo.root,
                                 files=files, eolmode=None)
                     if not files:
                         self.ui.warn(_('%s: empty changeset')
                                      % revlog.hex(node))
                         return None
                 finally:
                     files = cmdutil.updatedir(self.ui, repo, files)
             except Exception, inst:
                 seriespath = os.path.join(self.path, 'series')
                 if os.path.exists(seriespath):
                     os.unlink(seriespath)
                 p1 = repo.dirstate.parents()[0]
                 p2 = node
                 self.log(user, date, message, p1, p2, merge=merge)
                 self.ui.write(str(inst) + '\n')
                 raise util.Abort(_('fix up the merge and run '
                                    'hg transplant --continue'))
         else:
             files = None
         if merge:
             p1, p2 = repo.dirstate.parents()
             repo.dirstate.setparents(p1, node)
             m = match.always(repo.root, '')
         else:
             m = match.exact(repo.root, '', files)
 
         n = repo.commit(message, user, date, extra=extra, match=m)
         if not n:
             # Crash here to prevent an unclear crash later, in
             # transplants.write().  This can happen if patch.patch()
             # does nothing but claims success or if repo.status() fails
             # to report changes done by patch.patch().  These both
             # appear to be bugs in other parts of Mercurial, but dying
             # here, as soon as we can detect the problem, is preferable
             # to silently dropping changesets on the floor.
             raise RuntimeError('nothing committed after transplant')
         if not merge:
             self.transplants.set(n, node)
 
         return n
 
     def resume(self, repo, source, opts=None):
         '''recover last transaction and apply remaining changesets'''
         if os.path.exists(os.path.join(self.path, 'journal')):
             n, node = self.recover(repo)
             self.ui.status(_('%s transplanted as %s\n') % (revlog.short(node),
                                                            revlog.short(n)))
         seriespath = os.path.join(self.path, 'series')
         if not os.path.exists(seriespath):
             self.transplants.write()
             return
         nodes, merges = self.readseries()
         revmap = {}
         for n in nodes:
             revmap[source.changelog.rev(n)] = n
         os.unlink(seriespath)
 
         self.apply(repo, source, revmap, merges, opts)
 
     def recover(self, repo):
         '''commit working directory using journal metadata'''
         node, user, date, message, parents = self.readlog()
         merge = len(parents) == 2
 
         if not user or not date or not message or not parents[0]:
             raise util.Abort(_('transplant log file is corrupt'))
 
         extra = {'transplant_source': node}
         wlock = repo.wlock()
         try:
             p1, p2 = repo.dirstate.parents()
             if p1 != parents[0]:
                 raise util.Abort(
                     _('working dir not at transplant parent %s') %
                                  revlog.hex(parents[0]))
             if merge:
                 repo.dirstate.setparents(p1, parents[1])
             n = repo.commit(message, user, date, extra=extra)
             if not n:
                 raise util.Abort(_('commit failed'))
             if not merge:
                 self.transplants.set(n, node)
             self.unlog()
 
             return n, node
         finally:
             wlock.release()
 
     def readseries(self):
         nodes = []
         merges = []
         cur = nodes
         for line in self.opener('series').read().splitlines():
             if line.startswith('# Merges'):
                 cur = merges
                 continue
             cur.append(revlog.bin(line))
 
         return (nodes, merges)
 
     def saveseries(self, revmap, merges):
         if not revmap:
             return
 
         if not os.path.isdir(self.path):
             os.mkdir(self.path)
         series = self.opener('series', 'w')
         for rev in sorted(revmap):
             series.write(revlog.hex(revmap[rev]) + '\n')
         if merges:
             series.write('# Merges\n')
             for m in merges:
                 series.write(revlog.hex(m) + '\n')
         series.close()
 
     def parselog(self, fp):
         parents = []
         message = []
         node = revlog.nullid
         inmsg = False
         for line in fp.read().splitlines():
             if inmsg:
                 message.append(line)
             elif line.startswith('# User '):
                 user = line[7:]
             elif line.startswith('# Date '):
                 date = line[7:]
             elif line.startswith('# Node ID '):
                 node = revlog.bin(line[10:])
             elif line.startswith('# Parent '):
                 parents.append(revlog.bin(line[9:]))
             elif not line.startswith('# '):
                 inmsg = True
                 message.append(line)
         return (node, user, date, '\n'.join(message), parents)
 
     def log(self, user, date, message, p1, p2, merge=False):
         '''journal changelog metadata for later recover'''
 
         if not os.path.isdir(self.path):
             os.mkdir(self.path)
         fp = self.opener('journal', 'w')
         fp.write('# User %s\n' % user)
         fp.write('# Date %s\n' % date)
         fp.write('# Node ID %s\n' % revlog.hex(p2))
         fp.write('# Parent ' + revlog.hex(p1) + '\n')
         if merge:
             fp.write('# Parent ' + revlog.hex(p2) + '\n')
         fp.write(message.rstrip() + '\n')
         fp.close()
 
     def readlog(self):
         return self.parselog(self.opener('journal'))
 
     def unlog(self):
         '''remove changelog journal'''
         absdst = os.path.join(self.path, 'journal')
         if os.path.exists(absdst):
             os.unlink(absdst)
 
     def transplantfilter(self, repo, source, root):
         def matchfn(node):
             if self.applied(repo, node, root):
                 return False
             if source.changelog.parents(node)[1] != revlog.nullid:
                 return False
             extra = source.changelog.read(node)[5]
             cnode = extra.get('transplant_source')
             if cnode and self.applied(repo, cnode, root):
                 return False
             return True
 
         return matchfn
 
 def hasnode(repo, node):
     try:
         return repo.changelog.rev(node) != None
     except error.RevlogError:
         return False
 
 def browserevs(ui, repo, nodes, opts):
     '''interactively transplant changesets'''
     def browsehelp(ui):
         ui.write(_('y: transplant this changeset\n'
                    'n: skip this changeset\n'
                    'm: merge at this changeset\n'
                    'p: show patch\n'
                    'c: commit selected changesets\n'
                    'q: cancel transplant\n'
                    '?: show this help\n'))
 
     displayer = cmdutil.show_changeset(ui, repo, opts)
     transplants = []
     merges = []
     for node in nodes:
         displayer.show(repo[node])
         action = None
         while not action:
             action = ui.prompt(_('apply changeset? [ynmpcq?]:'))
             if action == '?':
                 browsehelp(ui)
                 action = None
             elif action == 'p':
                 parent = repo.changelog.parents(node)[0]
                 for chunk in patch.diff(repo, parent, node):
                     ui.write(chunk)
                 action = None
             elif action not in ('y', 'n', 'm', 'c', 'q'):
                 ui.write(_('no such option\n'))
                 action = None
         if action == 'y':
             transplants.append(node)
         elif action == 'm':
             merges.append(node)
         elif action == 'c':
             break
         elif action == 'q':
             transplants = ()
             merges = ()
             break
     displayer.close()
     return (transplants, merges)
 
 def transplant(ui, repo, *revs, **opts):
     '''transplant changesets from another branch
 
     Selected changesets will be applied on top of the current working
     directory with the log of the original changeset. If --log is
     specified, log messages will have a comment appended of the form::
 
       (transplanted from CHANGESETHASH)
 
     You can rewrite the changelog message with the --filter option.
     Its argument will be invoked with the current changelog message as
     $1 and the patch as $2.
 
     If --source/-s is specified, selects changesets from the named
     repository. If --branch/-b is specified, selects changesets from
     the branch holding the named revision, up to that revision. If
     --all/-a is specified, all changesets on the branch will be
     transplanted, otherwise you will be prompted to select the
     changesets you want.
 
     :hg:`transplant --branch REVISION --all` will rebase the selected
     branch (up to the named revision) onto your current working
     directory.
 
     You can optionally mark selected transplanted changesets as merge
     changesets. You will not be prompted to transplant any ancestors
     of a merged transplant, and you can merge descendants of them
     normally instead of transplanting them.
 
     If no merges or revisions are provided, :hg:`transplant` will
     start an interactive changeset browser.
 
     If a changeset application fails, you can fix the merge by hand
     and then resume where you left off by calling :hg:`transplant
     --continue/-c`.
     '''
     def incwalk(repo, incoming, branches, match=util.always):
         if not branches:
             branches = None
         for node in repo.changelog.nodesbetween(incoming, branches)[0]:
             if match(node):
                 yield node
 
     def transplantwalk(repo, root, branches, match=util.always):
         if not branches:
             branches = repo.heads()
         ancestors = []
         for branch in branches:
             ancestors.append(repo.changelog.ancestor(root, branch))
         for node in repo.changelog.nodesbetween(ancestors, branches)[0]:
             if match(node):
                 yield node
 
     def checkopts(opts, revs):
         if opts.get('continue'):
             if opts.get('branch') or opts.get('all') or opts.get('merge'):
                 raise util.Abort(_('--continue is incompatible with '
                                    'branch, all or merge'))
             return
         if not (opts.get('source') or revs or
                 opts.get('merge') or opts.get('branch')):
             raise util.Abort(_('no source URL, branch tag or revision '
                                'list provided'))
         if opts.get('all'):
             if not opts.get('branch'):
                 raise util.Abort(_('--all requires a branch revision'))
             if revs:
                 raise util.Abort(_('--all is incompatible with a '
                                    'revision list'))
 
     checkopts(opts, revs)
 
     if not opts.get('log'):
         opts['log'] = ui.config('transplant', 'log')
     if not opts.get('filter'):
         opts['filter'] = ui.config('transplant', 'filter')
 
     tp = transplanter(ui, repo)
 
     p1, p2 = repo.dirstate.parents()
     if len(repo) > 0 and p1 == revlog.nullid:
         raise util.Abort(_('no revision checked out'))
     if not opts.get('continue'):
         if p2 != revlog.nullid:
             raise util.Abort(_('outstanding uncommitted merges'))
         m, a, r, d = repo.status()[:4]
         if m or a or r or d:
             raise util.Abort(_('outstanding local changes'))
 
     bundle = None
     source = opts.get('source')
     if source:
         sourcerepo = ui.expandpath(source)
         source = hg.repository(ui, sourcerepo)
         source, incoming, bundle = bundlerepo.getremotechanges(ui, repo, source,
                                     force=True)
     else:
         source = repo
 
     try:
         if opts.get('continue'):
             tp.resume(repo, source, opts)
             return
 
         tf = tp.transplantfilter(repo, source, p1)
         if opts.get('prune'):
             prune = [source.lookup(r)
                      for r in cmdutil.revrange(source, opts.get('prune'))]
             matchfn = lambda x: tf(x) and x not in prune
         else:
             matchfn = tf
         branches = map(source.lookup, opts.get('branch', ()))
         merges = map(source.lookup, opts.get('merge', ()))
         revmap = {}
         if revs:
             for r in cmdutil.revrange(source, revs):
                 revmap[int(r)] = source.lookup(r)
         elif opts.get('all') or not merges:
             if source != repo:
                 alltransplants = incwalk(source, incoming, branches,
                                          match=matchfn)
             else:
                 alltransplants = transplantwalk(source, p1, branches,
                                                 match=matchfn)
             if opts.get('all'):
                 revs = alltransplants
             else:
                 revs, newmerges = browserevs(ui, source, alltransplants, opts)
                 merges.extend(newmerges)
             for r in revs:
                 revmap[source.changelog.rev(r)] = r
         for r in merges:
             revmap[source.changelog.rev(r)] = r
 
         tp.apply(repo, source, revmap, merges, opts)
     finally:
         if bundle:
             source.close()
             os.unlink(bundle)
 
 def revsettransplanted(repo, subset, x):
     """``transplanted(set)``
     Transplanted changesets in set.
     """
     if x:
       s = revset.getset(repo, subset, x)
     else:
       s = subset
     cs = set()
     for r in xrange(0, len(repo)):
       if repo[r].extra().get('transplant_source'):
         cs.add(r)
     return [r for r in s if r in cs]
 
 def extsetup(ui):
     revset.symbols['transplanted'] = revsettransplanted
 
 cmdtable = {
     "transplant":
         (transplant,
          [('s', 'source', '',
            _('pull patches from REPO'), _('REPO')),
           ('b', 'branch', [],
            _('pull patches from branch BRANCH'), _('BRANCH')),
           ('a', 'all', None, _('pull all changesets up to BRANCH')),
           ('p', 'prune', [],
            _('skip over REV'), _('REV')),
           ('m', 'merge', [],
            _('merge at REV'), _('REV')),
           ('', 'log', None, _('append transplant info to log message')),
           ('c', 'continue', None, _('continue last transplant session '
                                     'after repair')),
           ('', 'filter', '',
            _('filter changesets through command'), _('CMD'))],
          _('hg transplant [-s REPO] [-b BRANCH [-a]] [-p REV] '
            '[-m REV] [REV]...'))
 }
+
+# tell hggettext to extract docstrings from these functions:
+i18nfunctions = [revsettransplanted]

i18n/hggettext

@@ -1,131 +1,137
 #!/usr/bin/env python
 #
 # hggettext - carefully extract docstrings for Mercurial
 #
 # Copyright 2009 Matt Mackall <[e-mail]> and others
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 # The normalize function is taken from pygettext which is distributed
 # with Python under the Python License, which is GPL compatible.
 
 """Extract docstrings from Mercurial commands.
 
 Compared to pygettext, this script knows about the cmdtable and table
 dictionaries used by Mercurial, and will only extract docstrings from
 functions mentioned therein.
 
 Use xgettext like normal to extract strings marked as translatable and
 join the message cataloges to get the final catalog.
 """
 
 import os, sys, inspect
 
 
 def escape(s):
     # The order is important, the backslash must be escaped first
     # since the other replacements introduce new backslashes
     # themselves.
     s = s.replace('\\', '\\\\')
     s = s.replace('\n', '\\n')
     s = s.replace('\r', '\\r')
     s = s.replace('\t', '\\t')
     s = s.replace('"', '\\"')
     return s
 
 
 def normalize(s):
     # This converts the various Python string types into a format that
     # is appropriate for .po files, namely much closer to C style.
     lines = s.split('\n')
     if len(lines) == 1:
         s = '"' + escape(s) + '"'
     else:
         if not lines[-1]:
             del lines[-1]
             lines[-1] = lines[-1] + '\n'
         lines = map(escape, lines)
         lineterm = '\\n"\n"'
         s = '""\n"' + lineterm.join(lines) + '"'
     return s
 
 
 def poentry(path, lineno, s):
     return ('#: %s:%d\n' % (path, lineno) +
             'msgid %s\n' % normalize(s) +
             'msgstr ""\n')
 
 
 def offset(src, doc, name, default):
     """Compute offset or issue a warning on stdout."""
     # Backslashes in doc appear doubled in src.
     end = src.find(doc.replace('\\', '\\\\'))
     if end == -1:
         # This can happen if the docstring contains unnecessary escape
         # sequences such as \" in a triple-quoted string. The problem
         # is that \" is turned into " and so doc wont appear in src.
         sys.stderr.write("warning: unknown offset in %s, assuming %d lines\n"
                          % (name, default))
         return default
     else:
         return src.count('\n', 0, end)
 
 
 def importpath(path):
     """Import a path like foo/bar/baz.py and return the baz module."""
     if path.endswith('.py'):
         path = path[:-3]
     if path.endswith('/__init__'):
         path = path[:-9]
     path = path.replace('/', '.')
     mod = __import__(path)
     for comp in path.split('.')[1:]:
         mod = getattr(mod, comp)
     return mod
 
 
 def docstrings(path):
     """Extract docstrings from path.
 
     This respects the Mercurial cmdtable/table convention and will
     only extract docstrings from functions mentioned in these tables.
     """
     mod = importpath(path)
     if mod.__doc__:
         src = open(path).read()
         lineno = 1 + offset(src, mod.__doc__, path, 7)
         print poentry(path, lineno, mod.__doc__)
 
+    functions = list(getattr(mod, 'i18nfunctions', []))
+    functions = [(f, True) for f in functions]
+
     cmdtable = getattr(mod, 'cmdtable', {})
     if not cmdtable:
         # Maybe we are processing mercurial.commands?
         cmdtable = getattr(mod, 'table', {})
+    functions.extend((c[0], False) for c in cmdtable.itervalues())
 
-    for entry in cmdtable.itervalues():
-        func = entry[0]
+    for func, rstrip in functions:
         if func.__doc__:
             src = inspect.getsource(func)
             name = "%s.%s" % (path, func.__name__)
             lineno = func.func_code.co_firstlineno
-            lineno += offset(src, func.__doc__, name, 1)
-            print poentry(path, lineno, func.__doc__)
+            doc = func.__doc__
+            if rstrip:
+                doc = doc.rstrip()
+            lineno += offset(src, doc, name, 1)
+            print poentry(path, lineno, doc)
 
 
 def rawtext(path):
     src = open(path).read()
     print poentry(path, 1, src)
 
 
 if __name__ == "__main__":
     # It is very important that we import the Mercurial modules from
     # the source tree where hggettext is executed. Otherwise we might
     # accidentally import and extract strings from a Mercurial
     # installation mentioned in PYTHONPATH.
     sys.path.insert(0, os.getcwd())
     from mercurial import demandimport; demandimport.enable()
     for path in sys.argv[1:]:
         if path.endswith('.txt'):
             rawtext(path)
         else:
             docstrings(path)

mercurial/revset.py

@@ -1,793 +1,796
 # revset.py - revision set queries for mercurial
 #
 # Copyright 2010 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.
 
 import re
 import parser, util, error, discovery
 import match as matchmod
 from i18n import _
 
 elements = {
     "(": (20, ("group", 1, ")"), ("func", 1, ")")),
     "-": (5, ("negate", 19), ("minus", 5)),
     "::": (17, ("dagrangepre", 17), ("dagrange", 17),
            ("dagrangepost", 17)),
     "..": (17, ("dagrangepre", 17), ("dagrange", 17),
            ("dagrangepost", 17)),
     ":": (15, ("rangepre", 15), ("range", 15), ("rangepost", 15)),
     "not": (10, ("not", 10)),
     "!": (10, ("not", 10)),
     "and": (5, None, ("and", 5)),
     "&": (5, None, ("and", 5)),
     "or": (4, None, ("or", 4)),
     "|": (4, None, ("or", 4)),
     "+": (4, None, ("or", 4)),
     ",": (2, None, ("list", 2)),
     ")": (0, None, None),
     "symbol": (0, ("symbol",), None),
     "string": (0, ("string",), None),
     "end": (0, None, None),
 }
 
 keywords = set(['and', 'or', 'not'])
 
 def tokenize(program):
     pos, l = 0, len(program)
     while pos < l:
         c = program[pos]
         if c.isspace(): # skip inter-token whitespace
             pass
         elif c == ':' and program[pos:pos + 2] == '::': # look ahead carefully
             yield ('::', None, pos)
             pos += 1 # skip ahead
         elif c == '.' and program[pos:pos + 2] == '..': # look ahead carefully
             yield ('..', None, pos)
             pos += 1 # skip ahead
         elif c in "():,-|&+!": # handle simple operators
             yield (c, None, pos)
         elif (c in '"\'' or c == 'r' and
               program[pos:pos + 2] in ("r'", 'r"')): # handle quoted strings
             if c == 'r':
                 pos += 1
                 c = program[pos]
                 decode = lambda x: x
             else:
                 decode = lambda x: x.decode('string-escape')
             pos += 1
             s = pos
             while pos < l: # find closing quote
                 d = program[pos]
                 if d == '\\': # skip over escaped characters
                     pos += 2
                     continue
                 if d == c:
                     yield ('string', decode(program[s:pos]), s)
                     break
                 pos += 1
             else:
                 raise error.ParseError(_("unterminated string"), s)
         elif c.isalnum() or c in '._' or ord(c) > 127: # gather up a symbol/keyword
             s = pos
             pos += 1
             while pos < l: # find end of symbol
                 d = program[pos]
                 if not (d.isalnum() or d in "._" or ord(d) > 127):
                     break
                 if d == '.' and program[pos - 1] == '.': # special case for ..
                     pos -= 1
                     break
                 pos += 1
             sym = program[s:pos]
             if sym in keywords: # operator keywords
                 yield (sym, None, s)
             else:
                 yield ('symbol', sym, s)
             pos -= 1
         else:
             raise error.ParseError(_("syntax error"), pos)
         pos += 1
     yield ('end', None, pos)
 
 # helpers
 
 def getstring(x, err):
     if x and (x[0] == 'string' or x[0] == 'symbol'):
         return x[1]
     raise error.ParseError(err)
 
 def getlist(x):
     if not x:
         return []
     if x[0] == 'list':
         return getlist(x[1]) + [x[2]]
     return [x]
 
 def getargs(x, min, max, err):
     l = getlist(x)
     if len(l) < min or len(l) > max:
         raise error.ParseError(err)
     return l
 
 def getset(repo, subset, x):
     if not x:
         raise error.ParseError(_("missing argument"))
     return methods[x[0]](repo, subset, *x[1:])
 
 # operator methods
 
 def stringset(repo, subset, x):
     x = repo[x].rev()
     if x == -1 and len(subset) == len(repo):
         return [-1]
     if x in subset:
         return [x]
     return []
 
 def symbolset(repo, subset, x):
     if x in symbols:
         raise error.ParseError(_("can't use %s here") % x)
     return stringset(repo, subset, x)
 
 def rangeset(repo, subset, x, y):
     m = getset(repo, subset, x)
     if not m:
         m = getset(repo, range(len(repo)), x)
 
     n = getset(repo, subset, y)
     if not n:
         n = getset(repo, range(len(repo)), y)
 
     if not m or not n:
         return []
     m, n = m[0], n[-1]
 
     if m < n:
         r = range(m, n + 1)
     else:
         r = range(m, n - 1, -1)
     s = set(subset)
     return [x for x in r if x in s]
 
 def andset(repo, subset, x, y):
     return getset(repo, getset(repo, subset, x), y)
 
 def orset(repo, subset, x, y):
     s = set(getset(repo, subset, x))
     s |= set(getset(repo, [r for r in subset if r not in s], y))
     return [r for r in subset if r in s]
 
 def notset(repo, subset, x):
     s = set(getset(repo, subset, x))
     return [r for r in subset if r not in s]
 
 def listset(repo, subset, a, b):
     raise error.ParseError(_("can't use a list in this context"))
 
 def func(repo, subset, a, b):
     if a[0] == 'symbol' and a[1] in symbols:
         return symbols[a[1]](repo, subset, b)
     raise error.ParseError(_("not a function: %s") % a[1])
 
 # functions
 
 def node(repo, subset, x):
     """``id(string)``
     Revision non-ambiguously specified by the given hex string prefix
     """
     # i18n: "id" is a keyword
     l = getargs(x, 1, 1, _("id requires one argument"))
     # i18n: "id" is a keyword
     n = getstring(l[0], _("id requires a string"))
     if len(n) == 40:
         rn = repo[n].rev()
     else:
         rn = repo.changelog.rev(repo.changelog._partialmatch(n))
     return [r for r in subset if r == rn]
 
 def rev(repo, subset, x):
     """``rev(number)``
     Revision with the given numeric identifier.
     """
     # i18n: "rev" is a keyword
     l = getargs(x, 1, 1, _("rev requires one argument"))
     try:
         # i18n: "rev" is a keyword
         l = int(getstring(l[0], _("rev requires a number")))
     except ValueError:
         # i18n: "rev" is a keyword
         raise error.ParseError(_("rev expects a number"))
     return [r for r in subset if r == l]
 
 def p1(repo, subset, x):
     """``p1(set)``
     First parent of changesets in set.
     """
     ps = set()
     cl = repo.changelog
     for r in getset(repo, range(len(repo)), x):
         ps.add(cl.parentrevs(r)[0])
     return [r for r in subset if r in ps]
 
 def p2(repo, subset, x):
     """``p2(set)``
     Second parent of changesets in set.
     """
     ps = set()
     cl = repo.changelog
     for r in getset(repo, range(len(repo)), x):
         ps.add(cl.parentrevs(r)[1])
     return [r for r in subset if r in ps]
 
 def parents(repo, subset, x):
     """``parents(set)``
     The set of all parents for all changesets in set.
     """
     ps = set()
     cl = repo.changelog
     for r in getset(repo, range(len(repo)), x):
         ps.update(cl.parentrevs(r))
     return [r for r in subset if r in ps]
 
 def maxrev(repo, subset, x):
     """``max(set)``
     Changeset with highest revision number in set.
     """
     s = getset(repo, subset, x)
     if s:
         m = max(s)
         if m in subset:
             return [m]
     return []
 
 def minrev(repo, subset, x):
     """``min(set)``
     Changeset with lowest revision number in set.
     """
     s = getset(repo, subset, x)
     if s:
         m = min(s)
         if m in subset:
             return [m]
     return []
 
 def limit(repo, subset, x):
     """``limit(set, n)``
     First n members of set.
     """
     # i18n: "limit" is a keyword
     l = getargs(x, 2, 2, _("limit requires two arguments"))
     try:
         # i18n: "limit" is a keyword
         lim = int(getstring(l[1], _("limit requires a number")))
     except ValueError:
         # i18n: "limit" is a keyword
         raise error.ParseError(_("limit expects a number"))
     return getset(repo, subset, l[0])[:lim]
 
 def children(repo, subset, x):
     """``children(set)``
     Child changesets of changesets in set.
     """
     cs = set()
     cl = repo.changelog
     s = set(getset(repo, range(len(repo)), x))
     for r in xrange(0, len(repo)):
         for p in cl.parentrevs(r):
             if p in s:
                 cs.add(r)
     return [r for r in subset if r in cs]
 
 def branch(repo, subset, x):
     """``branch(set)``
     All changesets belonging to the branches of changesets in set.
     """
     s = getset(repo, range(len(repo)), x)
     b = set()
     for r in s:
         b.add(repo[r].branch())
     s = set(s)
     return [r for r in subset if r in s or repo[r].branch() in b]
 
 def ancestor(repo, subset, x):
     """``ancestor(single, single)``
     Greatest common ancestor of the two changesets.
     """
     # i18n: "ancestor" is a keyword
     l = getargs(x, 2, 2, _("ancestor requires two arguments"))
     r = range(len(repo))
     a = getset(repo, r, l[0])
     b = getset(repo, r, l[1])
     if len(a) != 1 or len(b) != 1:
         # i18n: "ancestor" is a keyword
         raise error.ParseError(_("ancestor arguments must be single revisions"))
     an = [repo[a[0]].ancestor(repo[b[0]]).rev()]
 
     return [r for r in an if r in subset]
 
 def ancestors(repo, subset, x):
     """``ancestors(set)``
     Changesets that are ancestors of a changeset in set.
     """
     args = getset(repo, range(len(repo)), x)
     if not args:
         return []
     s = set(repo.changelog.ancestors(*args)) | set(args)
     return [r for r in subset if r in s]
 
 def descendants(repo, subset, x):
     """``descendants(set)``
     Changesets which are descendants of changesets in set.
     """
     args = getset(repo, range(len(repo)), x)
     if not args:
         return []
     s = set(repo.changelog.descendants(*args)) | set(args)
     return [r for r in subset if r in s]
 
 def follow(repo, subset, x):
     """``follow()``
     An alias for ``::.`` (ancestors of the working copy's first parent).
     """
     # i18n: "follow" is a keyword
     getargs(x, 0, 0, _("follow takes no arguments"))
     p = repo['.'].rev()
     s = set(repo.changelog.ancestors(p)) | set([p])
     return [r for r in subset if r in s]
 
 def date(repo, subset, x):
     """``date(interval)``
     Changesets within the interval, see :hg:`help dates`.
     """
     # i18n: "date" is a keyword
     ds = getstring(x, _("date requires a string"))
     dm = util.matchdate(ds)
     return [r for r in subset if dm(repo[r].date()[0])]
 
 def keyword(repo, subset, x):
     """``keyword(string)``
     Search commit message, user name, and names of changed files for
     string.
     """
     # i18n: "keyword" is a keyword
     kw = getstring(x, _("keyword requires a string")).lower()
     l = []
     for r in subset:
         c = repo[r]
         t = " ".join(c.files() + [c.user(), c.description()])
         if kw in t.lower():
             l.append(r)
     return l
 
 def grep(repo, subset, x):
     """``grep(regex)``
     Like ``keyword(string)`` but accepts a regex. Use ``grep(r'...')``
     to ensure special escape characters are handled correctly.
     """
     try:
         # i18n: "grep" is a keyword
         gr = re.compile(getstring(x, _("grep requires a string")))
     except re.error, e:
         raise error.ParseError(_('invalid match pattern: %s') % e)
     l = []
     for r in subset:
         c = repo[r]
         for e in c.files() + [c.user(), c.description()]:
             if gr.search(e):
                 l.append(r)
                 continue
     return l
 
 def author(repo, subset, x):
     """``author(string)``
     Alias for ``user(string)``.
     """
     # i18n: "author" is a keyword
     n = getstring(x, _("author requires a string")).lower()
     return [r for r in subset if n in repo[r].user().lower()]
 
 def user(repo, subset, x):
     """``user(string)``
     User name is string.
     """
     return author(repo, subset, x)
 
 def hasfile(repo, subset, x):
     """``file(pattern)``
     Changesets affecting files matched by pattern.
     """
     # i18n: "file" is a keyword
     pat = getstring(x, _("file requires a pattern"))
     m = matchmod.match(repo.root, repo.getcwd(), [pat])
     s = []
     for r in subset:
         for f in repo[r].files():
             if m(f):
                 s.append(r)
                 continue
     return s
 
 def contains(repo, subset, x):
     """``contains(pattern)``
     Revision contains pattern.
     """
     # i18n: "contains" is a keyword
     pat = getstring(x, _("contains requires a pattern"))
     m = matchmod.match(repo.root, repo.getcwd(), [pat])
     s = []
     if m.files() == [pat]:
         for r in subset:
             if pat in repo[r]:
                 s.append(r)
                 continue
     else:
         for r in subset:
             for f in repo[r].manifest():
                 if m(f):
                     s.append(r)
                     continue
     return s
 
 def checkstatus(repo, subset, pat, field):
     m = matchmod.match(repo.root, repo.getcwd(), [pat])
     s = []
     fast = (m.files() == [pat])
     for r in subset:
         c = repo[r]
         if fast:
             if pat not in c.files():
                 continue
         else:
             for f in c.files():
                 if m(f):
                     break
             else:
                 continue
         files = repo.status(c.p1().node(), c.node())[field]
         if fast:
             if pat in files:
                 s.append(r)
                 continue
         else:
             for f in files:
                 if m(f):
                     s.append(r)
                     continue
     return s
 
 def modifies(repo, subset, x):
     """``modifies(pattern)``
     Changesets modifying files matched by pattern.
     """
     # i18n: "modifies" is a keyword
     pat = getstring(x, _("modifies requires a pattern"))
     return checkstatus(repo, subset, pat, 0)
 
 def adds(repo, subset, x):
     """``adds(pattern)``
     Changesets that add a file matching pattern.
     """
     # i18n: "adds" is a keyword
     pat = getstring(x, _("adds requires a pattern"))
     return checkstatus(repo, subset, pat, 1)
 
 def removes(repo, subset, x):
     """``removes(pattern)``
     Changesets which remove files matching pattern.
     """
     # i18n: "removes" is a keyword
     pat = getstring(x, _("removes requires a pattern"))
     return checkstatus(repo, subset, pat, 2)
 
 def merge(repo, subset, x):
     """``merge()``
     Changeset is a merge changeset.
     """
     # i18n: "merge" is a keyword
     getargs(x, 0, 0, _("merge takes no arguments"))
     cl = repo.changelog
     return [r for r in subset if cl.parentrevs(r)[1] != -1]
 
 def closed(repo, subset, x):
     """``closed()``
     Changeset is closed.
     """
     # i18n: "closed" is a keyword
     getargs(x, 0, 0, _("closed takes no arguments"))
     return [r for r in subset if repo[r].extra().get('close')]
 
 def head(repo, subset, x):
     """``head()``
     Changeset is a named branch head.
     """
     # i18n: "head" is a keyword
     getargs(x, 0, 0, _("head takes no arguments"))
     hs = set()
     for b, ls in repo.branchmap().iteritems():
         hs.update(repo[h].rev() for h in ls)
     return [r for r in subset if r in hs]
 
 def reverse(repo, subset, x):
     """``reverse(set)``
     Reverse order of set.
     """
     l = getset(repo, subset, x)
     l.reverse()
     return l
 
 def present(repo, subset, x):
     """``present(set)``
     An empty set, if any revision in set isn't found; otherwise,
     all revisions in set.
     """
     try:
         return getset(repo, subset, x)
     except error.RepoLookupError:
         return []
 
 def sort(repo, subset, x):
     """``sort(set[, [-]key...])``
     Sort set by keys. The default sort order is ascending, specify a key
     as ``-key`` to sort in descending order.
 
     The keys can be:
 
     - ``rev`` for the revision number,
     - ``branch`` for the branch name,
     - ``desc`` for the commit message (description),
     - ``user`` for user name (``author`` can be used as an alias),
     - ``date`` for the commit date
     """
     # i18n: "sort" is a keyword
     l = getargs(x, 1, 2, _("sort requires one or two arguments"))
     keys = "rev"
     if len(l) == 2:
         keys = getstring(l[1], _("sort spec must be a string"))
 
     s = l[0]
     keys = keys.split()
     l = []
     def invert(s):
         return "".join(chr(255 - ord(c)) for c in s)
     for r in getset(repo, subset, s):
         c = repo[r]
         e = []
         for k in keys:
             if k == 'rev':
                 e.append(r)
             elif k == '-rev':
                 e.append(-r)
             elif k == 'branch':
                 e.append(c.branch())
             elif k == '-branch':
                 e.append(invert(c.branch()))
             elif k == 'desc':
                 e.append(c.description())
             elif k == '-desc':
                 e.append(invert(c.description()))
             elif k in 'user author':
                 e.append(c.user())
             elif k in '-user -author':
                 e.append(invert(c.user()))
             elif k == 'date':
                 e.append(c.date()[0])
             elif k == '-date':
                 e.append(-c.date()[0])
             else:
                 raise error.ParseError(_("unknown sort key %r") % k)
         e.append(r)
         l.append(e)
     l.sort()
     return [e[-1] for e in l]
 
 def getall(repo, subset, x):
     """``all()``
     All changesets, the same as ``0:tip``.
     """
     # i18n: "all" is a keyword
     getargs(x, 0, 0, _("all takes no arguments"))
     return subset
 
 def heads(repo, subset, x):
     """``heads(set)``
     Members of set with no children in set.
     """
     s = getset(repo, subset, x)
     ps = set(parents(repo, subset, x))
     return [r for r in s if r not in ps]
 
 def roots(repo, subset, x):
     """``roots(set)``
     Changesets with no parent changeset in set.
     """
     s = getset(repo, subset, x)
     cs = set(children(repo, subset, x))
     return [r for r in s if r not in cs]
 
 def outgoing(repo, subset, x):
     """``outgoing([path])``
     Changesets not found in the specified destination repository, or the
     default push location.
     """
     import hg # avoid start-up nasties
     # i18n: "outgoing" is a keyword
     l = getargs(x, 0, 1, _("outgoing requires a repository path"))
     # i18n: "outgoing" is a keyword
     dest = l and getstring(l[0], _("outgoing requires a repository path")) or ''
     dest = repo.ui.expandpath(dest or 'default-push', dest or 'default')
     dest, branches = hg.parseurl(dest)
     revs, checkout = hg.addbranchrevs(repo, repo, branches, [])
     if revs:
         revs = [repo.lookup(rev) for rev in revs]
     other = hg.repository(hg.remoteui(repo, {}), dest)
     repo.ui.pushbuffer()
     o = discovery.findoutgoing(repo, other)
     repo.ui.popbuffer()
     cl = repo.changelog
     o = set([cl.rev(r) for r in repo.changelog.nodesbetween(o, revs)[0]])
     return [r for r in subset if r in o]
 
 def tag(repo, subset, x):
     """``tag(name)``
     The specified tag by name, or all tagged revisions if no name is given.
     """
     # i18n: "tag" is a keyword
     args = getargs(x, 0, 1, _("tag takes one or no arguments"))
     cl = repo.changelog
     if args:
         tn = getstring(args[0],
                        # i18n: "tag" is a keyword
                        _('the argument to tag must be a string'))
         s = set([cl.rev(n) for t, n in repo.tagslist() if t == tn])
     else:
         s = set([cl.rev(n) for t, n in repo.tagslist() if t != 'tip'])
     return [r for r in subset if r in s]
 
 def tagged(repo, subset, x):
     return tag(repo, subset, x)
 
 symbols = {
     "adds": adds,
     "all": getall,
     "ancestor": ancestor,
     "ancestors": ancestors,
     "author": author,
     "branch": branch,
     "children": children,
     "closed": closed,
     "contains": contains,
     "date": date,
     "descendants": descendants,
     "file": hasfile,
     "follow": follow,
     "grep": grep,
     "head": head,
     "heads": heads,
     "keyword": keyword,
     "limit": limit,
     "max": maxrev,
     "min": minrev,
     "merge": merge,
     "modifies": modifies,
     "id": node,
     "outgoing": outgoing,
     "p1": p1,
     "p2": p2,
     "parents": parents,
     "present": present,
     "removes": removes,
     "reverse": reverse,
     "rev": rev,
     "roots": roots,
     "sort": sort,
     "tag": tag,
     "tagged": tagged,
     "user": user,
 }
 
 methods = {
     "range": rangeset,
     "string": stringset,
     "symbol": symbolset,
     "and": andset,
     "or": orset,
     "not": notset,
     "list": listset,
     "func": func,
 }
 
 def optimize(x, small):
     if x == None:
         return 0, x
 
     smallbonus = 1
     if small:
         smallbonus = .5
 
     op = x[0]
     if op == 'minus':
         return optimize(('and', x[1], ('not', x[2])), small)
     elif op == 'dagrange':
         return optimize(('and', ('func', ('symbol', 'descendants'), x[1]),
                          ('func', ('symbol', 'ancestors'), x[2])), small)
     elif op == 'dagrangepre':
         return optimize(('func', ('symbol', 'ancestors'), x[1]), small)
     elif op == 'dagrangepost':
         return optimize(('func', ('symbol', 'descendants'), x[1]), small)
     elif op == 'rangepre':
         return optimize(('range', ('string', '0'), x[1]), small)
     elif op == 'rangepost':
         return optimize(('range', x[1], ('string', 'tip')), small)
     elif op == 'negate':
         return optimize(('string',
                          '-' + getstring(x[1], _("can't negate that"))), small)
     elif op in 'string symbol negate':
         return smallbonus, x # single revisions are small
     elif op == 'and' or op == 'dagrange':
         wa, ta = optimize(x[1], True)
         wb, tb = optimize(x[2], True)
         w = min(wa, wb)
         if wa > wb:
             return w, (op, tb, ta)
         return w, (op, ta, tb)
     elif op == 'or':
         wa, ta = optimize(x[1], False)
         wb, tb = optimize(x[2], False)
         if wb < wa:
             wb, wa = wa, wb
         return max(wa, wb), (op, ta, tb)
     elif op == 'not':
         o = optimize(x[1], not small)
         return o[0], (op, o[1])
     elif op == 'group':
         return optimize(x[1], small)
     elif op in 'range list':
         wa, ta = optimize(x[1], small)
         wb, tb = optimize(x[2], small)
         return wa + wb, (op, ta, tb)
     elif op == 'func':
         f = getstring(x[1], _("not a symbol"))
         wa, ta = optimize(x[2], small)
         if f in "grep date user author keyword branch file outgoing":
             w = 10 # slow
         elif f in "modifies adds removes":
             w = 30 # slower
         elif f == "contains":
             w = 100 # very slow
         elif f == "ancestor":
             w = 1 * smallbonus
         elif f == "reverse limit":
             w = 0
         elif f in "sort":
             w = 10 # assume most sorts look at changelog
         else:
             w = 1
         return w + wa, (op, x[1], ta)
     return 1, x
 
 parse = parser.parser(tokenize, elements).parse
 
 def match(spec):
     if not spec:
         raise error.ParseError(_("empty query"))
     tree = parse(spec)
     weight, tree = optimize(tree, True)
     def mfunc(repo, subset):
         return getset(repo, subset, tree)
     return mfunc
 
 def makedoc(topic, doc):
     """Generate and include predicates help in revsets topic."""
     predicates = []
     for name in sorted(symbols):
         text = symbols[name].__doc__
         if not text:
             continue
         lines = text.splitlines()
         lines[1:] = [('  ' + l.strip()) for l in lines[1:]]
         predicates.append('\n'.join(lines))
     predicates = '\n'.join(predicates)
     doc = doc.replace('.. predicatesmarker', predicates)
     return doc
+
+# tell hggettext to extract docstrings from these functions:
+i18nfunctions = symbols.values()