extensions: document that `testedwith = 'internal'` is special

Extension authors (notably at companies using hg) have been
cargo-culting the `testedwith = 'internal'` bit from hg's own
extensions, which then defeats our "file bugs over here" logic in
dispatch. Let's be more aggressive about trying to give extension
authors a hint about what testedwith should say.

contrib/synthrepo.py

@@ -1,491 +1,495 b''
 # synthrepo.py - repo synthesis
 #
 # Copyright 2012 Facebook
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 '''synthesize structurally interesting change history
 
 This extension is useful for creating a repository with properties
 that are statistically similar to an existing repository. During
 analysis, a simple probability table is constructed from the history
 of an existing repository.  During synthesis, these properties are
 reconstructed.
 
 Properties that are analyzed and synthesized include the following:
 
 - Lines added or removed when an existing file is modified
 - Number and sizes of files added
 - Number of files removed
 - Line lengths
 - Topological distance to parent changeset(s)
 - Probability of a commit being a merge
 - Probability of a newly added file being added to a new directory
 - Interarrival time, and time zone, of commits
 - Number of files in each directory
 
 A few obvious properties that are not currently handled realistically:
 
 - Merges are treated as regular commits with two parents, which is not
   realistic
 - Modifications are not treated as operations on hunks of lines, but
   as insertions and deletions of randomly chosen single lines
 - Committer ID (always random)
 - Executability of files
 - Symlinks and binary files are ignored
 '''
 
 import bisect, collections, itertools, json, os, random, time, sys
 from mercurial import cmdutil, context, patch, scmutil, util, hg
 from mercurial.i18n import _
 from mercurial.node import nullrev, nullid, short
 
+# Note for extension authors: ONLY specify testedwith = 'internal' for
+# extensions which SHIP WITH MERCURIAL. Non-mainline extensions should
+# be specifying the version(s) of Mercurial they are tested with, or
+# leave the attribute unspecified.
 testedwith = 'internal'
 
 cmdtable = {}
 command = cmdutil.command(cmdtable)
 
 newfile = set(('new fi', 'rename', 'copy f', 'copy t'))
 
 def zerodict():
     return collections.defaultdict(lambda: 0)
 
 def roundto(x, k):
     if x > k * 2:
         return int(round(x / float(k)) * k)
     return int(round(x))
 
 def parsegitdiff(lines):
     filename, mar, lineadd, lineremove = None, None, zerodict(), 0
     binary = False
     for line in lines:
         start = line[:6]
         if start == 'diff -':
             if filename:
                 yield filename, mar, lineadd, lineremove, binary
             mar, lineadd, lineremove, binary = 'm', zerodict(), 0, False
             filename = patch.gitre.match(line).group(1)
         elif start in newfile:
             mar = 'a'
         elif start == 'GIT bi':
             binary = True
         elif start == 'delete':
             mar = 'r'
         elif start:
             s = start[0]
             if s == '-' and not line.startswith('--- '):
                 lineremove += 1
             elif s == '+' and not line.startswith('+++ '):
                 lineadd[roundto(len(line) - 1, 5)] += 1
     if filename:
         yield filename, mar, lineadd, lineremove, binary
 
 @command('analyze',
          [('o', 'output', '', _('write output to given file'), _('FILE')),
           ('r', 'rev', [], _('analyze specified revisions'), _('REV'))],
          _('hg analyze'), optionalrepo=True)
 def analyze(ui, repo, *revs, **opts):
     '''create a simple model of a repository to use for later synthesis
 
     This command examines every changeset in the given range (or all
     of history if none are specified) and creates a simple statistical
     model of the history of the repository. It also measures the directory
     structure of the repository as checked out.
 
     The model is written out to a JSON file, and can be used by
     :hg:`synthesize` to create or augment a repository with synthetic
     commits that have a structure that is statistically similar to the
     analyzed repository.
     '''
     root = repo.root
     if not root.endswith(os.path.sep):
         root += os.path.sep
 
     revs = list(revs)
     revs.extend(opts['rev'])
     if not revs:
         revs = [':']
 
     output = opts['output']
     if not output:
         output = os.path.basename(root) + '.json'
 
     if output == '-':
         fp = sys.stdout
     else:
         fp = open(output, 'w')
 
     # Always obtain file counts of each directory in the given root directory.
     def onerror(e):
         ui.warn(_('error walking directory structure: %s\n') % e)
 
     dirs = {}
     rootprefixlen = len(root)
     for dirpath, dirnames, filenames in os.walk(root, onerror=onerror):
         dirpathfromroot = dirpath[rootprefixlen:]
         dirs[dirpathfromroot] = len(filenames)
         if '.hg' in dirnames:
             dirnames.remove('.hg')
 
     lineschanged = zerodict()
     children = zerodict()
     p1distance = zerodict()
     p2distance = zerodict()
     linesinfilesadded = zerodict()
     fileschanged = zerodict()
     filesadded = zerodict()
     filesremoved = zerodict()
     linelengths = zerodict()
     interarrival = zerodict()
     parents = zerodict()
     dirsadded = zerodict()
     tzoffset = zerodict()
 
     # If a mercurial repo is available, also model the commit history.
     if repo:
         revs = scmutil.revrange(repo, revs)
         revs.sort()
 
         progress = ui.progress
         _analyzing = _('analyzing')
         _changesets = _('changesets')
         _total = len(revs)
 
         for i, rev in enumerate(revs):
             progress(_analyzing, i, unit=_changesets, total=_total)
             ctx = repo[rev]
             pl = ctx.parents()
             pctx = pl[0]
             prev = pctx.rev()
             children[prev] += 1
             p1distance[rev - prev] += 1
             parents[len(pl)] += 1
             tzoffset[ctx.date()[1]] += 1
             if len(pl) > 1:
                 p2distance[rev - pl[1].rev()] += 1
             if prev == rev - 1:
                 lastctx = pctx
             else:
                 lastctx = repo[rev - 1]
             if lastctx.rev() != nullrev:
                 timedelta = ctx.date()[0] - lastctx.date()[0]
                 interarrival[roundto(timedelta, 300)] += 1
             diff = sum((d.splitlines() for d in ctx.diff(pctx, git=True)), [])
             fileadds, diradds, fileremoves, filechanges = 0, 0, 0, 0
             for filename, mar, lineadd, lineremove, isbin in parsegitdiff(diff):
                 if isbin:
                     continue
                 added = sum(lineadd.itervalues(), 0)
                 if mar == 'm':
                     if added and lineremove:
                         lineschanged[roundto(added, 5),
                                      roundto(lineremove, 5)] += 1
                         filechanges += 1
                 elif mar == 'a':
                     fileadds += 1
                     if '/' in filename:
                         filedir = filename.rsplit('/', 1)[0]
                         if filedir not in pctx.dirs():
                             diradds += 1
                     linesinfilesadded[roundto(added, 5)] += 1
                 elif mar == 'r':
                     fileremoves += 1
                 for length, count in lineadd.iteritems():
                     linelengths[length] += count
             fileschanged[filechanges] += 1
             filesadded[fileadds] += 1
             dirsadded[diradds] += 1
             filesremoved[fileremoves] += 1
 
     invchildren = zerodict()
 
     for rev, count in children.iteritems():
         invchildren[count] += 1
 
     if output != '-':
         ui.status(_('writing output to %s\n') % output)
 
     def pronk(d):
         return sorted(d.iteritems(), key=lambda x: x[1], reverse=True)
 
     json.dump({'revs': len(revs),
                'initdirs': pronk(dirs),
                'lineschanged': pronk(lineschanged),
                'children': pronk(invchildren),
                'fileschanged': pronk(fileschanged),
                'filesadded': pronk(filesadded),
                'linesinfilesadded': pronk(linesinfilesadded),
                'dirsadded': pronk(dirsadded),
                'filesremoved': pronk(filesremoved),
                'linelengths': pronk(linelengths),
                'parents': pronk(parents),
                'p1distance': pronk(p1distance),
                'p2distance': pronk(p2distance),
                'interarrival': pronk(interarrival),
                'tzoffset': pronk(tzoffset),
                },
               fp)
     fp.close()
 
 @command('synthesize',
          [('c', 'count', 0, _('create given number of commits'), _('COUNT')),
           ('', 'dict', '', _('path to a dictionary of words'), _('FILE')),
           ('', 'initfiles', 0, _('initial file count to create'), _('COUNT'))],
          _('hg synthesize [OPTION].. DESCFILE'))
 def synthesize(ui, repo, descpath, **opts):
     '''synthesize commits based on a model of an existing repository
 
     The model must have been generated by :hg:`analyze`. Commits will
     be generated randomly according to the probabilities described in
     the model. If --initfiles is set, the repository will be seeded with
     the given number files following the modeled repository's directory
     structure.
 
     When synthesizing new content, commit descriptions, and user
     names, words will be chosen randomly from a dictionary that is
     presumed to contain one word per line. Use --dict to specify the
     path to an alternate dictionary to use.
     '''
     try:
         fp = hg.openpath(ui, descpath)
     except Exception, err:
         raise util.Abort('%s: %s' % (descpath, err[0].strerror))
     desc = json.load(fp)
     fp.close()
 
     def cdf(l):
         if not l:
             return [], []
         vals, probs = zip(*sorted(l, key=lambda x: x[1], reverse=True))
         t = float(sum(probs, 0))
         s, cdfs = 0, []
         for v in probs:
             s += v
             cdfs.append(s / t)
         return vals, cdfs
 
     lineschanged = cdf(desc['lineschanged'])
     fileschanged = cdf(desc['fileschanged'])
     filesadded = cdf(desc['filesadded'])
     dirsadded = cdf(desc['dirsadded'])
     filesremoved = cdf(desc['filesremoved'])
     linelengths = cdf(desc['linelengths'])
     parents = cdf(desc['parents'])
     p1distance = cdf(desc['p1distance'])
     p2distance = cdf(desc['p2distance'])
     interarrival = cdf(desc['interarrival'])
     linesinfilesadded = cdf(desc['linesinfilesadded'])
     tzoffset = cdf(desc['tzoffset'])
 
     dictfile = opts.get('dict') or '/usr/share/dict/words'
     try:
         fp = open(dictfile, 'rU')
     except IOError, err:
         raise util.Abort('%s: %s' % (dictfile, err.strerror))
     words = fp.read().splitlines()
     fp.close()
 
     initdirs = {}
     if desc['initdirs']:
         for k, v in desc['initdirs']:
             initdirs[k.encode('utf-8').replace('.hg', '_hg')] = v
         initdirs = renamedirs(initdirs, words)
     initdirscdf = cdf(initdirs)
 
     def pick(cdf):
         return cdf[0][bisect.bisect_left(cdf[1], random.random())]
 
     def pickpath():
         return os.path.join(pick(initdirscdf), random.choice(words))
 
     def makeline(minimum=0):
         total = max(minimum, pick(linelengths))
         c, l = 0, []
         while c < total:
             w = random.choice(words)
             c += len(w) + 1
             l.append(w)
         return ' '.join(l)
 
     wlock = repo.wlock()
     lock = repo.lock()
 
     nevertouch = set(('.hgsub', '.hgignore', '.hgtags'))
 
     progress = ui.progress
     _synthesizing = _('synthesizing')
     _files = _('initial files')
     _changesets = _('changesets')
 
     # Synthesize a single initial revision adding files to the repo according
     # to the modeled directory structure.
     initcount = int(opts['initfiles'])
     if initcount and initdirs:
         pctx = repo[None].parents()[0]
         dirs = set(pctx.dirs())
         files = {}
 
         def validpath(path):
             # Don't pick filenames which are already directory names.
             if path in dirs:
                 return False
             # Don't pick directories which were used as file names.
             while path:
                 if path in files:
                     return False
                 path = os.path.dirname(path)
             return True
 
         for i in xrange(0, initcount):
             ui.progress(_synthesizing, i, unit=_files, total=initcount)
 
             path = pickpath()
             while not validpath(path):
                 path = pickpath()
             data = '%s contents\n' % path
             files[path] = context.memfilectx(repo, path, data)
             dir = os.path.dirname(path)
             while dir and dir not in dirs:
                 dirs.add(dir)
                 dir = os.path.dirname(dir)
 
         def filectxfn(repo, memctx, path):
             return files[path]
 
         ui.progress(_synthesizing, None)
         message = 'synthesized wide repo with %d files' % (len(files),)
         mc = context.memctx(repo, [pctx.node(), nullid], message,
                             files.iterkeys(), filectxfn, ui.username(),
                             '%d %d' % util.makedate())
         initnode = mc.commit()
         if ui.debugflag:
             hexfn = hex
         else:
             hexfn = short
         ui.status(_('added commit %s with %d files\n')
                   % (hexfn(initnode), len(files)))
 
     # Synthesize incremental revisions to the repository, adding repo depth.
     count = int(opts['count'])
     heads = set(map(repo.changelog.rev, repo.heads()))
     for i in xrange(count):
         progress(_synthesizing, i, unit=_changesets, total=count)
 
         node = repo.changelog.node
         revs = len(repo)
 
         def pickhead(heads, distance):
             if heads:
                 lheads = sorted(heads)
                 rev = revs - min(pick(distance), revs)
                 if rev < lheads[-1]:
                     rev = lheads[bisect.bisect_left(lheads, rev)]
                 else:
                     rev = lheads[-1]
                 return rev, node(rev)
             return nullrev, nullid
 
         r1 = revs - min(pick(p1distance), revs)
         p1 = node(r1)
 
         # the number of heads will grow without bound if we use a pure
         # model, so artificially constrain their proliferation
         toomanyheads = len(heads) > random.randint(1, 20)
         if p2distance[0] and (pick(parents) == 2 or toomanyheads):
             r2, p2 = pickhead(heads.difference([r1]), p2distance)
         else:
             r2, p2 = nullrev, nullid
 
         pl = [p1, p2]
         pctx = repo[r1]
         mf = pctx.manifest()
         mfk = mf.keys()
         changes = {}
         if mfk:
             for __ in xrange(pick(fileschanged)):
                 for __ in xrange(10):
                     fctx = pctx.filectx(random.choice(mfk))
                     path = fctx.path()
                     if not (path in nevertouch or fctx.isbinary() or
                             'l' in fctx.flags()):
                         break
                 lines = fctx.data().splitlines()
                 add, remove = pick(lineschanged)
                 for __ in xrange(remove):
                     if not lines:
                         break
                     del lines[random.randrange(0, len(lines))]
                 for __ in xrange(add):
                     lines.insert(random.randint(0, len(lines)), makeline())
                 path = fctx.path()
                 changes[path] = context.memfilectx(repo, path,
                                                    '\n'.join(lines) + '\n')
             for __ in xrange(pick(filesremoved)):
                 path = random.choice(mfk)
                 for __ in xrange(10):
                     path = random.choice(mfk)
                     if path not in changes:
                         changes[path] = None
                         break
         if filesadded:
             dirs = list(pctx.dirs())
             dirs.insert(0, '')
         for __ in xrange(pick(filesadded)):
             pathstr = ''
             while pathstr in dirs:
                 path = [random.choice(dirs)]
                 if pick(dirsadded):
                     path.append(random.choice(words))
                 path.append(random.choice(words))
                 pathstr = '/'.join(filter(None, path))
             data = '\n'.join(makeline()
                              for __ in xrange(pick(linesinfilesadded))) + '\n'
             changes[pathstr] = context.memfilectx(repo, pathstr, data)
         def filectxfn(repo, memctx, path):
             return changes[path]
         if not changes:
             continue
         if revs:
             date = repo['tip'].date()[0] + pick(interarrival)
         else:
             date = time.time() - (86400 * count)
         # dates in mercurial must be positive, fit in 32-bit signed integers.
         date = min(0x7fffffff, max(0, date))
         user = random.choice(words) + '@' + random.choice(words)
         mc = context.memctx(repo, pl, makeline(minimum=2),
                             sorted(changes.iterkeys()),
                             filectxfn, user, '%d %d' % (date, pick(tzoffset)))
         newnode = mc.commit()
         heads.add(repo.changelog.rev(newnode))
         heads.discard(r1)
         heads.discard(r2)
 
     lock.release()
     wlock.release()
 
 def renamedirs(dirs, words):
     '''Randomly rename the directory names in the per-dir file count dict.'''
     wordgen = itertools.cycle(words)
     replacements = {'': ''}
     def rename(dirpath):
         '''Recursively rename the directory and all path prefixes.
 
         The mapping from path to renamed path is stored for all path prefixes
         as in dynamic programming, ensuring linear runtime and consistent
         renaming regardless of iteration order through the model.
         '''
         if dirpath in replacements:
             return replacements[dirpath]
         head, _ = os.path.split(dirpath)
         if head:
             head = rename(head)
         else:
             head = ''
         renamed = os.path.join(head, wordgen.next())
         replacements[dirpath] = renamed
         return renamed
     result = []
     for dirpath, count in dirs.iteritems():
         result.append([rename(dirpath.lstrip(os.sep)), count])
     return result

hgext/acl.py

@@ -1,316 +1,320 b''
 # acl.py - changeset access control for mercurial
 #
 # Copyright 2006 Vadim Gelfer <[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.
 
 '''hooks for controlling repository access
 
 This hook makes it possible to allow or deny write access to given
 branches and paths of a repository when receiving incoming changesets
 via pretxnchangegroup and pretxncommit.
 
 The authorization is matched based on the local user name on the
 system where the hook runs, and not the committer of the original
 changeset (since the latter is merely informative).
 
 The acl hook is best used along with a restricted shell like hgsh,
 preventing authenticating users from doing anything other than pushing
 or pulling. The hook is not safe to use if users have interactive
 shell access, as they can then disable the hook. Nor is it safe if
 remote users share an account, because then there is no way to
 distinguish them.
 
 The order in which access checks are performed is:
 
 1) Deny  list for branches (section ``acl.deny.branches``)
 2) Allow list for branches (section ``acl.allow.branches``)
 3) Deny  list for paths    (section ``acl.deny``)
 4) Allow list for paths    (section ``acl.allow``)
 
 The allow and deny sections take key-value pairs.
 
 Branch-based Access Control
 ---------------------------
 
 Use the ``acl.deny.branches`` and ``acl.allow.branches`` sections to
 have branch-based access control. Keys in these sections can be
 either:
 
 - a branch name, or
 - an asterisk, to match any branch;
 
 The corresponding values can be either:
 
 - a comma-separated list containing users and groups, or
 - an asterisk, to match anyone;
 
 You can add the "!" prefix to a user or group name to invert the sense
 of the match.
 
 Path-based Access Control
 -------------------------
 
 Use the ``acl.deny`` and ``acl.allow`` sections to have path-based
 access control. Keys in these sections accept a subtree pattern (with
 a glob syntax by default). The corresponding values follow the same
 syntax as the other sections above.
 
 Groups
 ------
 
 Group names must be prefixed with an ``@`` symbol. Specifying a group
 name has the same effect as specifying all the users in that group.
 
 You can define group members in the ``acl.groups`` section.
 If a group name is not defined there, and Mercurial is running under
 a Unix-like system, the list of users will be taken from the OS.
 Otherwise, an exception will be raised.
 
 Example Configuration
 ---------------------
 
 ::
 
   [hooks]
 
   # Use this if you want to check access restrictions at commit time
   pretxncommit.acl = python:hgext.acl.hook
 
   # Use this if you want to check access restrictions for pull, push,
   # bundle and serve.
   pretxnchangegroup.acl = python:hgext.acl.hook
 
   [acl]
   # Allow or deny access for incoming changes only if their source is
   # listed here, let them pass otherwise. Source is "serve" for all
   # remote access (http or ssh), "push", "pull" or "bundle" when the
   # related commands are run locally.
   # Default: serve
   sources = serve
 
   [acl.deny.branches]
 
   # Everyone is denied to the frozen branch:
   frozen-branch = *
 
   # A bad user is denied on all branches:
   * = bad-user
 
   [acl.allow.branches]
 
   # A few users are allowed on branch-a:
   branch-a = user-1, user-2, user-3
 
   # Only one user is allowed on branch-b:
   branch-b = user-1
 
   # The super user is allowed on any branch:
   * = super-user
 
   # Everyone is allowed on branch-for-tests:
   branch-for-tests = *
 
   [acl.deny]
   # This list is checked first. If a match is found, acl.allow is not
   # checked. All users are granted access if acl.deny is not present.
   # Format for both lists: glob pattern = user, ..., @group, ...
 
   # To match everyone, use an asterisk for the user:
   # my/glob/pattern = *
 
   # user6 will not have write access to any file:
   ** = user6
 
   # Group "hg-denied" will not have write access to any file:
   ** = @hg-denied
 
   # Nobody will be able to change "DONT-TOUCH-THIS.txt", despite
   # everyone being able to change all other files. See below.
   src/main/resources/DONT-TOUCH-THIS.txt = *
 
   [acl.allow]
   # if acl.allow is not present, all users are allowed by default
   # empty acl.allow = no users allowed
 
   # User "doc_writer" has write access to any file under the "docs"
   # folder:
   docs/** = doc_writer
 
   # User "jack" and group "designers" have write access to any file
   # under the "images" folder:
   images/** = jack, @designers
 
   # Everyone (except for "user6" and "@hg-denied" - see acl.deny above)
   # will have write access to any file under the "resources" folder
   # (except for 1 file. See acl.deny):
   src/main/resources/** = *
 
   .hgtags = release_engineer
 
 Examples using the "!" prefix
 .............................
 
 Suppose there's a branch that only a given user (or group) should be able to
 push to, and you don't want to restrict access to any other branch that may
 be created.
 
 The "!" prefix allows you to prevent anyone except a given user or group to
 push changesets in a given branch or path.
 
 In the examples below, we will:
 1) Deny access to branch "ring" to anyone but user "gollum"
 2) Deny access to branch "lake" to anyone but members of the group "hobbit"
 3) Deny access to a file to anyone but user "gollum"
 
 ::
 
   [acl.allow.branches]
   # Empty
 
   [acl.deny.branches]
 
   # 1) only 'gollum' can commit to branch 'ring';
   # 'gollum' and anyone else can still commit to any other branch.
   ring = !gollum
 
   # 2) only members of the group 'hobbit' can commit to branch 'lake';
   # 'hobbit' members and anyone else can still commit to any other branch.
   lake = !@hobbit
 
   # You can also deny access based on file paths:
 
   [acl.allow]
   # Empty
 
   [acl.deny]
   # 3) only 'gollum' can change the file below;
   # 'gollum' and anyone else can still change any other file.
   /misty/mountains/cave/ring = !gollum
 
 '''
 
 from mercurial.i18n import _
 from mercurial import util, match
 import getpass, urllib
 
+# Note for extension authors: ONLY specify testedwith = 'internal' for
+# extensions which SHIP WITH MERCURIAL. Non-mainline extensions should
+# be specifying the version(s) of Mercurial they are tested with, or
+# leave the attribute unspecified.
 testedwith = 'internal'
 
 def _getusers(ui, group):
 
     # First, try to use group definition from section [acl.groups]
     hgrcusers = ui.configlist('acl.groups', group)
     if hgrcusers:
         return hgrcusers
 
     ui.debug('acl: "%s" not defined in [acl.groups]\n' % group)
     # If no users found in group definition, get users from OS-level group
     try:
         return util.groupmembers(group)
     except KeyError:
         raise util.Abort(_("group '%s' is undefined") % group)
 
 def _usermatch(ui, user, usersorgroups):
 
     if usersorgroups == '*':
         return True
 
     for ug in usersorgroups.replace(',', ' ').split():
 
         if ug.startswith('!'):
             # Test for excluded user or group. Format:
             # if ug is a user  name: !username
             # if ug is a group name: !@groupname
             ug = ug[1:]
             if not ug.startswith('@') and user != ug \
                 or ug.startswith('@') and user not in _getusers(ui, ug[1:]):
                 return True
 
         # Test for user or group. Format:
         # if ug is a user  name: username
         # if ug is a group name: @groupname
         elif user == ug \
              or ug.startswith('@') and user in _getusers(ui, ug[1:]):
             return True
 
     return False
 
 def buildmatch(ui, repo, user, key):
     '''return tuple of (match function, list enabled).'''
     if not ui.has_section(key):
         ui.debug('acl: %s not enabled\n' % key)
         return None
 
     pats = [pat for pat, users in ui.configitems(key)
             if _usermatch(ui, user, users)]
     ui.debug('acl: %s enabled, %d entries for user %s\n' %
              (key, len(pats), user))
 
     # Branch-based ACL
     if not repo:
         if pats:
             # If there's an asterisk (meaning "any branch"), always return True;
             # Otherwise, test if b is in pats
             if '*' in pats:
                 return util.always
             return lambda b: b in pats
         return util.never
 
     # Path-based ACL
     if pats:
         return match.match(repo.root, '', pats)
     return util.never
 
 def hook(ui, repo, hooktype, node=None, source=None, **kwargs):
     if hooktype not in ['pretxnchangegroup', 'pretxncommit']:
         raise util.Abort(_('config error - hook type "%s" cannot stop '
                            'incoming changesets nor commits') % hooktype)
     if (hooktype == 'pretxnchangegroup' and
         source not in ui.config('acl', 'sources', 'serve').split()):
         ui.debug('acl: changes have source "%s" - skipping\n' % source)
         return
 
     user = None
     if source == 'serve' and 'url' in kwargs:
         url = kwargs['url'].split(':')
         if url[0] == 'remote' and url[1].startswith('http'):
             user = urllib.unquote(url[3])
 
     if user is None:
         user = getpass.getuser()
 
     ui.debug('acl: checking access for user "%s"\n' % user)
 
     cfg = ui.config('acl', 'config')
     if cfg:
         ui.readconfig(cfg, sections=['acl.groups', 'acl.allow.branches',
             'acl.deny.branches', 'acl.allow', 'acl.deny'])
 
     allowbranches = buildmatch(ui, None, user, 'acl.allow.branches')
     denybranches = buildmatch(ui, None, user, 'acl.deny.branches')
     allow = buildmatch(ui, repo, user, 'acl.allow')
     deny = buildmatch(ui, repo, user, 'acl.deny')
 
     for rev in xrange(repo[node], len(repo)):
         ctx = repo[rev]
         branch = ctx.branch()
         if denybranches and denybranches(branch):
             raise util.Abort(_('acl: user "%s" denied on branch "%s"'
                                ' (changeset "%s")')
                                % (user, branch, ctx))
         if allowbranches and not allowbranches(branch):
             raise util.Abort(_('acl: user "%s" not allowed on branch "%s"'
                                ' (changeset "%s")')
                                % (user, branch, ctx))
         ui.debug('acl: branch access granted: "%s" on branch "%s"\n'
         % (ctx, branch))
 
         for f in ctx.files():
             if deny and deny(f):
                 raise util.Abort(_('acl: user "%s" denied on "%s"'
                 ' (changeset "%s")') % (user, f, ctx))
             if allow and not allow(f):
                 raise util.Abort(_('acl: user "%s" not allowed on "%s"'
                 ' (changeset "%s")') % (user, f, ctx))
         ui.debug('acl: path access granted: "%s"\n' % ctx)

hgext/blackbox.py

@@ -1,158 +1,162 b''
 # blackbox.py - log repository events to a file for post-mortem debugging
 #
 # Copyright 2010 Nicolas Dumazet
 # Copyright 2013 Facebook, Inc.
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 """log repository events to a blackbox for debugging
 
 Logs event information to .hg/blackbox.log to help debug and diagnose problems.
 The events that get logged can be configured via the blackbox.track config key.
 Examples::
 
   [blackbox]
   track = *
 
   [blackbox]
   track = command, commandfinish, commandexception, exthook, pythonhook
 
   [blackbox]
   track = incoming
 
   [blackbox]
   # limit the size of a log file
   maxsize = 1.5 MB
   # rotate up to N log files when the current one gets too big
   maxfiles = 3
 
 """
 
 from mercurial import util, cmdutil
 from mercurial.i18n import _
 import errno, os, re
 
 cmdtable = {}
 command = cmdutil.command(cmdtable)
+# Note for extension authors: ONLY specify testedwith = 'internal' for
+# extensions which SHIP WITH MERCURIAL. Non-mainline extensions should
+# be specifying the version(s) of Mercurial they are tested with, or
+# leave the attribute unspecified.
 testedwith = 'internal'
 lastblackbox = None
 
 def wrapui(ui):
     class blackboxui(ui.__class__):
         @util.propertycache
         def track(self):
             return self.configlist('blackbox', 'track', ['*'])
 
         def _openlogfile(self):
             def rotate(oldpath, newpath):
                 try:
                     os.unlink(newpath)
                 except OSError, err:
                     if err.errno != errno.ENOENT:
                         self.debug("warning: cannot remove '%s': %s\n" %
                                    (newpath, err.strerror))
                 try:
                     if newpath:
                         os.rename(oldpath, newpath)
                 except OSError, err:
                     if err.errno != errno.ENOENT:
                         self.debug("warning: cannot rename '%s' to '%s': %s\n" %
                                    (newpath, oldpath, err.strerror))
 
             fp = self._bbopener('blackbox.log', 'a')
             maxsize = self.configbytes('blackbox', 'maxsize', 1048576)
             if maxsize > 0:
                 st = os.fstat(fp.fileno())
                 if st.st_size >= maxsize:
                     path = fp.name
                     fp.close()
                     maxfiles = self.configint('blackbox', 'maxfiles', 7)
                     for i in xrange(maxfiles - 1, 1, -1):
                         rotate(oldpath='%s.%d' % (path, i - 1),
                                newpath='%s.%d' % (path, i))
                     rotate(oldpath=path,
                            newpath=maxfiles > 0 and path + '.1')
                     fp = self._bbopener('blackbox.log', 'a')
             return fp
 
         def log(self, event, *msg, **opts):
             global lastblackbox
             super(blackboxui, self).log(event, *msg, **opts)
 
             if not '*' in self.track and not event in self.track:
                 return
 
             if util.safehasattr(self, '_blackbox'):
                 blackbox = self._blackbox
             elif util.safehasattr(self, '_bbopener'):
                 try:
                     self._blackbox = self._openlogfile()
                 except (IOError, OSError), err:
                     self.debug('warning: cannot write to blackbox.log: %s\n' %
                                err.strerror)
                     del self._bbopener
                     self._blackbox = None
                 blackbox = self._blackbox
             else:
                 # certain ui instances exist outside the context of
                 # a repo, so just default to the last blackbox that
                 # was seen.
                 blackbox = lastblackbox
 
             if blackbox:
                 date = util.datestr(None, '%Y/%m/%d %H:%M:%S')
                 user = util.getuser()
                 formattedmsg = msg[0] % msg[1:]
                 try:
                     blackbox.write('%s %s> %s' % (date, user, formattedmsg))
                 except IOError, err:
                     self.debug('warning: cannot write to blackbox.log: %s\n' %
                                err.strerror)
                 lastblackbox = blackbox
 
         def setrepo(self, repo):
             self._bbopener = repo.vfs
 
     ui.__class__ = blackboxui
 
 def uisetup(ui):
     wrapui(ui)
 
 def reposetup(ui, repo):
     # During 'hg pull' a httppeer repo is created to represent the remote repo.
     # It doesn't have a .hg directory to put a blackbox in, so we don't do
     # the blackbox setup for it.
     if not repo.local():
         return
 
     if util.safehasattr(ui, 'setrepo'):
         ui.setrepo(repo)
 
 @command('^blackbox',
     [('l', 'limit', 10, _('the number of events to show')),
     ],
     _('hg blackbox [OPTION]...'))
 def blackbox(ui, repo, *revs, **opts):
     '''view the recent repository events
     '''
 
     if not os.path.exists(repo.join('blackbox.log')):
         return
 
     limit = opts.get('limit')
     blackbox = repo.vfs('blackbox.log', 'r')
     lines = blackbox.read().split('\n')
 
     count = 0
     output = []
     for line in reversed(lines):
         if count >= limit:
             break
 
         # count the commands by matching lines like: 2013/01/23 19:13:36 root>
         if re.match('^\d{4}/\d{2}/\d{2} \d{2}:\d{2}:\d{2} .*> .*', line):
             count += 1
         output.append(line)
 
     ui.status('\n'.join(reversed(output)))

hgext/bugzilla.py

@@ -1,910 +1,914 b''
 # bugzilla.py - bugzilla integration for mercurial
 #
 # Copyright 2006 Vadim Gelfer <[e-mail]>
 # Copyright 2011-4 Jim Hague <[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.
 
 '''hooks for integrating with the Bugzilla bug tracker
 
 This hook extension adds comments on bugs in Bugzilla when changesets
 that refer to bugs by Bugzilla ID are seen. The comment is formatted using
 the Mercurial template mechanism.
 
 The bug references can optionally include an update for Bugzilla of the
 hours spent working on the bug. Bugs can also be marked fixed.
 
 Three basic modes of access to Bugzilla are provided:
 
 1. Access via the Bugzilla XMLRPC interface. Requires Bugzilla 3.4 or later.
 
 2. Check data via the Bugzilla XMLRPC interface and submit bug change
    via email to Bugzilla email interface. Requires Bugzilla 3.4 or later.
 
 3. Writing directly to the Bugzilla database. Only Bugzilla installations
    using MySQL are supported. Requires Python MySQLdb.
 
 Writing directly to the database is susceptible to schema changes, and
 relies on a Bugzilla contrib script to send out bug change
 notification emails. This script runs as the user running Mercurial,
 must be run on the host with the Bugzilla install, and requires
 permission to read Bugzilla configuration details and the necessary
 MySQL user and password to have full access rights to the Bugzilla
 database. For these reasons this access mode is now considered
 deprecated, and will not be updated for new Bugzilla versions going
 forward. Only adding comments is supported in this access mode.
 
 Access via XMLRPC needs a Bugzilla username and password to be specified
 in the configuration. Comments are added under that username. Since the
 configuration must be readable by all Mercurial users, it is recommended
 that the rights of that user are restricted in Bugzilla to the minimum
 necessary to add comments. Marking bugs fixed requires Bugzilla 4.0 and later.
 
 Access via XMLRPC/email uses XMLRPC to query Bugzilla, but sends
 email to the Bugzilla email interface to submit comments to bugs.
 The From: address in the email is set to the email address of the Mercurial
 user, so the comment appears to come from the Mercurial user. In the event
 that the Mercurial user email is not recognized by Bugzilla as a Bugzilla
 user, the email associated with the Bugzilla username used to log into
 Bugzilla is used instead as the source of the comment. Marking bugs fixed
 works on all supported Bugzilla versions.
 
 Configuration items common to all access modes:
 
 bugzilla.version
   The access type to use. Values recognized are:
 
   :``xmlrpc``:       Bugzilla XMLRPC interface.
   :``xmlrpc+email``: Bugzilla XMLRPC and email interfaces.
   :``3.0``:          MySQL access, Bugzilla 3.0 and later.
   :``2.18``:         MySQL access, Bugzilla 2.18 and up to but not
                      including 3.0.
   :``2.16``:         MySQL access, Bugzilla 2.16 and up to but not
                      including 2.18.
 
 bugzilla.regexp
   Regular expression to match bug IDs for update in changeset commit message.
   It must contain one "()" named group ``<ids>`` containing the bug
   IDs separated by non-digit characters. It may also contain
   a named group ``<hours>`` with a floating-point number giving the
   hours worked on the bug. If no named groups are present, the first
   "()" group is assumed to contain the bug IDs, and work time is not
   updated. The default expression matches ``Bug 1234``, ``Bug no. 1234``,
   ``Bug number 1234``, ``Bugs 1234,5678``, ``Bug 1234 and 5678`` and
   variations thereof, followed by an hours number prefixed by ``h`` or
   ``hours``, e.g. ``hours 1.5``. Matching is case insensitive.
 
 bugzilla.fixregexp
   Regular expression to match bug IDs for marking fixed in changeset
   commit message. This must contain a "()" named group ``<ids>` containing
   the bug IDs separated by non-digit characters. It may also contain
   a named group ``<hours>`` with a floating-point number giving the
   hours worked on the bug. If no named groups are present, the first
   "()" group is assumed to contain the bug IDs, and work time is not
   updated. The default expression matches ``Fixes 1234``, ``Fixes bug 1234``,
   ``Fixes bugs 1234,5678``, ``Fixes 1234 and 5678`` and
   variations thereof, followed by an hours number prefixed by ``h`` or
   ``hours``, e.g. ``hours 1.5``. Matching is case insensitive.
 
 bugzilla.fixstatus
   The status to set a bug to when marking fixed. Default ``RESOLVED``.
 
 bugzilla.fixresolution
   The resolution to set a bug to when marking fixed. Default ``FIXED``.
 
 bugzilla.style
   The style file to use when formatting comments.
 
 bugzilla.template
   Template to use when formatting comments. Overrides style if
   specified. In addition to the usual Mercurial keywords, the
   extension specifies:
 
   :``{bug}``:     The Bugzilla bug ID.
   :``{root}``:    The full pathname of the Mercurial repository.
   :``{webroot}``: Stripped pathname of the Mercurial repository.
   :``{hgweb}``:   Base URL for browsing Mercurial repositories.
 
   Default ``changeset {node|short} in repo {root} refers to bug
   {bug}.\\ndetails:\\n\\t{desc|tabindent}``
 
 bugzilla.strip
   The number of path separator characters to strip from the front of
   the Mercurial repository path (``{root}`` in templates) to produce
   ``{webroot}``. For example, a repository with ``{root}``
   ``/var/local/my-project`` with a strip of 2 gives a value for
   ``{webroot}`` of ``my-project``. Default 0.
 
 web.baseurl
   Base URL for browsing Mercurial repositories. Referenced from
   templates as ``{hgweb}``.
 
 Configuration items common to XMLRPC+email and MySQL access modes:
 
 bugzilla.usermap
   Path of file containing Mercurial committer email to Bugzilla user email
   mappings. If specified, the file should contain one mapping per
   line::
 
     committer = Bugzilla user
 
   See also the ``[usermap]`` section.
 
 The ``[usermap]`` section is used to specify mappings of Mercurial
 committer email to Bugzilla user email. See also ``bugzilla.usermap``.
 Contains entries of the form ``committer = Bugzilla user``.
 
 XMLRPC access mode configuration:
 
 bugzilla.bzurl
   The base URL for the Bugzilla installation.
   Default ``http://localhost/bugzilla``.
 
 bugzilla.user
   The username to use to log into Bugzilla via XMLRPC. Default
   ``bugs``.
 
 bugzilla.password
   The password for Bugzilla login.
 
 XMLRPC+email access mode uses the XMLRPC access mode configuration items,
 and also:
 
 bugzilla.bzemail
   The Bugzilla email address.
 
 In addition, the Mercurial email settings must be configured. See the
 documentation in hgrc(5), sections ``[email]`` and ``[smtp]``.
 
 MySQL access mode configuration:
 
 bugzilla.host
   Hostname of the MySQL server holding the Bugzilla database.
   Default ``localhost``.
 
 bugzilla.db
   Name of the Bugzilla database in MySQL. Default ``bugs``.
 
 bugzilla.user
   Username to use to access MySQL server. Default ``bugs``.
 
 bugzilla.password
   Password to use to access MySQL server.
 
 bugzilla.timeout
   Database connection timeout (seconds). Default 5.
 
 bugzilla.bzuser
   Fallback Bugzilla user name to record comments with, if changeset
   committer cannot be found as a Bugzilla user.
 
 bugzilla.bzdir
    Bugzilla install directory. Used by default notify. Default
    ``/var/www/html/bugzilla``.
 
 bugzilla.notify
   The command to run to get Bugzilla to send bug change notification
   emails. Substitutes from a map with 3 keys, ``bzdir``, ``id`` (bug
   id) and ``user`` (committer bugzilla email). Default depends on
   version; from 2.18 it is "cd %(bzdir)s && perl -T
   contrib/sendbugmail.pl %(id)s %(user)s".
 
 Activating the extension::
 
     [extensions]
     bugzilla =
 
     [hooks]
     # run bugzilla hook on every change pulled or pushed in here
     incoming.bugzilla = python:hgext.bugzilla.hook
 
 Example configurations:
 
 XMLRPC example configuration. This uses the Bugzilla at
 ``http://my-project.org/bugzilla``, logging in as user
 ``[e-mail]`` with password ``plugh``. It is used with a
 collection of Mercurial repositories in ``/var/local/hg/repos/``,
 with a web interface at ``http://my-project.org/hg``. ::
 
     [bugzilla]
     bzurl=http://my-project.org/bugzilla
     user=[e-mail]
     password=plugh
     version=xmlrpc
     template=Changeset {node|short} in {root|basename}.
              {hgweb}/{webroot}/rev/{node|short}\\n
              {desc}\\n
     strip=5
 
     [web]
     baseurl=http://my-project.org/hg
 
 XMLRPC+email example configuration. This uses the Bugzilla at
 ``http://my-project.org/bugzilla``, logging in as user
 ``[e-mail]`` with password ``plugh``. It is used with a
 collection of Mercurial repositories in ``/var/local/hg/repos/``,
 with a web interface at ``http://my-project.org/hg``. Bug comments
 are sent to the Bugzilla email address
 ``[e-mail]``. ::
 
     [bugzilla]
     bzurl=http://my-project.org/bugzilla
     user=[e-mail]
     password=plugh
     version=xmlrpc+email
     bzemail=[e-mail]
     template=Changeset {node|short} in {root|basename}.
              {hgweb}/{webroot}/rev/{node|short}\\n
              {desc}\\n
     strip=5
 
     [web]
     baseurl=http://my-project.org/hg
 
     [usermap]
     [e-mail]=[e-mail]
 
 MySQL example configuration. This has a local Bugzilla 3.2 installation
 in ``/opt/bugzilla-3.2``. The MySQL database is on ``localhost``,
 the Bugzilla database name is ``bugs`` and MySQL is
 accessed with MySQL username ``bugs`` password ``XYZZY``. It is used
 with a collection of Mercurial repositories in ``/var/local/hg/repos/``,
 with a web interface at ``http://my-project.org/hg``. ::
 
     [bugzilla]
     host=localhost
     password=XYZZY
     version=3.0
     bzuser=[e-mail]
     bzdir=/opt/bugzilla-3.2
     template=Changeset {node|short} in {root|basename}.
              {hgweb}/{webroot}/rev/{node|short}\\n
              {desc}\\n
     strip=5
 
     [web]
     baseurl=http://my-project.org/hg
 
     [usermap]
     [e-mail]=[e-mail]
 
 All the above add a comment to the Bugzilla bug record of the form::
 
     Changeset 3b16791d6642 in repository-name.
     http://my-project.org/hg/repository-name/rev/3b16791d6642
 
     Changeset commit comment. Bug 1234.
 '''
 
 from mercurial.i18n import _
 from mercurial.node import short
 from mercurial import cmdutil, mail, util
 import re, time, urlparse, xmlrpclib
 
+# Note for extension authors: ONLY specify testedwith = 'internal' for
+# extensions which SHIP WITH MERCURIAL. Non-mainline extensions should
+# be specifying the version(s) of Mercurial they are tested with, or
+# leave the attribute unspecified.
 testedwith = 'internal'
 
 class bzaccess(object):
     '''Base class for access to Bugzilla.'''
 
     def __init__(self, ui):
         self.ui = ui
         usermap = self.ui.config('bugzilla', 'usermap')
         if usermap:
             self.ui.readconfig(usermap, sections=['usermap'])
 
     def map_committer(self, user):
         '''map name of committer to Bugzilla user name.'''
         for committer, bzuser in self.ui.configitems('usermap'):
             if committer.lower() == user.lower():
                 return bzuser
         return user
 
     # Methods to be implemented by access classes.
     #
     # 'bugs' is a dict keyed on bug id, where values are a dict holding
     # updates to bug state. Recognized dict keys are:
     #
     # 'hours': Value, float containing work hours to be updated.
     # 'fix':   If key present, bug is to be marked fixed. Value ignored.
 
     def filter_real_bug_ids(self, bugs):
         '''remove bug IDs that do not exist in Bugzilla from bugs.'''
         pass
 
     def filter_cset_known_bug_ids(self, node, bugs):
         '''remove bug IDs where node occurs in comment text from bugs.'''
         pass
 
     def updatebug(self, bugid, newstate, text, committer):
         '''update the specified bug. Add comment text and set new states.
 
         If possible add the comment as being from the committer of
         the changeset. Otherwise use the default Bugzilla user.
         '''
         pass
 
     def notify(self, bugs, committer):
         '''Force sending of Bugzilla notification emails.
 
         Only required if the access method does not trigger notification
         emails automatically.
         '''
         pass
 
 # Bugzilla via direct access to MySQL database.
 class bzmysql(bzaccess):
     '''Support for direct MySQL access to Bugzilla.
 
     The earliest Bugzilla version this is tested with is version 2.16.
 
     If your Bugzilla is version 3.4 or above, you are strongly
     recommended to use the XMLRPC access method instead.
     '''
 
     @staticmethod
     def sql_buglist(ids):
         '''return SQL-friendly list of bug ids'''
         return '(' + ','.join(map(str, ids)) + ')'
 
     _MySQLdb = None
 
     def __init__(self, ui):
         try:
             import MySQLdb as mysql
             bzmysql._MySQLdb = mysql
         except ImportError, err:
             raise util.Abort(_('python mysql support not available: %s') % err)
 
         bzaccess.__init__(self, ui)
 
         host = self.ui.config('bugzilla', 'host', 'localhost')
         user = self.ui.config('bugzilla', 'user', 'bugs')
         passwd = self.ui.config('bugzilla', 'password')
         db = self.ui.config('bugzilla', 'db', 'bugs')
         timeout = int(self.ui.config('bugzilla', 'timeout', 5))
         self.ui.note(_('connecting to %s:%s as %s, password %s\n') %
                      (host, db, user, '*' * len(passwd)))
         self.conn = bzmysql._MySQLdb.connect(host=host,
                                                    user=user, passwd=passwd,
                                                    db=db,
                                                    connect_timeout=timeout)
         self.cursor = self.conn.cursor()
         self.longdesc_id = self.get_longdesc_id()
         self.user_ids = {}
         self.default_notify = "cd %(bzdir)s && ./processmail %(id)s %(user)s"
 
     def run(self, *args, **kwargs):
         '''run a query.'''
         self.ui.note(_('query: %s %s\n') % (args, kwargs))
         try:
             self.cursor.execute(*args, **kwargs)
         except bzmysql._MySQLdb.MySQLError:
             self.ui.note(_('failed query: %s %s\n') % (args, kwargs))
             raise
 
     def get_longdesc_id(self):
         '''get identity of longdesc field'''
         self.run('select fieldid from fielddefs where name = "longdesc"')
         ids = self.cursor.fetchall()
         if len(ids) != 1:
             raise util.Abort(_('unknown database schema'))
         return ids[0][0]
 
     def filter_real_bug_ids(self, bugs):
         '''filter not-existing bugs from set.'''
         self.run('select bug_id from bugs where bug_id in %s' %
                  bzmysql.sql_buglist(bugs.keys()))
         existing = [id for (id,) in self.cursor.fetchall()]
         for id in bugs.keys():
             if id not in existing:
                 self.ui.status(_('bug %d does not exist\n') % id)
                 del bugs[id]
 
     def filter_cset_known_bug_ids(self, node, bugs):
         '''filter bug ids that already refer to this changeset from set.'''
         self.run('''select bug_id from longdescs where
                     bug_id in %s and thetext like "%%%s%%"''' %
                  (bzmysql.sql_buglist(bugs.keys()), short(node)))
         for (id,) in self.cursor.fetchall():
             self.ui.status(_('bug %d already knows about changeset %s\n') %
                            (id, short(node)))
             del bugs[id]
 
     def notify(self, bugs, committer):
         '''tell bugzilla to send mail.'''
         self.ui.status(_('telling bugzilla to send mail:\n'))
         (user, userid) = self.get_bugzilla_user(committer)
         for id in bugs.keys():
             self.ui.status(_('  bug %s\n') % id)
             cmdfmt = self.ui.config('bugzilla', 'notify', self.default_notify)
             bzdir = self.ui.config('bugzilla', 'bzdir',
                                    '/var/www/html/bugzilla')
             try:
                 # Backwards-compatible with old notify string, which
                 # took one string. This will throw with a new format
                 # string.
                 cmd = cmdfmt % id
             except TypeError:
                 cmd = cmdfmt % {'bzdir': bzdir, 'id': id, 'user': user}
             self.ui.note(_('running notify command %s\n') % cmd)
             fp = util.popen('(%s) 2>&1' % cmd)
             out = fp.read()
             ret = fp.close()
             if ret:
                 self.ui.warn(out)
                 raise util.Abort(_('bugzilla notify command %s') %
                                  util.explainexit(ret)[0])
         self.ui.status(_('done\n'))
 
     def get_user_id(self, user):
         '''look up numeric bugzilla user id.'''
         try:
             return self.user_ids[user]
         except KeyError:
             try:
                 userid = int(user)
             except ValueError:
                 self.ui.note(_('looking up user %s\n') % user)
                 self.run('''select userid from profiles
                             where login_name like %s''', user)
                 all = self.cursor.fetchall()
                 if len(all) != 1:
                     raise KeyError(user)
                 userid = int(all[0][0])
             self.user_ids[user] = userid
             return userid
 
     def get_bugzilla_user(self, committer):
         '''See if committer is a registered bugzilla user. Return
         bugzilla username and userid if so. If not, return default
         bugzilla username and userid.'''
         user = self.map_committer(committer)
         try:
             userid = self.get_user_id(user)
         except KeyError:
             try:
                 defaultuser = self.ui.config('bugzilla', 'bzuser')
                 if not defaultuser:
                     raise util.Abort(_('cannot find bugzilla user id for %s') %
                                      user)
                 userid = self.get_user_id(defaultuser)
                 user = defaultuser
             except KeyError:
                 raise util.Abort(_('cannot find bugzilla user id for %s or %s')
                                  % (user, defaultuser))
         return (user, userid)
 
     def updatebug(self, bugid, newstate, text, committer):
         '''update bug state with comment text.
 
         Try adding comment as committer of changeset, otherwise as
         default bugzilla user.'''
         if len(newstate) > 0:
             self.ui.warn(_("Bugzilla/MySQL cannot update bug state\n"))
 
         (user, userid) = self.get_bugzilla_user(committer)
         now = time.strftime('%Y-%m-%d %H:%M:%S')
         self.run('''insert into longdescs
                     (bug_id, who, bug_when, thetext)
                     values (%s, %s, %s, %s)''',
                  (bugid, userid, now, text))
         self.run('''insert into bugs_activity (bug_id, who, bug_when, fieldid)
                     values (%s, %s, %s, %s)''',
                  (bugid, userid, now, self.longdesc_id))
         self.conn.commit()
 
 class bzmysql_2_18(bzmysql):
     '''support for bugzilla 2.18 series.'''
 
     def __init__(self, ui):
         bzmysql.__init__(self, ui)
         self.default_notify = \
             "cd %(bzdir)s && perl -T contrib/sendbugmail.pl %(id)s %(user)s"
 
 class bzmysql_3_0(bzmysql_2_18):
     '''support for bugzilla 3.0 series.'''
 
     def __init__(self, ui):
         bzmysql_2_18.__init__(self, ui)
 
     def get_longdesc_id(self):
         '''get identity of longdesc field'''
         self.run('select id from fielddefs where name = "longdesc"')
         ids = self.cursor.fetchall()
         if len(ids) != 1:
             raise util.Abort(_('unknown database schema'))
         return ids[0][0]
 
 # Bugzilla via XMLRPC interface.
 
 class cookietransportrequest(object):
     """A Transport request method that retains cookies over its lifetime.
 
     The regular xmlrpclib transports ignore cookies. Which causes
     a bit of a problem when you need a cookie-based login, as with
     the Bugzilla XMLRPC interface prior to 4.4.3.
 
     So this is a helper for defining a Transport which looks for
     cookies being set in responses and saves them to add to all future
     requests.
     """
 
     # Inspiration drawn from
     # http://blog.godson.in/2010/09/how-to-make-python-xmlrpclib-client.html
     # http://www.itkovian.net/base/transport-class-for-pythons-xml-rpc-lib/
 
     cookies = []
     def send_cookies(self, connection):
         if self.cookies:
             for cookie in self.cookies:
                 connection.putheader("Cookie", cookie)
 
     def request(self, host, handler, request_body, verbose=0):
         self.verbose = verbose
         self.accept_gzip_encoding = False
 
         # issue XML-RPC request
         h = self.make_connection(host)
         if verbose:
             h.set_debuglevel(1)
 
         self.send_request(h, handler, request_body)
         self.send_host(h, host)
         self.send_cookies(h)
         self.send_user_agent(h)
         self.send_content(h, request_body)
 
         # Deal with differences between Python 2.4-2.6 and 2.7.
         # In the former h is a HTTP(S). In the latter it's a
         # HTTP(S)Connection. Luckily, the 2.4-2.6 implementation of
         # HTTP(S) has an underlying HTTP(S)Connection, so extract
         # that and use it.
         try:
             response = h.getresponse()
         except AttributeError:
             response = h._conn.getresponse()
 
         # Add any cookie definitions to our list.
         for header in response.msg.getallmatchingheaders("Set-Cookie"):
             val = header.split(": ", 1)[1]
             cookie = val.split(";", 1)[0]
             self.cookies.append(cookie)
 
         if response.status != 200:
             raise xmlrpclib.ProtocolError(host + handler, response.status,
                                           response.reason, response.msg.headers)
 
         payload = response.read()
         parser, unmarshaller = self.getparser()
         parser.feed(payload)
         parser.close()
 
         return unmarshaller.close()
 
 # The explicit calls to the underlying xmlrpclib __init__() methods are
 # necessary. The xmlrpclib.Transport classes are old-style classes, and
 # it turns out their __init__() doesn't get called when doing multiple
 # inheritance with a new-style class.
 class cookietransport(cookietransportrequest, xmlrpclib.Transport):
     def __init__(self, use_datetime=0):
         if util.safehasattr(xmlrpclib.Transport, "__init__"):
             xmlrpclib.Transport.__init__(self, use_datetime)
 
 class cookiesafetransport(cookietransportrequest, xmlrpclib.SafeTransport):
     def __init__(self, use_datetime=0):
         if util.safehasattr(xmlrpclib.Transport, "__init__"):
             xmlrpclib.SafeTransport.__init__(self, use_datetime)
 
 class bzxmlrpc(bzaccess):
     """Support for access to Bugzilla via the Bugzilla XMLRPC API.
 
     Requires a minimum Bugzilla version 3.4.
     """
 
     def __init__(self, ui):
         bzaccess.__init__(self, ui)
 
         bzweb = self.ui.config('bugzilla', 'bzurl',
                                'http://localhost/bugzilla/')
         bzweb = bzweb.rstrip("/") + "/xmlrpc.cgi"
 
         user = self.ui.config('bugzilla', 'user', 'bugs')
         passwd = self.ui.config('bugzilla', 'password')
 
         self.fixstatus = self.ui.config('bugzilla', 'fixstatus', 'RESOLVED')
         self.fixresolution = self.ui.config('bugzilla', 'fixresolution',
                                             'FIXED')
 
         self.bzproxy = xmlrpclib.ServerProxy(bzweb, self.transport(bzweb))
         ver = self.bzproxy.Bugzilla.version()['version'].split('.')
         self.bzvermajor = int(ver[0])
         self.bzverminor = int(ver[1])
         login = self.bzproxy.User.login({'login': user, 'password': passwd,
                                          'restrict_login': True})
         self.bztoken = login.get('token', '')
 
     def transport(self, uri):
         if urlparse.urlparse(uri, "http")[0] == "https":
             return cookiesafetransport()
         else:
             return cookietransport()
 
     def get_bug_comments(self, id):
         """Return a string with all comment text for a bug."""
         c = self.bzproxy.Bug.comments({'ids': [id],
                                        'include_fields': ['text'],
                                        'token': self.bztoken})
         return ''.join([t['text'] for t in c['bugs'][str(id)]['comments']])
 
     def filter_real_bug_ids(self, bugs):
         probe = self.bzproxy.Bug.get({'ids': sorted(bugs.keys()),
                                       'include_fields': [],
                                       'permissive': True,
                                       'token': self.bztoken,
                                       })
         for badbug in probe['faults']:
             id = badbug['id']
             self.ui.status(_('bug %d does not exist\n') % id)
             del bugs[id]
 
     def filter_cset_known_bug_ids(self, node, bugs):
         for id in sorted(bugs.keys()):
             if self.get_bug_comments(id).find(short(node)) != -1:
                 self.ui.status(_('bug %d already knows about changeset %s\n') %
                                (id, short(node)))
                 del bugs[id]
 
     def updatebug(self, bugid, newstate, text, committer):
         args = {}
         if 'hours' in newstate:
             args['work_time'] = newstate['hours']
 
         if self.bzvermajor >= 4:
             args['ids'] = [bugid]
             args['comment'] = {'body' : text}
             if 'fix' in newstate:
                 args['status'] = self.fixstatus
                 args['resolution'] = self.fixresolution
             args['token'] = self.bztoken
             self.bzproxy.Bug.update(args)
         else:
             if 'fix' in newstate:
                 self.ui.warn(_("Bugzilla/XMLRPC needs Bugzilla 4.0 or later "
                                "to mark bugs fixed\n"))
             args['id'] = bugid
             args['comment'] = text
             self.bzproxy.Bug.add_comment(args)
 
 class bzxmlrpcemail(bzxmlrpc):
     """Read data from Bugzilla via XMLRPC, send updates via email.
 
     Advantages of sending updates via email:
       1. Comments can be added as any user, not just logged in user.
       2. Bug statuses or other fields not accessible via XMLRPC can
          potentially be updated.
 
     There is no XMLRPC function to change bug status before Bugzilla
     4.0, so bugs cannot be marked fixed via XMLRPC before Bugzilla 4.0.
     But bugs can be marked fixed via email from 3.4 onwards.
     """
 
     # The email interface changes subtly between 3.4 and 3.6. In 3.4,
     # in-email fields are specified as '@<fieldname> = <value>'. In
     # 3.6 this becomes '@<fieldname> <value>'. And fieldname @bug_id
     # in 3.4 becomes @id in 3.6. 3.6 and 4.0 both maintain backwards
     # compatibility, but rather than rely on this use the new format for
     # 4.0 onwards.
 
     def __init__(self, ui):
         bzxmlrpc.__init__(self, ui)
 
         self.bzemail = self.ui.config('bugzilla', 'bzemail')
         if not self.bzemail:
             raise util.Abort(_("configuration 'bzemail' missing"))
         mail.validateconfig(self.ui)
 
     def makecommandline(self, fieldname, value):
         if self.bzvermajor >= 4:
             return "@%s %s" % (fieldname, str(value))
         else:
             if fieldname == "id":
                 fieldname = "bug_id"
             return "@%s = %s" % (fieldname, str(value))
 
     def send_bug_modify_email(self, bugid, commands, comment, committer):
         '''send modification message to Bugzilla bug via email.
 
         The message format is documented in the Bugzilla email_in.pl
         specification. commands is a list of command lines, comment is the
         comment text.
 
         To stop users from crafting commit comments with
         Bugzilla commands, specify the bug ID via the message body, rather
         than the subject line, and leave a blank line after it.
         '''
         user = self.map_committer(committer)
         matches = self.bzproxy.User.get({'match': [user],
                                          'token': self.bztoken})
         if not matches['users']:
             user = self.ui.config('bugzilla', 'user', 'bugs')
             matches = self.bzproxy.User.get({'match': [user],
                                              'token': self.bztoken})
             if not matches['users']:
                 raise util.Abort(_("default bugzilla user %s email not found") %
                                  user)
         user = matches['users'][0]['email']
         commands.append(self.makecommandline("id", bugid))
 
         text = "\n".join(commands) + "\n\n" + comment
 
         _charsets = mail._charsets(self.ui)
         user = mail.addressencode(self.ui, user, _charsets)
         bzemail = mail.addressencode(self.ui, self.bzemail, _charsets)
         msg = mail.mimeencode(self.ui, text, _charsets)
         msg['From'] = user
         msg['To'] = bzemail
         msg['Subject'] = mail.headencode(self.ui, "Bug modification", _charsets)
         sendmail = mail.connect(self.ui)
         sendmail(user, bzemail, msg.as_string())
 
     def updatebug(self, bugid, newstate, text, committer):
         cmds = []
         if 'hours' in newstate:
             cmds.append(self.makecommandline("work_time", newstate['hours']))
         if 'fix' in newstate:
             cmds.append(self.makecommandline("bug_status", self.fixstatus))
             cmds.append(self.makecommandline("resolution", self.fixresolution))
         self.send_bug_modify_email(bugid, cmds, text, committer)
 
 class bugzilla(object):
     # supported versions of bugzilla. different versions have
     # different schemas.
     _versions = {
         '2.16': bzmysql,
         '2.18': bzmysql_2_18,
         '3.0':  bzmysql_3_0,
         'xmlrpc': bzxmlrpc,
         'xmlrpc+email': bzxmlrpcemail
         }
 
     _default_bug_re = (r'bugs?\s*,?\s*(?:#|nos?\.?|num(?:ber)?s?)?\s*'
                        r'(?P<ids>(?:\d+\s*(?:,?\s*(?:and)?)?\s*)+)'
                        r'\.?\s*(?:h(?:ours?)?\s*(?P<hours>\d*(?:\.\d+)?))?')
 
     _default_fix_re = (r'fix(?:es)?\s*(?:bugs?\s*)?,?\s*'
                        r'(?:nos?\.?|num(?:ber)?s?)?\s*'
                        r'(?P<ids>(?:#?\d+\s*(?:,?\s*(?:and)?)?\s*)+)'
                        r'\.?\s*(?:h(?:ours?)?\s*(?P<hours>\d*(?:\.\d+)?))?')
 
     def __init__(self, ui, repo):
         self.ui = ui
         self.repo = repo
 
         bzversion = self.ui.config('bugzilla', 'version')
         try:
             bzclass = bugzilla._versions[bzversion]
         except KeyError:
             raise util.Abort(_('bugzilla version %s not supported') %
                              bzversion)
         self.bzdriver = bzclass(self.ui)
 
         self.bug_re = re.compile(
             self.ui.config('bugzilla', 'regexp',
                            bugzilla._default_bug_re), re.IGNORECASE)
         self.fix_re = re.compile(
             self.ui.config('bugzilla', 'fixregexp',
                            bugzilla._default_fix_re), re.IGNORECASE)
         self.split_re = re.compile(r'\D+')
 
     def find_bugs(self, ctx):
         '''return bugs dictionary created from commit comment.
 
         Extract bug info from changeset comments. Filter out any that are
         not known to Bugzilla, and any that already have a reference to
         the given changeset in their comments.
         '''
         start = 0
         hours = 0.0
         bugs = {}
         bugmatch = self.bug_re.search(ctx.description(), start)
         fixmatch = self.fix_re.search(ctx.description(), start)
         while True:
             bugattribs = {}
             if not bugmatch and not fixmatch:
                 break
             if not bugmatch:
                 m = fixmatch
             elif not fixmatch:
                 m = bugmatch
             else:
                 if bugmatch.start() < fixmatch.start():
                     m = bugmatch
                 else:
                     m = fixmatch
             start = m.end()
             if m is bugmatch:
                 bugmatch = self.bug_re.search(ctx.description(), start)
                 if 'fix' in bugattribs:
                     del bugattribs['fix']
             else:
                 fixmatch = self.fix_re.search(ctx.description(), start)
                 bugattribs['fix'] = None
 
             try:
                 ids = m.group('ids')
             except IndexError:
                 ids = m.group(1)
             try:
                 hours = float(m.group('hours'))
                 bugattribs['hours'] = hours
             except IndexError:
                 pass
             except TypeError:
                 pass
             except ValueError:
                 self.ui.status(_("%s: invalid hours\n") % m.group('hours'))
 
             for id in self.split_re.split(ids):
                 if not id:
                     continue
                 bugs[int(id)] = bugattribs
         if bugs:
             self.bzdriver.filter_real_bug_ids(bugs)
         if bugs:
             self.bzdriver.filter_cset_known_bug_ids(ctx.node(), bugs)
         return bugs
 
     def update(self, bugid, newstate, ctx):
         '''update bugzilla bug with reference to changeset.'''
 
         def webroot(root):
             '''strip leading prefix of repo root and turn into
             url-safe path.'''
             count = int(self.ui.config('bugzilla', 'strip', 0))
             root = util.pconvert(root)
             while count > 0:
                 c = root.find('/')
                 if c == -1:
                     break
                 root = root[c + 1:]
                 count -= 1
             return root
 
         mapfile = self.ui.config('bugzilla', 'style')
         tmpl = self.ui.config('bugzilla', 'template')
         if not mapfile and not tmpl:
             tmpl = _('changeset {node|short} in repo {root} refers '
                      'to bug {bug}.\ndetails:\n\t{desc|tabindent}')
         t = cmdutil.changeset_templater(self.ui, self.repo,
                                         False, None, tmpl, mapfile, False)
         self.ui.pushbuffer()
         t.show(ctx, changes=ctx.changeset(),
                bug=str(bugid),
                hgweb=self.ui.config('web', 'baseurl'),
                root=self.repo.root,
                webroot=webroot(self.repo.root))
         data = self.ui.popbuffer()
         self.bzdriver.updatebug(bugid, newstate, data, util.email(ctx.user()))
 
     def notify(self, bugs, committer):
         '''ensure Bugzilla users are notified of bug change.'''
         self.bzdriver.notify(bugs, committer)
 
 def hook(ui, repo, hooktype, node=None, **kwargs):
     '''add comment to bugzilla for each changeset that refers to a
     bugzilla bug id. only add a comment once per bug, so same change
     seen multiple times does not fill bug with duplicate data.'''
     if node is None:
         raise util.Abort(_('hook type %s does not pass a changeset id') %
                          hooktype)
     try:
         bz = bugzilla(ui, repo)
         ctx = repo[node]
         bugs = bz.find_bugs(ctx)
         if bugs:
             for bug in bugs:
                 bz.update(bug, bugs[bug], ctx)
             bz.notify(bugs, util.email(ctx.user()))
     except Exception, e:
         raise util.Abort(_('Bugzilla error: %s') % e)

hgext/censor.py

@@ -1,161 +1,165 b''
 # Copyright (C) 2015 - Mike Edgar <[e-mail]>
 #
 # This extension enables removal of file content at a given revision,
 # rewriting the data/metadata of successive revisions to preserve revision log
 # integrity.
 
 """erase file content at a given revision
 
 The censor command instructs Mercurial to erase all content of a file at a given
 revision *without updating the changeset hash.* This allows existing history to
 remain valid while preventing future clones/pulls from receiving the erased
 data.
 
 Typical uses for censor are due to security or legal requirements, including::
 
  * Passwords, private keys, crytographic material
  * Licensed data/code/libraries for which the license has expired
  * Personally Identifiable Information or other private data
 
 Censored nodes can interrupt mercurial's typical operation whenever the excised
 data needs to be materialized. Some commands, like ``hg cat``/``hg revert``,
 simply fail when asked to produce censored data. Others, like ``hg verify`` and
 ``hg update``, must be capable of tolerating censored data to continue to
 function in a meaningful way. Such commands only tolerate censored file
 revisions if they are allowed by the "censor.policy=ignore" config option.
 """
 
 from mercurial.node import short
 from mercurial import cmdutil, error, filelog, revlog, scmutil, util
 from mercurial.i18n import _
 
 cmdtable = {}
 command = cmdutil.command(cmdtable)
+# Note for extension authors: ONLY specify testedwith = 'internal' for
+# extensions which SHIP WITH MERCURIAL. Non-mainline extensions should
+# be specifying the version(s) of Mercurial they are tested with, or
+# leave the attribute unspecified.
 testedwith = 'internal'
 
 @command('censor',
     [('r', 'rev', '', _('censor file from specified revision'), _('REV')),
      ('t', 'tombstone', '', _('replacement tombstone data'), _('TEXT'))],
     _('-r REV [-t TEXT] [FILE]'))
 def censor(ui, repo, path, rev='', tombstone='', **opts):
     if not path:
         raise util.Abort(_('must specify file path to censor'))
     if not rev:
         raise util.Abort(_('must specify revision to censor'))
 
     flog = repo.file(path)
     if not len(flog):
         raise util.Abort(_('cannot censor file with no history'))
 
     rev = scmutil.revsingle(repo, rev, rev).rev()
     try:
         ctx = repo[rev]
     except KeyError:
         raise util.Abort(_('invalid revision identifier %s') % rev)
 
     try:
         fctx = ctx.filectx(path)
     except error.LookupError:
         raise util.Abort(_('file does not exist at revision %s') % rev)
 
     fnode = fctx.filenode()
     headctxs = [repo[c] for c in repo.heads()]
     heads = [c for c in headctxs if path in c and c.filenode(path) == fnode]
     if heads:
         headlist = ', '.join([short(c.node()) for c in heads])
         raise util.Abort(_('cannot censor file in heads (%s)') % headlist,
             hint=_('clean/delete and commit first'))
 
     wctx = repo[None]
     wp = wctx.parents()
     if ctx.node() in [p.node() for p in wp]:
         raise util.Abort(_('cannot censor working directory'),
             hint=_('clean/delete/update first'))
 
     flogv = flog.version & 0xFFFF
     if flogv != revlog.REVLOGNG:
         raise util.Abort(
             _('censor does not support revlog version %d') % (flogv,))
 
     tombstone = filelog.packmeta({"censored": tombstone}, "")
 
     crev = fctx.filerev()
 
     if len(tombstone) > flog.rawsize(crev):
         raise util.Abort(_(
             'censor tombstone must be no longer than censored data'))
 
     # Using two files instead of one makes it easy to rewrite entry-by-entry
     idxread = repo.svfs(flog.indexfile, 'r')
     idxwrite = repo.svfs(flog.indexfile, 'wb', atomictemp=True)
     if flog.version & revlog.REVLOGNGINLINEDATA:
         dataread, datawrite = idxread, idxwrite
     else:
         dataread = repo.svfs(flog.datafile, 'r')
         datawrite = repo.svfs(flog.datafile, 'wb', atomictemp=True)
 
     # Copy all revlog data up to the entry to be censored.
     rio = revlog.revlogio()
     offset = flog.start(crev)
 
     for chunk in util.filechunkiter(idxread, limit=crev * rio.size):
         idxwrite.write(chunk)
     for chunk in util.filechunkiter(dataread, limit=offset):
         datawrite.write(chunk)
 
     def rewriteindex(r, newoffs, newdata=None):
         """Rewrite the index entry with a new data offset and optional new data.
 
         The newdata argument, if given, is a tuple of three positive integers:
         (new compressed, new uncompressed, added flag bits).
         """
         offlags, comp, uncomp, base, link, p1, p2, nodeid = flog.index[r]
         flags = revlog.gettype(offlags)
         if newdata:
             comp, uncomp, nflags = newdata
             flags |= nflags
         offlags = revlog.offset_type(newoffs, flags)
         e = (offlags, comp, uncomp, r, link, p1, p2, nodeid)
         idxwrite.write(rio.packentry(e, None, flog.version, r))
         idxread.seek(rio.size, 1)
 
     def rewrite(r, offs, data, nflags=revlog.REVIDX_DEFAULT_FLAGS):
         """Write the given full text to the filelog with the given data offset.
 
         Returns:
             The integer number of data bytes written, for tracking data offsets.
         """
         flag, compdata = flog.compress(data)
         newcomp = len(flag) + len(compdata)
         rewriteindex(r, offs, (newcomp, len(data), nflags))
         datawrite.write(flag)
         datawrite.write(compdata)
         dataread.seek(flog.length(r), 1)
         return newcomp
 
     # Rewrite censored revlog entry with (padded) tombstone data.
     pad = ' ' * (flog.rawsize(crev) - len(tombstone))
     offset += rewrite(crev, offset, tombstone + pad, revlog.REVIDX_ISCENSORED)
 
     # Rewrite all following filelog revisions fixing up offsets and deltas.
     for srev in xrange(crev + 1, len(flog)):
         if crev in flog.parentrevs(srev):
             # Immediate children of censored node must be re-added as fulltext.
             try:
                 revdata = flog.revision(srev)
             except error.CensoredNodeError, e:
                 revdata = e.tombstone
             dlen = rewrite(srev, offset, revdata)
         else:
             # Copy any other revision data verbatim after fixing up the offset.
             rewriteindex(srev, offset)
             dlen = flog.length(srev)
             for chunk in util.filechunkiter(dataread, limit=dlen):
                 datawrite.write(chunk)
         offset += dlen
 
     idxread.close()
     idxwrite.close()
     if dataread is not idxread:
         dataread.close()
         datawrite.close()

hgext/children.py

@@ -1,51 +1,55 b''
 # Mercurial extension to provide the 'hg children' command
 #
 # Copyright 2007 by Intevation GmbH <[e-mail]>
 #
 # Author(s):
 # Thomas Arendsen Hein <[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 display child changesets (DEPRECATED)
 
 This extension is deprecated. You should use :hg:`log -r
 "children(REV)"` instead.
 '''
 
 from mercurial import cmdutil
 from mercurial.commands import templateopts
 from mercurial.i18n import _
 
 cmdtable = {}
 command = cmdutil.command(cmdtable)
+# Note for extension authors: ONLY specify testedwith = 'internal' for
+# extensions which SHIP WITH MERCURIAL. Non-mainline extensions should
+# be specifying the version(s) of Mercurial they are tested with, or
+# leave the attribute unspecified.
 testedwith = 'internal'
 
 @command('children',
     [('r', 'rev', '',
      _('show children of the specified revision'), _('REV')),
     ] + templateopts,
     _('hg children [-r REV] [FILE]'),
     inferrepo=True)
 def children(ui, repo, file_=None, **opts):
     """show the children of the given or working directory revision
 
     Print the children of the working directory's revisions. If a
     revision is given via -r/--rev, the children of that revision will
     be printed. If a file argument is given, revision in which the
     file was last changed (after the working directory revision or the
     argument to --rev if given) is printed.
     """
     rev = opts.get('rev')
     if file_:
         fctx = repo.filectx(file_, changeid=rev)
         childctxs = [fcctx.changectx() for fcctx in fctx.children()]
     else:
         ctx = repo[rev]
         childctxs = ctx.children()
 
     displayer = cmdutil.show_changeset(ui, repo, opts)
     for cctx in childctxs:
         displayer.show(cctx)
     displayer.close()

hgext/churn.py

@@ -1,201 +1,205 b''
 # churn.py - create a graph of revisions count grouped by template
 #
 # Copyright 2006 Josef "Jeff" Sipek <[e-mail]>
 # Copyright 2008 Alexander Solovyov <[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 display statistics about repository history'''
 
 from mercurial.i18n import _
 from mercurial import patch, cmdutil, scmutil, util, commands
 from mercurial import encoding
 import os
 import time, datetime
 
 cmdtable = {}
 command = cmdutil.command(cmdtable)
+# Note for extension authors: ONLY specify testedwith = 'internal' for
+# extensions which SHIP WITH MERCURIAL. Non-mainline extensions should
+# be specifying the version(s) of Mercurial they are tested with, or
+# leave the attribute unspecified.
 testedwith = 'internal'
 
 def maketemplater(ui, repo, tmpl):
     try:
         t = cmdutil.changeset_templater(ui, repo, False, None, tmpl,
                                         None, False)
     except SyntaxError, inst:
         raise util.Abort(inst.args[0])
     return t
 
 def changedlines(ui, repo, ctx1, ctx2, fns):
     added, removed = 0, 0
     fmatch = scmutil.matchfiles(repo, fns)
     diff = ''.join(patch.diff(repo, ctx1.node(), ctx2.node(), fmatch))
     for l in diff.split('\n'):
         if l.startswith("+") and not l.startswith("+++ "):
             added += 1
         elif l.startswith("-") and not l.startswith("--- "):
             removed += 1
     return (added, removed)
 
 def countrate(ui, repo, amap, *pats, **opts):
     """Calculate stats"""
     if opts.get('dateformat'):
         def getkey(ctx):
             t, tz = ctx.date()
             date = datetime.datetime(*time.gmtime(float(t) - tz)[:6])
             return date.strftime(opts['dateformat'])
     else:
         tmpl = opts.get('oldtemplate') or opts.get('template')
         tmpl = maketemplater(ui, repo, tmpl)
         def getkey(ctx):
             ui.pushbuffer()
             tmpl.show(ctx)
             return ui.popbuffer()
 
     state = {'count': 0}
     rate = {}
     df = False
     if opts.get('date'):
         df = util.matchdate(opts['date'])
 
     m = scmutil.match(repo[None], pats, opts)
     def prep(ctx, fns):
         rev = ctx.rev()
         if df and not df(ctx.date()[0]): # doesn't match date format
             return
 
         key = getkey(ctx).strip()
         key = amap.get(key, key) # alias remap
         if opts.get('changesets'):
             rate[key] = (rate.get(key, (0,))[0] + 1, 0)
         else:
             parents = ctx.parents()
             if len(parents) > 1:
                 ui.note(_('revision %d is a merge, ignoring...\n') % (rev,))
                 return
 
             ctx1 = parents[0]
             lines = changedlines(ui, repo, ctx1, ctx, fns)
             rate[key] = [r + l for r, l in zip(rate.get(key, (0, 0)), lines)]
 
         state['count'] += 1
         ui.progress(_('analyzing'), state['count'], total=len(repo))
 
     for ctx in cmdutil.walkchangerevs(repo, m, opts, prep):
         continue
 
     ui.progress(_('analyzing'), None)
 
     return rate
 
 
 @command('churn',
     [('r', 'rev', [],
      _('count rate for the specified revision or revset'), _('REV')),
     ('d', 'date', '',
      _('count rate for revisions matching date spec'), _('DATE')),
     ('t', 'oldtemplate', '',
      _('template to group changesets (DEPRECATED)'), _('TEMPLATE')),
     ('T', 'template', '{author|email}',
      _('template to group changesets'), _('TEMPLATE')),
     ('f', 'dateformat', '',
      _('strftime-compatible format for grouping by date'), _('FORMAT')),
     ('c', 'changesets', False, _('count rate by number of changesets')),
     ('s', 'sort', False, _('sort by key (default: sort by count)')),
     ('', 'diffstat', False, _('display added/removed lines separately')),
     ('', 'aliases', '', _('file with email aliases'), _('FILE')),
     ] + commands.walkopts,
     _("hg churn [-d DATE] [-r REV] [--aliases FILE] [FILE]"),
     inferrepo=True)
 def churn(ui, repo, *pats, **opts):
     '''histogram of changes to the repository
 
     This command will display a histogram representing the number
     of changed lines or revisions, grouped according to the given
     template. The default template will group changes by author.
     The --dateformat option may be used to group the results by
     date instead.
 
     Statistics are based on the number of changed lines, or
     alternatively the number of matching revisions if the
     --changesets option is specified.
 
     Examples::
 
       # display count of changed lines for every committer
       hg churn -t "{author|email}"
 
       # display daily activity graph
       hg churn -f "%H" -s -c
 
       # display activity of developers by month
       hg churn -f "%Y-%m" -s -c
 
       # display count of lines changed in every year
       hg churn -f "%Y" -s
 
     It is possible to map alternate email addresses to a main address
     by providing a file using the following format::
 
       <alias email> = <actual email>
 
     Such a file may be specified with the --aliases option, otherwise
     a .hgchurn file will be looked for in the working directory root.
     Aliases will be split from the rightmost "=".
     '''
     def pad(s, l):
         return s + " " * (l - encoding.colwidth(s))
 
     amap = {}
     aliases = opts.get('aliases')
     if not aliases and os.path.exists(repo.wjoin('.hgchurn')):
         aliases = repo.wjoin('.hgchurn')
     if aliases:
         for l in open(aliases, "r"):
             try:
                 alias, actual = l.rsplit('=' in l and '=' or None, 1)
                 amap[alias.strip()] = actual.strip()
             except ValueError:
                 l = l.strip()
                 if l:
                     ui.warn(_("skipping malformed alias: %s\n") % l)
                 continue
 
     rate = countrate(ui, repo, amap, *pats, **opts).items()
     if not rate:
         return
 
     if opts.get('sort'):
         rate.sort()
     else:
         rate.sort(key=lambda x: (-sum(x[1]), x))
 
     # Be careful not to have a zero maxcount (issue833)
     maxcount = float(max(sum(v) for k, v in rate)) or 1.0
     maxname = max(len(k) for k, v in rate)
 
     ttywidth = ui.termwidth()
     ui.debug("assuming %i character terminal\n" % ttywidth)
     width = ttywidth - maxname - 2 - 2 - 2
 
     if opts.get('diffstat'):
         width -= 15
         def format(name, diffstat):
             added, removed = diffstat
             return "%s %15s %s%s\n" % (pad(name, maxname),
                                        '+%d/-%d' % (added, removed),
                                        ui.label('+' * charnum(added),
                                                 'diffstat.inserted'),
                                        ui.label('-' * charnum(removed),
                                                 'diffstat.deleted'))
     else:
         width -= 6
         def format(name, count):
             return "%s %6d %s\n" % (pad(name, maxname), sum(count),
                                     '*' * charnum(sum(count)))
 
     def charnum(count):
         return int(round(count * width / maxcount))
 
     for name, count in rate:
         ui.write(format(name, count))

hgext/color.py

@@ -1,683 +1,687 b''
 # color.py color output for Mercurial commands
 #
 # Copyright (C) 2007 Kevin Christen <[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.
 
 '''colorize output from some commands
 
 The color extension colorizes output from several Mercurial commands.
 For example, the diff command shows additions in green and deletions
 in red, while the status command shows modified files in magenta. Many
 other commands have analogous colors. It is possible to customize
 these colors.
 
 Effects
 -------
 
 Other effects in addition to color, like bold and underlined text, are
 also available. By default, the terminfo database is used to find the
 terminal codes used to change color and effect.  If terminfo is not
 available, then effects are rendered with the ECMA-48 SGR control
 function (aka ANSI escape codes).
 
 The available effects in terminfo mode are 'blink', 'bold', 'dim',
 'inverse', 'invisible', 'italic', 'standout', and 'underline'; in
 ECMA-48 mode, the options are 'bold', 'inverse', 'italic', and
 'underline'.  How each is rendered depends on the terminal emulator.
 Some may not be available for a given terminal type, and will be
 silently ignored.
 
 Labels
 ------
 
 Text receives color effects depending on the labels that it has. Many
 default Mercurial commands emit labelled text. You can also define
 your own labels in templates using the label function, see :hg:`help
 templates`. A single portion of text may have more than one label. In
 that case, effects given to the last label will override any other
 effects. This includes the special "none" effect, which nullifies
 other effects.
 
 Labels are normally invisible. In order to see these labels and their
 position in the text, use the global --color=debug option. The same
 anchor text may be associated to multiple labels, e.g.
 
   [log.changeset changeset.secret|changeset:   22611:6f0a53c8f587]
 
 The following are the default effects for some default labels. Default
 effects may be overridden from your configuration file::
 
   [color]
   status.modified = blue bold underline red_background
   status.added = green bold
   status.removed = red bold blue_background
   status.deleted = cyan bold underline
   status.unknown = magenta bold underline
   status.ignored = black bold
 
   # 'none' turns off all effects
   status.clean = none
   status.copied = none
 
   qseries.applied = blue bold underline
   qseries.unapplied = black bold
   qseries.missing = red bold
 
   diff.diffline = bold
   diff.extended = cyan bold
   diff.file_a = red bold
   diff.file_b = green bold
   diff.hunk = magenta
   diff.deleted = red
   diff.inserted = green
   diff.changed = white
   diff.tab =
   diff.trailingwhitespace = bold red_background
 
   # Blank so it inherits the style of the surrounding label
   changeset.public =
   changeset.draft =
   changeset.secret =
 
   resolve.unresolved = red bold
   resolve.resolved = green bold
 
   bookmarks.current = green
 
   branches.active = none
   branches.closed = black bold
   branches.current = green
   branches.inactive = none
 
   tags.normal = green
   tags.local = black bold
 
   rebase.rebased = blue
   rebase.remaining = red bold
 
   shelve.age = cyan
   shelve.newest = green bold
   shelve.name = blue bold
 
   histedit.remaining = red bold
 
 Custom colors
 -------------
 
 Because there are only eight standard colors, this module allows you
 to define color names for other color slots which might be available
 for your terminal type, assuming terminfo mode.  For instance::
 
   color.brightblue = 12
   color.pink = 207
   color.orange = 202
 
 to set 'brightblue' to color slot 12 (useful for 16 color terminals
 that have brighter colors defined in the upper eight) and, 'pink' and
 'orange' to colors in 256-color xterm's default color cube.  These
 defined colors may then be used as any of the pre-defined eight,
 including appending '_background' to set the background to that color.
 
 Modes
 -----
 
 By default, the color extension will use ANSI mode (or win32 mode on
 Windows) if it detects a terminal. To override auto mode (to enable
 terminfo mode, for example), set the following configuration option::
 
   [color]
   mode = terminfo
 
 Any value other than 'ansi', 'win32', 'terminfo', or 'auto' will
 disable color.
 
 Note that on some systems, terminfo mode may cause problems when using
 color with the pager extension and less -R. less with the -R option
 will only display ECMA-48 color codes, and terminfo mode may sometimes
 emit codes that less doesn't understand. You can work around this by
 either using ansi mode (or auto mode), or by using less -r (which will
 pass through all terminal control codes, not just color control
 codes).
 
 On some systems (such as MSYS in Windows), the terminal may support
 a different color mode than the pager (activated via the "pager"
 extension). It is possible to define separate modes depending on whether
 the pager is active::
 
   [color]
   mode = auto
   pagermode = ansi
 
 If ``pagermode`` is not defined, the ``mode`` will be used.
 '''
 
 import os
 
 from mercurial import cmdutil, commands, dispatch, extensions, subrepo, util
 from mercurial import ui as uimod
 from mercurial import templater, error
 from mercurial.i18n import _
 
 cmdtable = {}
 command = cmdutil.command(cmdtable)
+# Note for extension authors: ONLY specify testedwith = 'internal' for
+# extensions which SHIP WITH MERCURIAL. Non-mainline extensions should
+# be specifying the version(s) of Mercurial they are tested with, or
+# leave the attribute unspecified.
 testedwith = 'internal'
 
 # start and stop parameters for effects
 _effects = {'none': 0, 'black': 30, 'red': 31, 'green': 32, 'yellow': 33,
             'blue': 34, 'magenta': 35, 'cyan': 36, 'white': 37, 'bold': 1,
             'italic': 3, 'underline': 4, 'inverse': 7, 'dim': 2,
             'black_background': 40, 'red_background': 41,
             'green_background': 42, 'yellow_background': 43,
             'blue_background': 44, 'purple_background': 45,
             'cyan_background': 46, 'white_background': 47}
 
 def _terminfosetup(ui, mode):
     '''Initialize terminfo data and the terminal if we're in terminfo mode.'''
 
     global _terminfo_params
     # If we failed to load curses, we go ahead and return.
     if not _terminfo_params:
         return
     # Otherwise, see what the config file says.
     if mode not in ('auto', 'terminfo'):
         return
 
     _terminfo_params.update((key[6:], (False, int(val)))
         for key, val in ui.configitems('color')
         if key.startswith('color.'))
 
     try:
         curses.setupterm()
     except curses.error, e:
         _terminfo_params = {}
         return
 
     for key, (b, e) in _terminfo_params.items():
         if not b:
             continue
         if not curses.tigetstr(e):
             # Most terminals don't support dim, invis, etc, so don't be
             # noisy and use ui.debug().
             ui.debug("no terminfo entry for %s\n" % e)
             del _terminfo_params[key]
     if not curses.tigetstr('setaf') or not curses.tigetstr('setab'):
         # Only warn about missing terminfo entries if we explicitly asked for
         # terminfo mode.
         if mode == "terminfo":
             ui.warn(_("no terminfo entry for setab/setaf: reverting to "
               "ECMA-48 color\n"))
         _terminfo_params = {}
 
 def _modesetup(ui, coloropt):
     global _terminfo_params
 
     if coloropt == 'debug':
         return 'debug'
 
     auto = (coloropt == 'auto')
     always = not auto and util.parsebool(coloropt)
     if not always and not auto:
         return None
 
     formatted = always or (os.environ.get('TERM') != 'dumb' and ui.formatted())
 
     mode = ui.config('color', 'mode', 'auto')
 
     # If pager is active, color.pagermode overrides color.mode.
     if getattr(ui, 'pageractive', False):
         mode = ui.config('color', 'pagermode', mode)
 
     realmode = mode
     if mode == 'auto':
         if os.name == 'nt':
             term = os.environ.get('TERM')
             # TERM won't be defined in a vanilla cmd.exe environment.
 
             # UNIX-like environments on Windows such as Cygwin and MSYS will
             # set TERM. They appear to make a best effort attempt at setting it
             # to something appropriate. However, not all environments with TERM
             # defined support ANSI. Since "ansi" could result in terminal
             # gibberish, we error on the side of selecting "win32". However, if
             # w32effects is not defined, we almost certainly don't support
             # "win32", so don't even try.
             if (term and 'xterm' in term) or not w32effects:
                 realmode = 'ansi'
             else:
                 realmode = 'win32'
         else:
             realmode = 'ansi'
 
     def modewarn():
         # only warn if color.mode was explicitly set and we're in
         # an interactive terminal
         if mode == realmode and ui.interactive():
             ui.warn(_('warning: failed to set color mode to %s\n') % mode)
 
     if realmode == 'win32':
         _terminfo_params = {}
         if not w32effects:
             modewarn()
             return None
         _effects.update(w32effects)
     elif realmode == 'ansi':
         _terminfo_params = {}
     elif realmode == 'terminfo':
         _terminfosetup(ui, mode)
         if not _terminfo_params:
             ## FIXME Shouldn't we return None in this case too?
             modewarn()
             realmode = 'ansi'
     else:
         return None
 
     if always or (auto and formatted):
         return realmode
     return None
 
 try:
     import curses
     # Mapping from effect name to terminfo attribute name or color number.
     # This will also force-load the curses module.
     _terminfo_params = {'none': (True, 'sgr0'),
                         'standout': (True, 'smso'),
                         'underline': (True, 'smul'),
                         'reverse': (True, 'rev'),
                         'inverse': (True, 'rev'),
                         'blink': (True, 'blink'),
                         'dim': (True, 'dim'),
                         'bold': (True, 'bold'),
                         'invisible': (True, 'invis'),
                         'italic': (True, 'sitm'),
                         'black': (False, curses.COLOR_BLACK),
                         'red': (False, curses.COLOR_RED),
                         'green': (False, curses.COLOR_GREEN),
                         'yellow': (False, curses.COLOR_YELLOW),
                         'blue': (False, curses.COLOR_BLUE),
                         'magenta': (False, curses.COLOR_MAGENTA),
                         'cyan': (False, curses.COLOR_CYAN),
                         'white': (False, curses.COLOR_WHITE)}
 except ImportError:
     _terminfo_params = {}
 
 _styles = {'grep.match': 'red bold',
            'grep.linenumber': 'green',
            'grep.rev': 'green',
            'grep.change': 'green',
            'grep.sep': 'cyan',
            'grep.filename': 'magenta',
            'grep.user': 'magenta',
            'grep.date': 'magenta',
            'bookmarks.current': 'green',
            'branches.active': 'none',
            'branches.closed': 'black bold',
            'branches.current': 'green',
            'branches.inactive': 'none',
            'diff.changed': 'white',
            'diff.deleted': 'red',
            'diff.diffline': 'bold',
            'diff.extended': 'cyan bold',
            'diff.file_a': 'red bold',
            'diff.file_b': 'green bold',
            'diff.hunk': 'magenta',
            'diff.inserted': 'green',
            'diff.tab': '',
            'diff.trailingwhitespace': 'bold red_background',
            'changeset.public' : '',
            'changeset.draft' : '',
            'changeset.secret' : '',
            'diffstat.deleted': 'red',
            'diffstat.inserted': 'green',
            'histedit.remaining': 'red bold',
            'ui.prompt': 'yellow',
            'log.changeset': 'yellow',
            'patchbomb.finalsummary': '',
            'patchbomb.from': 'magenta',
            'patchbomb.to': 'cyan',
            'patchbomb.subject': 'green',
            'patchbomb.diffstats': '',
            'rebase.rebased': 'blue',
            'rebase.remaining': 'red bold',
            'resolve.resolved': 'green bold',
            'resolve.unresolved': 'red bold',
            'shelve.age': 'cyan',
            'shelve.newest': 'green bold',
            'shelve.name': 'blue bold',
            'status.added': 'green bold',
            'status.clean': 'none',
            'status.copied': 'none',
            'status.deleted': 'cyan bold underline',
            'status.ignored': 'black bold',
            'status.modified': 'blue bold',
            'status.removed': 'red bold',
            'status.unknown': 'magenta bold underline',
            'tags.normal': 'green',
            'tags.local': 'black bold'}
 
 
 def _effect_str(effect):
     '''Helper function for render_effects().'''
 
     bg = False
     if effect.endswith('_background'):
         bg = True
         effect = effect[:-11]
     attr, val = _terminfo_params[effect]
     if attr:
         return curses.tigetstr(val)
     elif bg:
         return curses.tparm(curses.tigetstr('setab'), val)
     else:
         return curses.tparm(curses.tigetstr('setaf'), val)
 
 def render_effects(text, effects):
     'Wrap text in commands to turn on each effect.'
     if not text:
         return text
     if not _terminfo_params:
         start = [str(_effects[e]) for e in ['none'] + effects.split()]
         start = '\033[' + ';'.join(start) + 'm'
         stop = '\033[' + str(_effects['none']) + 'm'
     else:
         start = ''.join(_effect_str(effect)
                         for effect in ['none'] + effects.split())
         stop = _effect_str('none')
     return ''.join([start, text, stop])
 
 def extstyles():
     for name, ext in extensions.extensions():
         _styles.update(getattr(ext, 'colortable', {}))
 
 def valideffect(effect):
     'Determine if the effect is valid or not.'
     good = False
     if not _terminfo_params and effect in _effects:
         good = True
     elif effect in _terminfo_params or effect[:-11] in _terminfo_params:
         good = True
     return good
 
 def configstyles(ui):
     for status, cfgeffects in ui.configitems('color'):
         if '.' not in status or status.startswith('color.'):
             continue
         cfgeffects = ui.configlist('color', status)
         if cfgeffects:
             good = []
             for e in cfgeffects:
                 if valideffect(e):
                     good.append(e)
                 else:
                     ui.warn(_("ignoring unknown color/effect %r "
                               "(configured in color.%s)\n")
                             % (e, status))
             _styles[status] = ' '.join(good)
 
 class colorui(uimod.ui):
     def popbuffer(self, labeled=False):
         if self._colormode is None:
             return super(colorui, self).popbuffer(labeled)
 
         self._bufferstates.pop()
         if labeled:
             return ''.join(self.label(a, label) for a, label
                            in self._buffers.pop())
         return ''.join(a for a, label in self._buffers.pop())
 
     _colormode = 'ansi'
     def write(self, *args, **opts):
         if self._colormode is None:
             return super(colorui, self).write(*args, **opts)
 
         label = opts.get('label', '')
         if self._buffers:
             self._buffers[-1].extend([(str(a), label) for a in args])
         elif self._colormode == 'win32':
             for a in args:
                 win32print(a, super(colorui, self).write, **opts)
         else:
             return super(colorui, self).write(
                 *[self.label(str(a), label) for a in args], **opts)
 
     def write_err(self, *args, **opts):
         if self._colormode is None:
             return super(colorui, self).write_err(*args, **opts)
 
         label = opts.get('label', '')
         if self._bufferstates and self._bufferstates[-1][0]:
             return self.write(*args, **opts)
         if self._colormode == 'win32':
             for a in args:
                 win32print(a, super(colorui, self).write_err, **opts)
         else:
             return super(colorui, self).write_err(
                 *[self.label(str(a), label) for a in args], **opts)
 
     def showlabel(self, msg, label):
         if label and msg:
             if msg[-1] == '\n':
                 return "[%s|%s]\n" % (label, msg[:-1])
             else:
                 return "[%s|%s]" % (label, msg)
         else:
             return msg
 
     def label(self, msg, label):
         if self._colormode is None:
             return super(colorui, self).label(msg, label)
 
         if self._colormode == 'debug':
             return self.showlabel(msg, label)
 
         effects = []
         for l in label.split():
             s = _styles.get(l, '')
             if s:
                 effects.append(s)
             elif valideffect(l):
                 effects.append(l)
         effects = ' '.join(effects)
         if effects:
             return '\n'.join([render_effects(s, effects)
                               for s in msg.split('\n')])
         return msg
 
 def templatelabel(context, mapping, args):
     if len(args) != 2:
         # i18n: "label" is a keyword
         raise error.ParseError(_("label expects two arguments"))
 
     # add known effects to the mapping so symbols like 'red', 'bold',
     # etc. don't need to be quoted
     mapping.update(dict([(k, k) for k in _effects]))
 
     thing = templater._evalifliteral(args[1], context, mapping)
 
     # apparently, repo could be a string that is the favicon?
     repo = mapping.get('repo', '')
     if isinstance(repo, str):
         return thing
 
     label = templater._evalifliteral(args[0], context, mapping)
 
     thing = templater.stringify(thing)
     label = templater.stringify(label)
 
     return repo.ui.label(thing, label)
 
 def uisetup(ui):
     if ui.plain():
         return
     if not isinstance(ui, colorui):
         colorui.__bases__ = (ui.__class__,)
         ui.__class__ = colorui
     def colorcmd(orig, ui_, opts, cmd, cmdfunc):
         mode = _modesetup(ui_, opts['color'])
         colorui._colormode = mode
         if mode and mode != 'debug':
             extstyles()
             configstyles(ui_)
         return orig(ui_, opts, cmd, cmdfunc)
     def colorgit(orig, gitsub, commands, env=None, stream=False, cwd=None):
         if gitsub.ui._colormode and len(commands) and commands[0] == "diff":
                 # insert the argument in the front,
                 # the end of git diff arguments is used for paths
                 commands.insert(1, '--color')
         return orig(gitsub, commands, env, stream, cwd)
     extensions.wrapfunction(dispatch, '_runcommand', colorcmd)
     extensions.wrapfunction(subrepo.gitsubrepo, '_gitnodir', colorgit)
     templater.funcs['label'] = templatelabel
 
 def extsetup(ui):
     commands.globalopts.append(
         ('', 'color', 'auto',
          # i18n: 'always', 'auto', 'never', and 'debug' are keywords
          # and should not be translated
          _("when to colorize (boolean, always, auto, never, or debug)"),
          _('TYPE')))
 
 @command('debugcolor', [], 'hg debugcolor')
 def debugcolor(ui, repo, **opts):
     global _styles
     _styles = {}
     for effect in _effects.keys():
         _styles[effect] = effect
     ui.write(('color mode: %s\n') % ui._colormode)
     ui.write(_('available colors:\n'))
     for label, colors in _styles.items():
         ui.write(('%s\n') % colors, label=label)
 
 if os.name != 'nt':
     w32effects = None
 else:
     import re, ctypes
 
     _kernel32 = ctypes.windll.kernel32
 
     _WORD = ctypes.c_ushort
 
     _INVALID_HANDLE_VALUE = -1
 
     class _COORD(ctypes.Structure):
         _fields_ = [('X', ctypes.c_short),
                     ('Y', ctypes.c_short)]
 
     class _SMALL_RECT(ctypes.Structure):
         _fields_ = [('Left', ctypes.c_short),
                     ('Top', ctypes.c_short),
                     ('Right', ctypes.c_short),
                     ('Bottom', ctypes.c_short)]
 
     class _CONSOLE_SCREEN_BUFFER_INFO(ctypes.Structure):
         _fields_ = [('dwSize', _COORD),
                     ('dwCursorPosition', _COORD),
                     ('wAttributes', _WORD),
                     ('srWindow', _SMALL_RECT),
                     ('dwMaximumWindowSize', _COORD)]
 
     _STD_OUTPUT_HANDLE = 0xfffffff5L # (DWORD)-11
     _STD_ERROR_HANDLE = 0xfffffff4L  # (DWORD)-12
 
     _FOREGROUND_BLUE = 0x0001
     _FOREGROUND_GREEN = 0x0002
     _FOREGROUND_RED = 0x0004
     _FOREGROUND_INTENSITY = 0x0008
 
     _BACKGROUND_BLUE = 0x0010
     _BACKGROUND_GREEN = 0x0020
     _BACKGROUND_RED = 0x0040
     _BACKGROUND_INTENSITY = 0x0080
 
     _COMMON_LVB_REVERSE_VIDEO = 0x4000
     _COMMON_LVB_UNDERSCORE = 0x8000
 
     # http://msdn.microsoft.com/en-us/library/ms682088%28VS.85%29.aspx
     w32effects = {
         'none': -1,
         'black': 0,
         'red': _FOREGROUND_RED,
         'green': _FOREGROUND_GREEN,
         'yellow': _FOREGROUND_RED | _FOREGROUND_GREEN,
         'blue': _FOREGROUND_BLUE,
         'magenta': _FOREGROUND_BLUE | _FOREGROUND_RED,
         'cyan': _FOREGROUND_BLUE | _FOREGROUND_GREEN,
         'white': _FOREGROUND_RED | _FOREGROUND_GREEN | _FOREGROUND_BLUE,
         'bold': _FOREGROUND_INTENSITY,
         'black_background': 0x100,                  # unused value > 0x0f
         'red_background': _BACKGROUND_RED,
         'green_background': _BACKGROUND_GREEN,
         'yellow_background': _BACKGROUND_RED | _BACKGROUND_GREEN,
         'blue_background': _BACKGROUND_BLUE,
         'purple_background': _BACKGROUND_BLUE | _BACKGROUND_RED,
         'cyan_background': _BACKGROUND_BLUE | _BACKGROUND_GREEN,
         'white_background': (_BACKGROUND_RED | _BACKGROUND_GREEN |
                              _BACKGROUND_BLUE),
         'bold_background': _BACKGROUND_INTENSITY,
         'underline': _COMMON_LVB_UNDERSCORE,  # double-byte charsets only
         'inverse': _COMMON_LVB_REVERSE_VIDEO, # double-byte charsets only
     }
 
     passthrough = set([_FOREGROUND_INTENSITY,
                        _BACKGROUND_INTENSITY,
                        _COMMON_LVB_UNDERSCORE,
                        _COMMON_LVB_REVERSE_VIDEO])
 
     stdout = _kernel32.GetStdHandle(
                   _STD_OUTPUT_HANDLE)  # don't close the handle returned
     if stdout is None or stdout == _INVALID_HANDLE_VALUE:
         w32effects = None
     else:
         csbi = _CONSOLE_SCREEN_BUFFER_INFO()
         if not _kernel32.GetConsoleScreenBufferInfo(
                     stdout, ctypes.byref(csbi)):
             # stdout may not support GetConsoleScreenBufferInfo()
             # when called from subprocess or redirected
             w32effects = None
         else:
             origattr = csbi.wAttributes
             ansire = re.compile('\033\[([^m]*)m([^\033]*)(.*)',
                                 re.MULTILINE | re.DOTALL)
 
     def win32print(text, orig, **opts):
         label = opts.get('label', '')
         attr = origattr
 
         def mapcolor(val, attr):
             if val == -1:
                 return origattr
             elif val in passthrough:
                 return attr | val
             elif val > 0x0f:
                 return (val & 0x70) | (attr & 0x8f)
             else:
                 return (val & 0x07) | (attr & 0xf8)
 
         # determine console attributes based on labels
         for l in label.split():
             style = _styles.get(l, '')
             for effect in style.split():
                 try:
                     attr = mapcolor(w32effects[effect], attr)
                 except KeyError:
                     # w32effects could not have certain attributes so we skip
                     # them if not found
                     pass
         # hack to ensure regexp finds data
         if not text.startswith('\033['):
             text = '\033[m' + text
 
         # Look for ANSI-like codes embedded in text
         m = re.match(ansire, text)
 
         try:
             while m:
                 for sattr in m.group(1).split(';'):
                     if sattr:
                         attr = mapcolor(int(sattr), attr)
                 _kernel32.SetConsoleTextAttribute(stdout, attr)
                 orig(m.group(2), **opts)
                 m = re.match(ansire, m.group(3))
         finally:
             # Explicitly reset original attributes
             _kernel32.SetConsoleTextAttribute(stdout, origattr)

hgext/convert/__init__.py

@@ -1,405 +1,409 b''
 # convert.py Foreign SCM converter
 #
 # Copyright 2005-2007 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 revisions from foreign VCS repositories into Mercurial'''
 
 import convcmd
 import cvsps
 import subversion
 from mercurial import cmdutil, templatekw
 from mercurial.i18n import _
 
 cmdtable = {}
 command = cmdutil.command(cmdtable)
+# Note for extension authors: ONLY specify testedwith = 'internal' for
+# extensions which SHIP WITH MERCURIAL. Non-mainline extensions should
+# be specifying the version(s) of Mercurial they are tested with, or
+# leave the attribute unspecified.
 testedwith = 'internal'
 
 # Commands definition was moved elsewhere to ease demandload job.
 
 @command('convert',
     [('', 'authors', '',
       _('username mapping filename (DEPRECATED, use --authormap instead)'),
       _('FILE')),
     ('s', 'source-type', '', _('source repository type'), _('TYPE')),
     ('d', 'dest-type', '', _('destination repository type'), _('TYPE')),
     ('r', 'rev', '', _('import up to source revision REV'), _('REV')),
     ('A', 'authormap', '', _('remap usernames using this file'), _('FILE')),
     ('', 'filemap', '', _('remap file names using contents of file'),
      _('FILE')),
     ('', 'full', None,
      _('apply filemap changes by converting all files again')),
     ('', 'splicemap', '', _('splice synthesized history into place'),
      _('FILE')),
     ('', 'branchmap', '', _('change branch names while converting'),
      _('FILE')),
     ('', 'branchsort', None, _('try to sort changesets by branches')),
     ('', 'datesort', None, _('try to sort changesets by date')),
     ('', 'sourcesort', None, _('preserve source changesets order')),
     ('', 'closesort', None, _('try to reorder closed revisions'))],
    _('hg convert [OPTION]... SOURCE [DEST [REVMAP]]'),
    norepo=True)
 def convert(ui, src, dest=None, revmapfile=None, **opts):
     """convert a foreign SCM repository to a Mercurial one.
 
     Accepted source formats [identifiers]:
 
     - Mercurial [hg]
     - CVS [cvs]
     - Darcs [darcs]
     - git [git]
     - Subversion [svn]
     - Monotone [mtn]
     - GNU Arch [gnuarch]
     - Bazaar [bzr]
     - Perforce [p4]
 
     Accepted destination formats [identifiers]:
 
     - Mercurial [hg]
     - Subversion [svn] (history on branches is not preserved)
 
     If no revision is given, all revisions will be converted.
     Otherwise, convert will only import up to the named revision
     (given in a format understood by the source).
 
     If no destination directory name is specified, it defaults to the
     basename of the source with ``-hg`` appended. If the destination
     repository doesn't exist, it will be created.
 
     By default, all sources except Mercurial will use --branchsort.
     Mercurial uses --sourcesort to preserve original revision numbers
     order. Sort modes have the following effects:
 
     --branchsort  convert from parent to child revision when possible,
                   which means branches are usually converted one after
                   the other. It generates more compact repositories.
 
     --datesort    sort revisions by date. Converted repositories have
                   good-looking changelogs but are often an order of
                   magnitude larger than the same ones generated by
                   --branchsort.
 
     --sourcesort  try to preserve source revisions order, only
                   supported by Mercurial sources.
 
     --closesort   try to move closed revisions as close as possible
                   to parent branches, only supported by Mercurial
                   sources.
 
     If ``REVMAP`` isn't given, it will be put in a default location
     (``<dest>/.hg/shamap`` by default). The ``REVMAP`` is a simple
     text file that maps each source commit ID to the destination ID
     for that revision, like so::
 
       <source ID> <destination ID>
 
     If the file doesn't exist, it's automatically created. It's
     updated on each commit copied, so :hg:`convert` can be interrupted
     and can be run repeatedly to copy new commits.
 
     The authormap is a simple text file that maps each source commit
     author to a destination commit author. It is handy for source SCMs
     that use unix logins to identify authors (e.g.: CVS). One line per
     author mapping and the line format is::
 
       source author = destination author
 
     Empty lines and lines starting with a ``#`` are ignored.
 
     The filemap is a file that allows filtering and remapping of files
     and directories. Each line can contain one of the following
     directives::
 
       include path/to/file-or-dir
 
       exclude path/to/file-or-dir
 
       rename path/to/source path/to/destination
 
     Comment lines start with ``#``. A specified path matches if it
     equals the full relative name of a file or one of its parent
     directories. The ``include`` or ``exclude`` directive with the
     longest matching path applies, so line order does not matter.
 
     The ``include`` directive causes a file, or all files under a
     directory, to be included in the destination repository. The default
     if there are no ``include`` statements is to include everything.
     If there are any ``include`` statements, nothing else is included.
     The ``exclude`` directive causes files or directories to
     be omitted. The ``rename`` directive renames a file or directory if
     it is converted. To rename from a subdirectory into the root of
     the repository, use ``.`` as the path to rename to.
 
     ``--full`` will make sure the converted changesets contain exactly
     the right files with the right content. It will make a full
     conversion of all files, not just the ones that have
     changed. Files that already are correct will not be changed. This
     can be used to apply filemap changes when converting
     incrementally. This is currently only supported for Mercurial and
     Subversion.
 
     The splicemap is a file that allows insertion of synthetic
     history, letting you specify the parents of a revision. This is
     useful if you want to e.g. give a Subversion merge two parents, or
     graft two disconnected series of history together. Each entry
     contains a key, followed by a space, followed by one or two
     comma-separated values::
 
       key parent1, parent2
 
     The key is the revision ID in the source
     revision control system whose parents should be modified (same
     format as a key in .hg/shamap). The values are the revision IDs
     (in either the source or destination revision control system) that
     should be used as the new parents for that node. For example, if
     you have merged "release-1.0" into "trunk", then you should
     specify the revision on "trunk" as the first parent and the one on
     the "release-1.0" branch as the second.
 
     The branchmap is a file that allows you to rename a branch when it is
     being brought in from whatever external repository. When used in
     conjunction with a splicemap, it allows for a powerful combination
     to help fix even the most badly mismanaged repositories and turn them
     into nicely structured Mercurial repositories. The branchmap contains
     lines of the form::
 
       original_branch_name new_branch_name
 
     where "original_branch_name" is the name of the branch in the
     source repository, and "new_branch_name" is the name of the branch
     is the destination repository. No whitespace is allowed in the
     branch names. This can be used to (for instance) move code in one
     repository from "default" to a named branch.
 
     Mercurial Source
     ################
 
     The Mercurial source recognizes the following configuration
     options, which you can set on the command line with ``--config``:
 
     :convert.hg.ignoreerrors: ignore integrity errors when reading.
         Use it to fix Mercurial repositories with missing revlogs, by
         converting from and to Mercurial. Default is False.
 
     :convert.hg.saverev: store original revision ID in changeset
         (forces target IDs to change). It takes a boolean argument and
         defaults to False.
 
     :convert.hg.revs: revset specifying the source revisions to convert.
 
     CVS Source
     ##########
 
     CVS source will use a sandbox (i.e. a checked-out copy) from CVS
     to indicate the starting point of what will be converted. Direct
     access to the repository files is not needed, unless of course the
     repository is ``:local:``. The conversion uses the top level
     directory in the sandbox to find the CVS repository, and then uses
     CVS rlog commands to find files to convert. This means that unless
     a filemap is given, all files under the starting directory will be
     converted, and that any directory reorganization in the CVS
     sandbox is ignored.
 
     The following options can be used with ``--config``:
 
     :convert.cvsps.cache: Set to False to disable remote log caching,
         for testing and debugging purposes. Default is True.
 
     :convert.cvsps.fuzz: Specify the maximum time (in seconds) that is
         allowed between commits with identical user and log message in
         a single changeset. When very large files were checked in as
         part of a changeset then the default may not be long enough.
         The default is 60.
 
     :convert.cvsps.mergeto: Specify a regular expression to which
         commit log messages are matched. If a match occurs, then the
         conversion process will insert a dummy revision merging the
         branch on which this log message occurs to the branch
         indicated in the regex. Default is ``{{mergetobranch
         ([-\\w]+)}}``
 
     :convert.cvsps.mergefrom: Specify a regular expression to which
         commit log messages are matched. If a match occurs, then the
         conversion process will add the most recent revision on the
         branch indicated in the regex as the second parent of the
         changeset. Default is ``{{mergefrombranch ([-\\w]+)}}``
 
     :convert.localtimezone: use local time (as determined by the TZ
         environment variable) for changeset date/times. The default
         is False (use UTC).
 
     :hooks.cvslog: Specify a Python function to be called at the end of
         gathering the CVS log. The function is passed a list with the
         log entries, and can modify the entries in-place, or add or
         delete them.
 
     :hooks.cvschangesets: Specify a Python function to be called after
         the changesets are calculated from the CVS log. The
         function is passed a list with the changeset entries, and can
         modify the changesets in-place, or add or delete them.
 
     An additional "debugcvsps" Mercurial command allows the builtin
     changeset merging code to be run without doing a conversion. Its
     parameters and output are similar to that of cvsps 2.1. Please see
     the command help for more details.
 
     Subversion Source
     #################
 
     Subversion source detects classical trunk/branches/tags layouts.
     By default, the supplied ``svn://repo/path/`` source URL is
     converted as a single branch. If ``svn://repo/path/trunk`` exists
     it replaces the default branch. If ``svn://repo/path/branches``
     exists, its subdirectories are listed as possible branches. If
     ``svn://repo/path/tags`` exists, it is looked for tags referencing
     converted branches. Default ``trunk``, ``branches`` and ``tags``
     values can be overridden with following options. Set them to paths
     relative to the source URL, or leave them blank to disable auto
     detection.
 
     The following options can be set with ``--config``:
 
     :convert.svn.branches: specify the directory containing branches.
         The default is ``branches``.
 
     :convert.svn.tags: specify the directory containing tags. The
         default is ``tags``.
 
     :convert.svn.trunk: specify the name of the trunk branch. The
         default is ``trunk``.
 
     :convert.localtimezone: use local time (as determined by the TZ
         environment variable) for changeset date/times. The default
         is False (use UTC).
 
     Source history can be retrieved starting at a specific revision,
     instead of being integrally converted. Only single branch
     conversions are supported.
 
     :convert.svn.startrev: specify start Subversion revision number.
         The default is 0.
 
     Git Source
     ##########
 
     The Git importer converts commits from all reachable branches (refs
     in refs/heads) and remotes (refs in refs/remotes) to Mercurial.
     Branches are converted to bookmarks with the same name, with the
     leading 'refs/heads' stripped. Git submodules are converted to Git
     subrepos in Mercurial.
 
     The following options can be set with ``--config``:
 
     :convert.git.similarity: specify how similar files modified in a
         commit must be to be imported as renames or copies, as a
         percentage between ``0`` (disabled) and ``100`` (files must be
         identical). For example, ``90`` means that a delete/add pair will
         be imported as a rename if more than 90% of the file hasn't
         changed. The default is ``50``.
 
     :convert.git.findcopiesharder: while detecting copies, look at all
         files in the working copy instead of just changed ones. This
         is very expensive for large projects, and is only effective when
         ``convert.git.similarity`` is greater than 0. The default is False.
 
     Perforce Source
     ###############
 
     The Perforce (P4) importer can be given a p4 depot path or a
     client specification as source. It will convert all files in the
     source to a flat Mercurial repository, ignoring labels, branches
     and integrations. Note that when a depot path is given you then
     usually should specify a target directory, because otherwise the
     target may be named ``...-hg``.
 
     It is possible to limit the amount of source history to be
     converted by specifying an initial Perforce revision:
 
     :convert.p4.startrev: specify initial Perforce revision (a
         Perforce changelist number).
 
     Mercurial Destination
     #####################
 
     The following options are supported:
 
     :convert.hg.clonebranches: dispatch source branches in separate
         clones. The default is False.
 
     :convert.hg.tagsbranch: branch name for tag revisions, defaults to
         ``default``.
 
     :convert.hg.usebranchnames: preserve branch names. The default is
         True.
     """
     return convcmd.convert(ui, src, dest, revmapfile, **opts)
 
 @command('debugsvnlog', [], 'hg debugsvnlog', norepo=True)
 def debugsvnlog(ui, **opts):
     return subversion.debugsvnlog(ui, **opts)
 
 @command('debugcvsps',
     [
     # Main options shared with cvsps-2.1
     ('b', 'branches', [], _('only return changes on specified branches')),
     ('p', 'prefix', '', _('prefix to remove from file names')),
     ('r', 'revisions', [],
      _('only return changes after or between specified tags')),
     ('u', 'update-cache', None, _("update cvs log cache")),
     ('x', 'new-cache', None, _("create new cvs log cache")),
     ('z', 'fuzz', 60, _('set commit time fuzz in seconds')),
     ('', 'root', '', _('specify cvsroot')),
     # Options specific to builtin cvsps
     ('', 'parents', '', _('show parent changesets')),
     ('', 'ancestors', '', _('show current changeset in ancestor branches')),
     # Options that are ignored for compatibility with cvsps-2.1
     ('A', 'cvs-direct', None, _('ignored for compatibility')),
     ],
     _('hg debugcvsps [OPTION]... [PATH]...'),
     norepo=True)
 def debugcvsps(ui, *args, **opts):
     '''create changeset information from CVS
 
     This command is intended as a debugging tool for the CVS to
     Mercurial converter, and can be used as a direct replacement for
     cvsps.
 
     Hg debugcvsps reads the CVS rlog for current directory (or any
     named directory) in the CVS repository, and converts the log to a
     series of changesets based on matching commit log entries and
     dates.'''
     return cvsps.debugcvsps(ui, *args, **opts)
 
 def kwconverted(ctx, name):
     rev = ctx.extra().get('convert_revision', '')
     if rev.startswith('svn:'):
         if name == 'svnrev':
             return str(subversion.revsplit(rev)[2])
         elif name == 'svnpath':
             return subversion.revsplit(rev)[1]
         elif name == 'svnuuid':
             return subversion.revsplit(rev)[0]
     return rev
 
 def kwsvnrev(repo, ctx, **args):
     """:svnrev: String. Converted subversion revision number."""
     return kwconverted(ctx, 'svnrev')
 
 def kwsvnpath(repo, ctx, **args):
     """:svnpath: String. Converted subversion revision project path."""
     return kwconverted(ctx, 'svnpath')
 
 def kwsvnuuid(repo, ctx, **args):
     """:svnuuid: String. Converted subversion revision repository identifier."""
     return kwconverted(ctx, 'svnuuid')
 
 def extsetup(ui):
     templatekw.keywords['svnrev'] = kwsvnrev
     templatekw.keywords['svnpath'] = kwsvnpath
     templatekw.keywords['svnuuid'] = kwsvnuuid
 
 # tell hggettext to extract docstrings from these functions:
 i18nfunctions = [kwsvnrev, kwsvnpath, kwsvnuuid]

hgext/eol.py

@@ -1,350 +1,354 b''
 """automatically manage newlines in repository files
 
 This extension allows you to manage the type of line endings (CRLF or
 LF) that are used in the repository and in the local working
 directory. That way you can get CRLF line endings on Windows and LF on
 Unix/Mac, thereby letting everybody use their OS native line endings.
 
 The extension reads its configuration from a versioned ``.hgeol``
 configuration file found in the root of the working directory. The
 ``.hgeol`` file use the same syntax as all other Mercurial
 configuration files. It uses two sections, ``[patterns]`` and
 ``[repository]``.
 
 The ``[patterns]`` section specifies how line endings should be
 converted between the working directory and the repository. The format is
 specified by a file pattern. The first match is used, so put more
 specific patterns first. The available line endings are ``LF``,
 ``CRLF``, and ``BIN``.
 
 Files with the declared format of ``CRLF`` or ``LF`` are always
 checked out and stored in the repository in that format and files
 declared to be binary (``BIN``) are left unchanged. Additionally,
 ``native`` is an alias for checking out in the platform's default line
 ending: ``LF`` on Unix (including Mac OS X) and ``CRLF`` on
 Windows. Note that ``BIN`` (do nothing to line endings) is Mercurial's
 default behaviour; it is only needed if you need to override a later,
 more general pattern.
 
 The optional ``[repository]`` section specifies the line endings to
 use for files stored in the repository. It has a single setting,
 ``native``, which determines the storage line endings for files
 declared as ``native`` in the ``[patterns]`` section. It can be set to
 ``LF`` or ``CRLF``. The default is ``LF``. For example, this means
 that on Windows, files configured as ``native`` (``CRLF`` by default)
 will be converted to ``LF`` when stored in the repository. Files
 declared as ``LF``, ``CRLF``, or ``BIN`` in the ``[patterns]`` section
 are always stored as-is in the repository.
 
 Example versioned ``.hgeol`` file::
 
   [patterns]
   **.py = native
   **.vcproj = CRLF
   **.txt = native
   Makefile = LF
   **.jpg = BIN
 
   [repository]
   native = LF
 
 .. note::
 
    The rules will first apply when files are touched in the working
    directory, e.g. by updating to null and back to tip to touch all files.
 
 The extension uses an optional ``[eol]`` section read from both the
 normal Mercurial configuration files and the ``.hgeol`` file, with the
 latter overriding the former. You can use that section to control the
 overall behavior. There are three settings:
 
 - ``eol.native`` (default ``os.linesep``) can be set to ``LF`` or
   ``CRLF`` to override the default interpretation of ``native`` for
   checkout. This can be used with :hg:`archive` on Unix, say, to
   generate an archive where files have line endings for Windows.
 
 - ``eol.only-consistent`` (default True) can be set to False to make
   the extension convert files with inconsistent EOLs. Inconsistent
   means that there is both ``CRLF`` and ``LF`` present in the file.
   Such files are normally not touched under the assumption that they
   have mixed EOLs on purpose.
 
 - ``eol.fix-trailing-newline`` (default False) can be set to True to
   ensure that converted files end with a EOL character (either ``\\n``
   or ``\\r\\n`` as per the configured patterns).
 
 The extension provides ``cleverencode:`` and ``cleverdecode:`` filters
 like the deprecated win32text extension does. This means that you can
 disable win32text and enable eol and your filters will still work. You
 only need to these filters until you have prepared a ``.hgeol`` file.
 
 The ``win32text.forbid*`` hooks provided by the win32text extension
 have been unified into a single hook named ``eol.checkheadshook``. The
 hook will lookup the expected line endings from the ``.hgeol`` file,
 which means you must migrate to a ``.hgeol`` file first before using
 the hook. ``eol.checkheadshook`` only checks heads, intermediate
 invalid revisions will be pushed. To forbid them completely, use the
 ``eol.checkallhook`` hook. These hooks are best used as
 ``pretxnchangegroup`` hooks.
 
 See :hg:`help patterns` for more information about the glob patterns
 used.
 """
 
 from mercurial.i18n import _
 from mercurial import util, config, extensions, match, error
 import re, os
 
+# Note for extension authors: ONLY specify testedwith = 'internal' for
+# extensions which SHIP WITH MERCURIAL. Non-mainline extensions should
+# be specifying the version(s) of Mercurial they are tested with, or
+# leave the attribute unspecified.
 testedwith = 'internal'
 
 # Matches a lone LF, i.e., one that is not part of CRLF.
 singlelf = re.compile('(^|[^\r])\n')
 # Matches a single EOL which can either be a CRLF where repeated CR
 # are removed or a LF. We do not care about old Macintosh files, so a
 # stray CR is an error.
 eolre = re.compile('\r*\n')
 
 
 def inconsistenteol(data):
     return '\r\n' in data and singlelf.search(data)
 
 def tolf(s, params, ui, **kwargs):
     """Filter to convert to LF EOLs."""
     if util.binary(s):
         return s
     if ui.configbool('eol', 'only-consistent', True) and inconsistenteol(s):
         return s
     if (ui.configbool('eol', 'fix-trailing-newline', False)
         and s and s[-1] != '\n'):
         s = s + '\n'
     return eolre.sub('\n', s)
 
 def tocrlf(s, params, ui, **kwargs):
     """Filter to convert to CRLF EOLs."""
     if util.binary(s):
         return s
     if ui.configbool('eol', 'only-consistent', True) and inconsistenteol(s):
         return s
     if (ui.configbool('eol', 'fix-trailing-newline', False)
         and s and s[-1] != '\n'):
         s = s + '\n'
     return eolre.sub('\r\n', s)
 
 def isbinary(s, params):
     """Filter to do nothing with the file."""
     return s
 
 filters = {
     'to-lf': tolf,
     'to-crlf': tocrlf,
     'is-binary': isbinary,
     # The following provide backwards compatibility with win32text
     'cleverencode:': tolf,
     'cleverdecode:': tocrlf
 }
 
 class eolfile(object):
     def __init__(self, ui, root, data):
         self._decode = {'LF': 'to-lf', 'CRLF': 'to-crlf', 'BIN': 'is-binary'}
         self._encode = {'LF': 'to-lf', 'CRLF': 'to-crlf', 'BIN': 'is-binary'}
 
         self.cfg = config.config()
         # Our files should not be touched. The pattern must be
         # inserted first override a '** = native' pattern.
         self.cfg.set('patterns', '.hg*', 'BIN', 'eol')
         # We can then parse the user's patterns.
         self.cfg.parse('.hgeol', data)
 
         isrepolf = self.cfg.get('repository', 'native') != 'CRLF'
         self._encode['NATIVE'] = isrepolf and 'to-lf' or 'to-crlf'
         iswdlf = ui.config('eol', 'native', os.linesep) in ('LF', '\n')
         self._decode['NATIVE'] = iswdlf and 'to-lf' or 'to-crlf'
 
         include = []
         exclude = []
         for pattern, style in self.cfg.items('patterns'):
             key = style.upper()
             if key == 'BIN':
                 exclude.append(pattern)
             else:
                 include.append(pattern)
         # This will match the files for which we need to care
         # about inconsistent newlines.
         self.match = match.match(root, '', [], include, exclude)
 
     def copytoui(self, ui):
         for pattern, style in self.cfg.items('patterns'):
             key = style.upper()
             try:
                 ui.setconfig('decode', pattern, self._decode[key], 'eol')
                 ui.setconfig('encode', pattern, self._encode[key], 'eol')
             except KeyError:
                 ui.warn(_("ignoring unknown EOL style '%s' from %s\n")
                         % (style, self.cfg.source('patterns', pattern)))
         # eol.only-consistent can be specified in ~/.hgrc or .hgeol
         for k, v in self.cfg.items('eol'):
             ui.setconfig('eol', k, v, 'eol')
 
     def checkrev(self, repo, ctx, files):
         failed = []
         for f in (files or ctx.files()):
             if f not in ctx:
                 continue
             for pattern, style in self.cfg.items('patterns'):
                 if not match.match(repo.root, '', [pattern])(f):
                     continue
                 target = self._encode[style.upper()]
                 data = ctx[f].data()
                 if (target == "to-lf" and "\r\n" in data
                     or target == "to-crlf" and singlelf.search(data)):
                     failed.append((str(ctx), target, f))
                 break
         return failed
 
 def parseeol(ui, repo, nodes):
     try:
         for node in nodes:
             try:
                 if node is None:
                     # Cannot use workingctx.data() since it would load
                     # and cache the filters before we configure them.
                     data = repo.wfile('.hgeol').read()
                 else:
                     data = repo[node]['.hgeol'].data()
                 return eolfile(ui, repo.root, data)
             except (IOError, LookupError):
                 pass
     except error.ParseError, inst:
         ui.warn(_("warning: ignoring .hgeol file due to parse error "
                   "at %s: %s\n") % (inst.args[1], inst.args[0]))
     return None
 
 def _checkhook(ui, repo, node, headsonly):
     # Get revisions to check and touched files at the same time
     files = set()
     revs = set()
     for rev in xrange(repo[node].rev(), len(repo)):
         revs.add(rev)
         if headsonly:
             ctx = repo[rev]
             files.update(ctx.files())
             for pctx in ctx.parents():
                 revs.discard(pctx.rev())
     failed = []
     for rev in revs:
         ctx = repo[rev]
         eol = parseeol(ui, repo, [ctx.node()])
         if eol:
             failed.extend(eol.checkrev(repo, ctx, files))
 
     if failed:
         eols = {'to-lf': 'CRLF', 'to-crlf': 'LF'}
         msgs = []
         for node, target, f in failed:
             msgs.append(_("  %s in %s should not have %s line endings") %
                         (f, node, eols[target]))
         raise util.Abort(_("end-of-line check failed:\n") + "\n".join(msgs))
 
 def checkallhook(ui, repo, node, hooktype, **kwargs):
     """verify that files have expected EOLs"""
     _checkhook(ui, repo, node, False)
 
 def checkheadshook(ui, repo, node, hooktype, **kwargs):
     """verify that files have expected EOLs"""
     _checkhook(ui, repo, node, True)
 
 # "checkheadshook" used to be called "hook"
 hook = checkheadshook
 
 def preupdate(ui, repo, hooktype, parent1, parent2):
     repo.loadeol([parent1])
     return False
 
 def uisetup(ui):
     ui.setconfig('hooks', 'preupdate.eol', preupdate, 'eol')
 
 def extsetup(ui):
     try:
         extensions.find('win32text')
         ui.warn(_("the eol extension is incompatible with the "
                   "win32text extension\n"))
     except KeyError:
         pass
 
 
 def reposetup(ui, repo):
     uisetup(repo.ui)
 
     if not repo.local():
         return
     for name, fn in filters.iteritems():
         repo.adddatafilter(name, fn)
 
     ui.setconfig('patch', 'eol', 'auto', 'eol')
 
     class eolrepo(repo.__class__):
 
         def loadeol(self, nodes):
             eol = parseeol(self.ui, self, nodes)
             if eol is None:
                 return None
             eol.copytoui(self.ui)
             return eol.match
 
         def _hgcleardirstate(self):
             self._eolfile = self.loadeol([None, 'tip'])
             if not self._eolfile:
                 self._eolfile = util.never
                 return
 
             try:
                 cachemtime = os.path.getmtime(self.join("eol.cache"))
             except OSError:
                 cachemtime = 0
 
             try:
                 eolmtime = os.path.getmtime(self.wjoin(".hgeol"))
             except OSError:
                 eolmtime = 0
 
             if eolmtime > cachemtime:
                 self.ui.debug("eol: detected change in .hgeol\n")
                 wlock = None
                 try:
                     wlock = self.wlock()
                     for f in self.dirstate:
                         if self.dirstate[f] == 'n':
                             # all normal files need to be looked at
                             # again since the new .hgeol file might no
                             # longer match a file it matched before
                             self.dirstate.normallookup(f)
                     # Create or touch the cache to update mtime
                     self.vfs("eol.cache", "w").close()
                     wlock.release()
                 except error.LockUnavailable:
                     # If we cannot lock the repository and clear the
                     # dirstate, then a commit might not see all files
                     # as modified. But if we cannot lock the
                     # repository, then we can also not make a commit,
                     # so ignore the error.
                     pass
 
         def commitctx(self, ctx, error=False):
             for f in sorted(ctx.added() + ctx.modified()):
                 if not self._eolfile(f):
                     continue
                 fctx = ctx[f]
                 if fctx is None:
                     continue
                 data = fctx.data()
                 if util.binary(data):
                     # We should not abort here, since the user should
                     # be able to say "** = native" to automatically
                     # have all non-binary files taken care of.
                     continue
                 if inconsistenteol(data):
                     raise util.Abort(_("inconsistent newline style "
                                        "in %s\n") % f)
             return super(eolrepo, self).commitctx(ctx, error)
     repo.__class__ = eolrepo
     repo._hgcleardirstate()

hgext/extdiff.py

@@ -1,340 +1,344 b''
 # extdiff.py - external diff program support for mercurial
 #
 # Copyright 2006 Vadim Gelfer <[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 allow external programs to compare revisions
 
 The extdiff Mercurial extension allows you to use external programs
 to compare revisions, or revision with working directory. The external
 diff programs are called with a configurable set of options and two
 non-option arguments: paths to directories containing snapshots of
 files to compare.
 
 The extdiff extension also allows you to configure new diff commands, so
 you do not need to type :hg:`extdiff -p kdiff3` always. ::
 
   [extdiff]
   # add new command that runs GNU diff(1) in 'context diff' mode
   cdiff = gdiff -Nprc5
   ## or the old way:
   #cmd.cdiff = gdiff
   #opts.cdiff = -Nprc5
 
   # add new command called meld, runs meld (no need to name twice).  If
   # the meld executable is not available, the meld tool in [merge-tools]
   # will be used, if available
   meld =
 
   # add new command called vimdiff, runs gvimdiff with DirDiff plugin
   # (see http://www.vim.org/scripts/script.php?script_id=102) Non
   # English user, be sure to put "let g:DirDiffDynamicDiffText = 1" in
   # your .vimrc
   vimdiff = gvim -f "+next" \\
             "+execute 'DirDiff' fnameescape(argv(0)) fnameescape(argv(1))"
 
 Tool arguments can include variables that are expanded at runtime::
 
   $parent1, $plabel1 - filename, descriptive label of first parent
   $child,   $clabel  - filename, descriptive label of child revision
   $parent2, $plabel2 - filename, descriptive label of second parent
   $root              - repository root
   $parent is an alias for $parent1.
 
 The extdiff extension will look in your [diff-tools] and [merge-tools]
 sections for diff tool arguments, when none are specified in [extdiff].
 
 ::
 
   [extdiff]
   kdiff3 =
 
   [diff-tools]
   kdiff3.diffargs=--L1 '$plabel1' --L2 '$clabel' $parent $child
 
 You can use -I/-X and list of file or directory names like normal
 :hg:`diff` command. The extdiff extension makes snapshots of only
 needed files, so running the external diff program will actually be
 pretty fast (at least faster than having to compare the entire tree).
 '''
 
 from mercurial.i18n import _
 from mercurial.node import short, nullid
 from mercurial import cmdutil, scmutil, util, commands, encoding, filemerge
 import os, shlex, shutil, tempfile, re
 
 cmdtable = {}
 command = cmdutil.command(cmdtable)
+# Note for extension authors: ONLY specify testedwith = 'internal' for
+# extensions which SHIP WITH MERCURIAL. Non-mainline extensions should
+# be specifying the version(s) of Mercurial they are tested with, or
+# leave the attribute unspecified.
 testedwith = 'internal'
 
 def snapshot(ui, repo, files, node, tmproot):
     '''snapshot files as of some revision
     if not using snapshot, -I/-X does not work and recursive diff
     in tools like kdiff3 and meld displays too many files.'''
     dirname = os.path.basename(repo.root)
     if dirname == "":
         dirname = "root"
     if node is not None:
         dirname = '%s.%s' % (dirname, short(node))
     base = os.path.join(tmproot, dirname)
     os.mkdir(base)
     if node is not None:
         ui.note(_('making snapshot of %d files from rev %s\n') %
                 (len(files), short(node)))
     else:
         ui.note(_('making snapshot of %d files from working directory\n') %
             (len(files)))
     wopener = scmutil.opener(base)
     fns_and_mtime = []
     ctx = repo[node]
     for fn in sorted(files):
         wfn = util.pconvert(fn)
         if wfn not in ctx:
             # File doesn't exist; could be a bogus modify
             continue
         ui.note('  %s\n' % wfn)
         dest = os.path.join(base, wfn)
         fctx = ctx[wfn]
         data = repo.wwritedata(wfn, fctx.data())
         if 'l' in fctx.flags():
             wopener.symlink(data, wfn)
         else:
             wopener.write(wfn, data)
             if 'x' in fctx.flags():
                 util.setflags(dest, False, True)
         if node is None:
             fns_and_mtime.append((dest, repo.wjoin(fn),
                                   os.lstat(dest).st_mtime))
     return dirname, fns_and_mtime
 
 def dodiff(ui, repo, cmdline, pats, opts):
     '''Do the actual diff:
 
     - copy to a temp structure if diffing 2 internal revisions
     - copy to a temp structure if diffing working revision with
       another one and more than 1 file is changed
     - just invoke the diff for a single file in the working dir
     '''
 
     revs = opts.get('rev')
     change = opts.get('change')
     do3way = '$parent2' in cmdline
 
     if revs and change:
         msg = _('cannot specify --rev and --change at the same time')
         raise util.Abort(msg)
     elif change:
         node2 = scmutil.revsingle(repo, change, None).node()
         node1a, node1b = repo.changelog.parents(node2)
     else:
         node1a, node2 = scmutil.revpair(repo, revs)
         if not revs:
             node1b = repo.dirstate.p2()
         else:
             node1b = nullid
 
     # Disable 3-way merge if there is only one parent
     if do3way:
         if node1b == nullid:
             do3way = False
 
     matcher = scmutil.match(repo[node2], pats, opts)
     mod_a, add_a, rem_a = map(set, repo.status(node1a, node2, matcher)[:3])
     if do3way:
         mod_b, add_b, rem_b = map(set, repo.status(node1b, node2, matcher)[:3])
     else:
         mod_b, add_b, rem_b = set(), set(), set()
     modadd = mod_a | add_a | mod_b | add_b
     common = modadd | rem_a | rem_b
     if not common:
         return 0
 
     tmproot = tempfile.mkdtemp(prefix='extdiff.')
     try:
         # Always make a copy of node1a (and node1b, if applicable)
         dir1a_files = mod_a | rem_a | ((mod_b | add_b) - add_a)
         dir1a = snapshot(ui, repo, dir1a_files, node1a, tmproot)[0]
         rev1a = '@%d' % repo[node1a].rev()
         if do3way:
             dir1b_files = mod_b | rem_b | ((mod_a | add_a) - add_b)
             dir1b = snapshot(ui, repo, dir1b_files, node1b, tmproot)[0]
             rev1b = '@%d' % repo[node1b].rev()
         else:
             dir1b = None
             rev1b = ''
 
         fns_and_mtime = []
 
         # If node2 in not the wc or there is >1 change, copy it
         dir2root = ''
         rev2 = ''
         if node2:
             dir2 = snapshot(ui, repo, modadd, node2, tmproot)[0]
             rev2 = '@%d' % repo[node2].rev()
         elif len(common) > 1:
             #we only actually need to get the files to copy back to
             #the working dir in this case (because the other cases
             #are: diffing 2 revisions or single file -- in which case
             #the file is already directly passed to the diff tool).
             dir2, fns_and_mtime = snapshot(ui, repo, modadd, None, tmproot)
         else:
             # This lets the diff tool open the changed file directly
             dir2 = ''
             dir2root = repo.root
 
         label1a = rev1a
         label1b = rev1b
         label2 = rev2
 
         # If only one change, diff the files instead of the directories
         # Handle bogus modifies correctly by checking if the files exist
         if len(common) == 1:
             common_file = util.localpath(common.pop())
             dir1a = os.path.join(tmproot, dir1a, common_file)
             label1a = common_file + rev1a
             if not os.path.isfile(dir1a):
                 dir1a = os.devnull
             if do3way:
                 dir1b = os.path.join(tmproot, dir1b, common_file)
                 label1b = common_file + rev1b
                 if not os.path.isfile(dir1b):
                     dir1b = os.devnull
             dir2 = os.path.join(dir2root, dir2, common_file)
             label2 = common_file + rev2
 
         # Function to quote file/dir names in the argument string.
         # When not operating in 3-way mode, an empty string is
         # returned for parent2
         replace = {'parent': dir1a, 'parent1': dir1a, 'parent2': dir1b,
                    'plabel1': label1a, 'plabel2': label1b,
                    'clabel': label2, 'child': dir2,
                    'root': repo.root}
         def quote(match):
             pre = match.group(2)
             key = match.group(3)
             if not do3way and key == 'parent2':
                 return pre
             return pre + util.shellquote(replace[key])
 
         # Match parent2 first, so 'parent1?' will match both parent1 and parent
         regex = (r'''(['"]?)([^\s'"$]*)'''
                  r'\$(parent2|parent1?|child|plabel1|plabel2|clabel|root)\1')
         if not do3way and not re.search(regex, cmdline):
             cmdline += ' $parent1 $child'
         cmdline = re.sub(regex, quote, cmdline)
 
         ui.debug('running %r in %s\n' % (cmdline, tmproot))
         ui.system(cmdline, cwd=tmproot)
 
         for copy_fn, working_fn, mtime in fns_and_mtime:
             if os.lstat(copy_fn).st_mtime != mtime:
                 ui.debug('file changed while diffing. '
                          'Overwriting: %s (src: %s)\n' % (working_fn, copy_fn))
                 util.copyfile(copy_fn, working_fn)
 
         return 1
     finally:
         ui.note(_('cleaning up temp directory\n'))
         shutil.rmtree(tmproot)
 
 @command('extdiff',
     [('p', 'program', '',
      _('comparison program to run'), _('CMD')),
     ('o', 'option', [],
      _('pass option to comparison program'), _('OPT')),
     ('r', 'rev', [], _('revision'), _('REV')),
     ('c', 'change', '', _('change made by revision'), _('REV')),
     ] + commands.walkopts,
     _('hg extdiff [OPT]... [FILE]...'),
     inferrepo=True)
 def extdiff(ui, repo, *pats, **opts):
     '''use external program to diff repository (or selected files)
 
     Show differences between revisions for the specified files, using
     an external program. The default program used is diff, with
     default options "-Npru".
 
     To select a different program, use the -p/--program option. The
     program will be passed the names of two directories to compare. To
     pass additional options to the program, use -o/--option. These
     will be passed before the names of the directories to compare.
 
     When two revision arguments are given, then changes are shown
     between those revisions. If only one revision is specified then
     that revision is compared to the working directory, and, when no
     revisions are specified, the working directory files are compared
     to its parent.'''
     program = opts.get('program')
     option = opts.get('option')
     if not program:
         program = 'diff'
         option = option or ['-Npru']
     cmdline = ' '.join(map(util.shellquote, [program] + option))
     return dodiff(ui, repo, cmdline, pats, opts)
 
 def uisetup(ui):
     for cmd, path in ui.configitems('extdiff'):
         path = util.expandpath(path)
         if cmd.startswith('cmd.'):
             cmd = cmd[4:]
             if not path:
                 path = util.findexe(cmd)
                 if path is None:
                     path = filemerge.findexternaltool(ui, cmd) or cmd
             diffopts = ui.config('extdiff', 'opts.' + cmd, '')
             cmdline = util.shellquote(path)
             if diffopts:
                 cmdline += ' ' + diffopts
         elif cmd.startswith('opts.'):
             continue
         else:
             if path:
                 # case "cmd = path opts"
                 cmdline = path
                 diffopts = len(shlex.split(cmdline)) > 1
             else:
                 # case "cmd ="
                 path = util.findexe(cmd)
                 if path is None:
                     path = filemerge.findexternaltool(ui, cmd) or cmd
                 cmdline = util.shellquote(path)
                 diffopts = False
         # look for diff arguments in [diff-tools] then [merge-tools]
         if not diffopts:
             args = ui.config('diff-tools', cmd+'.diffargs') or \
                    ui.config('merge-tools', cmd+'.diffargs')
             if args:
                 cmdline += ' ' + args
         def save(cmdline):
             '''use closure to save diff command to use'''
             def mydiff(ui, repo, *pats, **opts):
                 options = ' '.join(map(util.shellquote, opts['option']))
                 if options:
                     options = ' ' + options
                 return dodiff(ui, repo, cmdline + options, pats, opts)
             doc = _('''\
 use %(path)s to diff repository (or selected files)
 
     Show differences between revisions for the specified files, using
     the %(path)s program.
 
     When two revision arguments are given, then changes are shown
     between those revisions. If only one revision is specified then
     that revision is compared to the working directory, and, when no
     revisions are specified, the working directory files are compared
     to its parent.\
 ''') % {'path': util.uirepr(path)}
 
             # We must translate the docstring right away since it is
             # used as a format string. The string will unfortunately
             # be translated again in commands.helpcmd and this will
             # fail when the docstring contains non-ASCII characters.
             # Decoding the string to a Unicode string here (using the
             # right encoding) prevents that.
             mydiff.__doc__ = doc.decode(encoding.encoding)
             return mydiff
         cmdtable[cmd] = (save(cmdline),
                          cmdtable['extdiff'][1][1:],
                          _('hg %s [OPTION]... [FILE]...') % cmd)

hgext/fetch.py

@@ -1,150 +1,154 b''
 # fetch.py - pull and merge remote changes
 #
 # Copyright 2006 Vadim Gelfer <[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.
 
 '''pull, update and merge in one command (DEPRECATED)'''
 
 from mercurial.i18n import _
 from mercurial.node import short
 from mercurial import commands, cmdutil, hg, util, error
 from mercurial.lock import release
 from mercurial import exchange
 
 cmdtable = {}
 command = cmdutil.command(cmdtable)
+# Note for extension authors: ONLY specify testedwith = 'internal' for
+# extensions which SHIP WITH MERCURIAL. Non-mainline extensions should
+# be specifying the version(s) of Mercurial they are tested with, or
+# leave the attribute unspecified.
 testedwith = 'internal'
 
 @command('fetch',
     [('r', 'rev', [],
      _('a specific revision you would like to pull'), _('REV')),
     ('e', 'edit', None, _('invoke editor on commit messages')),
     ('', 'force-editor', None, _('edit commit message (DEPRECATED)')),
     ('', 'switch-parent', None, _('switch parents when merging')),
     ] + commands.commitopts + commands.commitopts2 + commands.remoteopts,
     _('hg fetch [SOURCE]'))
 def fetch(ui, repo, source='default', **opts):
     '''pull changes from a remote repository, merge new changes if needed.
 
     This finds all changes from the repository at the specified path
     or URL and adds them to the local repository.
 
     If the pulled changes add a new branch head, the head is
     automatically merged, and the result of the merge is committed.
     Otherwise, the working directory is updated to include the new
     changes.
 
     When a merge is needed, the working directory is first updated to
     the newly pulled changes. Local changes are then merged into the
     pulled changes. To switch the merge order, use --switch-parent.
 
     See :hg:`help dates` for a list of formats valid for -d/--date.
 
     Returns 0 on success.
     '''
 
     date = opts.get('date')
     if date:
         opts['date'] = util.parsedate(date)
 
     parent, _p2 = repo.dirstate.parents()
     branch = repo.dirstate.branch()
     try:
         branchnode = repo.branchtip(branch)
     except error.RepoLookupError:
         branchnode = None
     if parent != branchnode:
         raise util.Abort(_('working directory not at branch tip'),
                          hint=_('use "hg update" to check out branch tip'))
 
     wlock = lock = None
     try:
         wlock = repo.wlock()
         lock = repo.lock()
 
         cmdutil.bailifchanged(repo)
 
         bheads = repo.branchheads(branch)
         bheads = [head for head in bheads if len(repo[head].children()) == 0]
         if len(bheads) > 1:
             raise util.Abort(_('multiple heads in this branch '
                                '(use "hg heads ." and "hg merge" to merge)'))
 
         other = hg.peer(repo, opts, ui.expandpath(source))
         ui.status(_('pulling from %s\n') %
                   util.hidepassword(ui.expandpath(source)))
         revs = None
         if opts['rev']:
             try:
                 revs = [other.lookup(rev) for rev in opts['rev']]
             except error.CapabilityError:
                 err = _("other repository doesn't support revision lookup, "
                         "so a rev cannot be specified.")
                 raise util.Abort(err)
 
         # Are there any changes at all?
         modheads = exchange.pull(repo, other, heads=revs).cgresult
         if modheads == 0:
             return 0
 
         # Is this a simple fast-forward along the current branch?
         newheads = repo.branchheads(branch)
         newchildren = repo.changelog.nodesbetween([parent], newheads)[2]
         if len(newheads) == 1 and len(newchildren):
             if newchildren[0] != parent:
                 return hg.update(repo, newchildren[0])
             else:
                 return 0
 
         # Are there more than one additional branch heads?
         newchildren = [n for n in newchildren if n != parent]
         newparent = parent
         if newchildren:
             newparent = newchildren[0]
             hg.clean(repo, newparent)
         newheads = [n for n in newheads if n != newparent]
         if len(newheads) > 1:
             ui.status(_('not merging with %d other new branch heads '
                         '(use "hg heads ." and "hg merge" to merge them)\n') %
                       (len(newheads) - 1))
             return 1
 
         if not newheads:
             return 0
 
         # Otherwise, let's merge.
         err = False
         if newheads:
             # By default, we consider the repository we're pulling
             # *from* as authoritative, so we merge our changes into
             # theirs.
             if opts['switch_parent']:
                 firstparent, secondparent = newparent, newheads[0]
             else:
                 firstparent, secondparent = newheads[0], newparent
                 ui.status(_('updating to %d:%s\n') %
                           (repo.changelog.rev(firstparent),
                            short(firstparent)))
             hg.clean(repo, firstparent)
             ui.status(_('merging with %d:%s\n') %
                       (repo.changelog.rev(secondparent), short(secondparent)))
             err = hg.merge(repo, secondparent, remind=False)
 
         if not err:
             # we don't translate commit messages
             message = (cmdutil.logmessage(ui, opts) or
                        ('Automated merge with %s' %
                         util.removeauth(other.url())))
             editopt = opts.get('edit') or opts.get('force_editor')
             editor = cmdutil.getcommiteditor(edit=editopt, editform='fetch')
             n = repo.commit(message, opts['user'], opts['date'], editor=editor)
             ui.status(_('new changeset %d:%s merges remote changes '
                         'with local\n') % (repo.changelog.rev(n),
                                            short(n)))
 
         return err
 
     finally:
         release(lock, wlock)

hgext/gpg.py

@@ -1,297 +1,301 b''
 # Copyright 2005, 2006 Benoit Boissinot <[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.
 
 '''commands to sign and verify changesets'''
 
 import os, tempfile, binascii
 from mercurial import util, commands, match, cmdutil
 from mercurial import node as hgnode
 from mercurial.i18n import _
 
 cmdtable = {}
 command = cmdutil.command(cmdtable)
+# Note for extension authors: ONLY specify testedwith = 'internal' for
+# extensions which SHIP WITH MERCURIAL. Non-mainline extensions should
+# be specifying the version(s) of Mercurial they are tested with, or
+# leave the attribute unspecified.
 testedwith = 'internal'
 
 class gpg(object):
     def __init__(self, path, key=None):
         self.path = path
         self.key = (key and " --local-user \"%s\"" % key) or ""
 
     def sign(self, data):
         gpgcmd = "%s --sign --detach-sign%s" % (self.path, self.key)
         return util.filter(data, gpgcmd)
 
     def verify(self, data, sig):
         """ returns of the good and bad signatures"""
         sigfile = datafile = None
         try:
             # create temporary files
             fd, sigfile = tempfile.mkstemp(prefix="hg-gpg-", suffix=".sig")
             fp = os.fdopen(fd, 'wb')
             fp.write(sig)
             fp.close()
             fd, datafile = tempfile.mkstemp(prefix="hg-gpg-", suffix=".txt")
             fp = os.fdopen(fd, 'wb')
             fp.write(data)
             fp.close()
             gpgcmd = ("%s --logger-fd 1 --status-fd 1 --verify "
                       "\"%s\" \"%s\"" % (self.path, sigfile, datafile))
             ret = util.filter("", gpgcmd)
         finally:
             for f in (sigfile, datafile):
                 try:
                     if f:
                         os.unlink(f)
                 except OSError:
                     pass
         keys = []
         key, fingerprint = None, None
         for l in ret.splitlines():
             # see DETAILS in the gnupg documentation
             # filter the logger output
             if not l.startswith("[GNUPG:]"):
                 continue
             l = l[9:]
             if l.startswith("VALIDSIG"):
                 # fingerprint of the primary key
                 fingerprint = l.split()[10]
             elif l.startswith("ERRSIG"):
                 key = l.split(" ", 3)[:2]
                 key.append("")
                 fingerprint = None
             elif (l.startswith("GOODSIG") or
                   l.startswith("EXPSIG") or
                   l.startswith("EXPKEYSIG") or
                   l.startswith("BADSIG")):
                 if key is not None:
                     keys.append(key + [fingerprint])
                 key = l.split(" ", 2)
                 fingerprint = None
         if key is not None:
             keys.append(key + [fingerprint])
         return keys
 
 def newgpg(ui, **opts):
     """create a new gpg instance"""
     gpgpath = ui.config("gpg", "cmd", "gpg")
     gpgkey = opts.get('key')
     if not gpgkey:
         gpgkey = ui.config("gpg", "key", None)
     return gpg(gpgpath, gpgkey)
 
 def sigwalk(repo):
     """
     walk over every sigs, yields a couple
     ((node, version, sig), (filename, linenumber))
     """
     def parsefile(fileiter, context):
         ln = 1
         for l in fileiter:
             if not l:
                 continue
             yield (l.split(" ", 2), (context, ln))
             ln += 1
 
     # read the heads
     fl = repo.file(".hgsigs")
     for r in reversed(fl.heads()):
         fn = ".hgsigs|%s" % hgnode.short(r)
         for item in parsefile(fl.read(r).splitlines(), fn):
             yield item
     try:
         # read local signatures
         fn = "localsigs"
         for item in parsefile(repo.vfs(fn), fn):
             yield item
     except IOError:
         pass
 
 def getkeys(ui, repo, mygpg, sigdata, context):
     """get the keys who signed a data"""
     fn, ln = context
     node, version, sig = sigdata
     prefix = "%s:%d" % (fn, ln)
     node = hgnode.bin(node)
 
     data = node2txt(repo, node, version)
     sig = binascii.a2b_base64(sig)
     keys = mygpg.verify(data, sig)
 
     validkeys = []
     # warn for expired key and/or sigs
     for key in keys:
         if key[0] == "ERRSIG":
             ui.write(_("%s Unknown key ID \"%s\"\n")
                      % (prefix, shortkey(ui, key[1][:15])))
             continue
         if key[0] == "BADSIG":
             ui.write(_("%s Bad signature from \"%s\"\n") % (prefix, key[2]))
             continue
         if key[0] == "EXPSIG":
             ui.write(_("%s Note: Signature has expired"
                        " (signed by: \"%s\")\n") % (prefix, key[2]))
         elif key[0] == "EXPKEYSIG":
             ui.write(_("%s Note: This key has expired"
                        " (signed by: \"%s\")\n") % (prefix, key[2]))
         validkeys.append((key[1], key[2], key[3]))
     return validkeys
 
 @command("sigs", [], _('hg sigs'))
 def sigs(ui, repo):
     """list signed changesets"""
     mygpg = newgpg(ui)
     revs = {}
 
     for data, context in sigwalk(repo):
         node, version, sig = data
         fn, ln = context
         try:
             n = repo.lookup(node)
         except KeyError:
             ui.warn(_("%s:%d node does not exist\n") % (fn, ln))
             continue
         r = repo.changelog.rev(n)
         keys = getkeys(ui, repo, mygpg, data, context)
         if not keys:
             continue
         revs.setdefault(r, [])
         revs[r].extend(keys)
     for rev in sorted(revs, reverse=True):
         for k in revs[rev]:
             r = "%5d:%s" % (rev, hgnode.hex(repo.changelog.node(rev)))
             ui.write("%-30s %s\n" % (keystr(ui, k), r))
 
 @command("sigcheck", [], _('hg sigcheck REV'))
 def check(ui, repo, rev):
     """verify all the signatures there may be for a particular revision"""
     mygpg = newgpg(ui)
     rev = repo.lookup(rev)
     hexrev = hgnode.hex(rev)
     keys = []
 
     for data, context in sigwalk(repo):
         node, version, sig = data
         if node == hexrev:
             k = getkeys(ui, repo, mygpg, data, context)
             if k:
                 keys.extend(k)
 
     if not keys:
         ui.write(_("no valid signature for %s\n") % hgnode.short(rev))
         return
 
     # print summary
     ui.write("%s is signed by:\n" % hgnode.short(rev))
     for key in keys:
         ui.write(" %s\n" % keystr(ui, key))
 
 def keystr(ui, key):
     """associate a string to a key (username, comment)"""
     keyid, user, fingerprint = key
     comment = ui.config("gpg", fingerprint, None)
     if comment:
         return "%s (%s)" % (user, comment)
     else:
         return user
 
 @command("sign",
          [('l', 'local', None, _('make the signature local')),
           ('f', 'force', None, _('sign even if the sigfile is modified')),
           ('', 'no-commit', None, _('do not commit the sigfile after signing')),
           ('k', 'key', '',
            _('the key id to sign with'), _('ID')),
           ('m', 'message', '',
            _('use text as commit message'), _('TEXT')),
           ('e', 'edit', False, _('invoke editor on commit messages')),
          ] + commands.commitopts2,
          _('hg sign [OPTION]... [REV]...'))
 def sign(ui, repo, *revs, **opts):
     """add a signature for the current or given revision
 
     If no revision is given, the parent of the working directory is used,
     or tip if no revision is checked out.
 
     See :hg:`help dates` for a list of formats valid for -d/--date.
     """
 
     mygpg = newgpg(ui, **opts)
     sigver = "0"
     sigmessage = ""
 
     date = opts.get('date')
     if date:
         opts['date'] = util.parsedate(date)
 
     if revs:
         nodes = [repo.lookup(n) for n in revs]
     else:
         nodes = [node for node in repo.dirstate.parents()
                  if node != hgnode.nullid]
         if len(nodes) > 1:
             raise util.Abort(_('uncommitted merge - please provide a '
                                'specific revision'))
         if not nodes:
             nodes = [repo.changelog.tip()]
 
     for n in nodes:
         hexnode = hgnode.hex(n)
         ui.write(_("signing %d:%s\n") % (repo.changelog.rev(n),
                                          hgnode.short(n)))
         # build data
         data = node2txt(repo, n, sigver)
         sig = mygpg.sign(data)
         if not sig:
             raise util.Abort(_("error while signing"))
         sig = binascii.b2a_base64(sig)
         sig = sig.replace("\n", "")
         sigmessage += "%s %s %s\n" % (hexnode, sigver, sig)
 
     # write it
     if opts['local']:
         repo.vfs.append("localsigs", sigmessage)
         return
 
     if not opts["force"]:
         msigs = match.exact(repo.root, '', ['.hgsigs'])
         if any(repo.status(match=msigs, unknown=True, ignored=True)):
             raise util.Abort(_("working copy of .hgsigs is changed "),
                              hint=_("please commit .hgsigs manually"))
 
     sigsfile = repo.wfile(".hgsigs", "ab")
     sigsfile.write(sigmessage)
     sigsfile.close()
 
     if '.hgsigs' not in repo.dirstate:
         repo[None].add([".hgsigs"])
 
     if opts["no_commit"]:
         return
 
     message = opts['message']
     if not message:
         # we don't translate commit messages
         message = "\n".join(["Added signature for changeset %s"
                              % hgnode.short(n)
                              for n in nodes])
     try:
         editor = cmdutil.getcommiteditor(editform='gpg.sign', **opts)
         repo.commit(message, opts['user'], opts['date'], match=msigs,
                     editor=editor)
     except ValueError, inst:
         raise util.Abort(str(inst))
 
 def shortkey(ui, key):
     if len(key) != 16:
         ui.debug("key ID \"%s\" format error\n" % key)
         return key
 
     return key[-8:]
 
 def node2txt(repo, node, ver):
     """map a manifest into some text"""
     if ver == "0":
         return "%s\n" % hgnode.hex(node)
     else:
         raise util.Abort(_("unknown signature version"))

hgext/graphlog.py

@@ -1,58 +1,62 b''
 # ASCII graph log extension for Mercurial
 #
 # Copyright 2007 Joel Rosdahl <[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 view revision graphs from a shell (DEPRECATED)
 
 The functionality of this extension has been include in core Mercurial
 since version 2.3.
 
 This extension adds a --graph option to the incoming, outgoing and log
 commands. When this options is given, an ASCII representation of the
 revision graph is also shown.
 '''
 
 from mercurial.i18n import _
 from mercurial import cmdutil, commands
 
 cmdtable = {}
 command = cmdutil.command(cmdtable)
+# Note for extension authors: ONLY specify testedwith = 'internal' for
+# extensions which SHIP WITH MERCURIAL. Non-mainline extensions should
+# be specifying the version(s) of Mercurial they are tested with, or
+# leave the attribute unspecified.
 testedwith = 'internal'
 
 @command('glog',
     [('f', 'follow', None,
      _('follow changeset history, or file history across copies and renames')),
     ('', 'follow-first', None,
      _('only follow the first parent of merge changesets (DEPRECATED)')),
     ('d', 'date', '', _('show revisions matching date spec'), _('DATE')),
     ('C', 'copies', None, _('show copied files')),
     ('k', 'keyword', [],
      _('do case-insensitive search for a given text'), _('TEXT')),
     ('r', 'rev', [], _('show the specified revision or revset'), _('REV')),
     ('', 'removed', None, _('include revisions where files were removed')),
     ('m', 'only-merges', None, _('show only merges (DEPRECATED)')),
     ('u', 'user', [], _('revisions committed by user'), _('USER')),
     ('', 'only-branch', [],
      _('show only changesets within the given named branch (DEPRECATED)'),
      _('BRANCH')),
     ('b', 'branch', [],
      _('show changesets within the given named branch'), _('BRANCH')),
     ('P', 'prune', [],
      _('do not display revision or any of its ancestors'), _('REV')),
     ] + commands.logopts + commands.walkopts,
     _('[OPTION]... [FILE]'),
     inferrepo=True)
 def graphlog(ui, repo, *pats, **opts):
     """show revision history alongside an ASCII revision graph
 
     Print a revision history alongside a revision graph drawn with
     ASCII characters.
 
     Nodes printed as an @ character are parents of the working
     directory.
     """
     opts['graph'] = True
     return commands.log(ui, repo, *pats, **opts)

hgext/hgcia.py

@@ -1,281 +1,285 b''
 # Copyright (C) 2007-8 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.
 
 """hooks for integrating with the CIA.vc notification service
 
 This is meant to be run as a changegroup or incoming hook. To
 configure it, set the following options in your hgrc::
 
   [cia]
   # your registered CIA user name
   user = foo
   # the name of the project in CIA
   project = foo
   # the module (subproject) (optional)
   #module = foo
   # Append a diffstat to the log message (optional)
   #diffstat = False
   # Template to use for log messages (optional)
   #template = {desc}\\n{baseurl}{webroot}/rev/{node}-- {diffstat}
   # Style to use (optional)
   #style = foo
   # The URL of the CIA notification service (optional)
   # You can use mailto: URLs to send by email, e.g.
   # mailto:[e-mail]
   # Make sure to set email.from if you do this.
   #url = http://cia.vc/
   # print message instead of sending it (optional)
   #test = False
   # number of slashes to strip for url paths
   #strip = 0
 
   [hooks]
   # one of these:
   changegroup.cia = python:hgcia.hook
   #incoming.cia = python:hgcia.hook
 
   [web]
   # If you want hyperlinks (optional)
   baseurl = http://server/path/to/repo
 """
 
 from mercurial.i18n import _
 from mercurial.node import bin, short
 from mercurial import cmdutil, patch, util, mail
 import email.Parser
 
 import socket, xmlrpclib
 from xml.sax import saxutils
+# Note for extension authors: ONLY specify testedwith = 'internal' for
+# extensions which SHIP WITH MERCURIAL. Non-mainline extensions should
+# be specifying the version(s) of Mercurial they are tested with, or
+# leave the attribute unspecified.
 testedwith = 'internal'
 
 socket_timeout = 30 # seconds
 if util.safehasattr(socket, 'setdefaulttimeout'):
     # set a timeout for the socket so you don't have to wait so looooong
     # when cia.vc is having problems. requires python >= 2.3:
     socket.setdefaulttimeout(socket_timeout)
 
 HGCIA_VERSION = '0.1'
 HGCIA_URL = 'http://hg.kublai.com/mercurial/hgcia'
 
 
 class ciamsg(object):
     """ A CIA message """
     def __init__(self, cia, ctx):
         self.cia = cia
         self.ctx = ctx
         self.url = self.cia.url
         if self.url:
             self.url += self.cia.root
 
     def fileelem(self, path, uri, action):
         if uri:
             uri = ' uri=%s' % saxutils.quoteattr(uri)
         return '<file%s action=%s>%s</file>' % (
             uri, saxutils.quoteattr(action), saxutils.escape(path))
 
     def fileelems(self):
         n = self.ctx.node()
         f = self.cia.repo.status(self.ctx.p1().node(), n)
         url = self.url or ''
         if url and url[-1] == '/':
             url = url[:-1]
         elems = []
         for path in f.modified:
             uri = '%s/diff/%s/%s' % (url, short(n), path)
             elems.append(self.fileelem(path, url and uri, 'modify'))
         for path in f.added:
             # TODO: copy/rename ?
             uri = '%s/file/%s/%s' % (url, short(n), path)
             elems.append(self.fileelem(path, url and uri, 'add'))
         for path in f.removed:
             elems.append(self.fileelem(path, '', 'remove'))
 
         return '\n'.join(elems)
 
     def sourceelem(self, project, module=None, branch=None):
         msg = ['<source>', '<project>%s</project>' % saxutils.escape(project)]
         if module:
             msg.append('<module>%s</module>' % saxutils.escape(module))
         if branch:
             msg.append('<branch>%s</branch>' % saxutils.escape(branch))
         msg.append('</source>')
 
         return '\n'.join(msg)
 
     def diffstat(self):
         class patchbuf(object):
             def __init__(self):
                 self.lines = []
                 # diffstat is stupid
                 self.name = 'cia'
             def write(self, data):
                 self.lines += data.splitlines(True)
             def close(self):
                 pass
 
         n = self.ctx.node()
         pbuf = patchbuf()
         cmdutil.export(self.cia.repo, [n], fp=pbuf)
         return patch.diffstat(pbuf.lines) or ''
 
     def logmsg(self):
         if self.cia.diffstat:
             diffstat = self.diffstat()
         else:
             diffstat = ''
         self.cia.ui.pushbuffer()
         self.cia.templater.show(self.ctx, changes=self.ctx.changeset(),
                                 baseurl=self.cia.ui.config('web', 'baseurl'),
                                 url=self.url, diffstat=diffstat,
                                 webroot=self.cia.root)
         return self.cia.ui.popbuffer()
 
     def xml(self):
         n = short(self.ctx.node())
         src = self.sourceelem(self.cia.project, module=self.cia.module,
                               branch=self.ctx.branch())
         # unix timestamp
         dt = self.ctx.date()
         timestamp = dt[0]
 
         author = saxutils.escape(self.ctx.user())
         rev = '%d:%s' % (self.ctx.rev(), n)
         log = saxutils.escape(self.logmsg())
 
         url = self.url
         if url and url[-1] == '/':
             url = url[:-1]
         url = url and '<url>%s/rev/%s</url>' % (saxutils.escape(url), n) or ''
 
         msg = """
 <message>
   <generator>
     <name>Mercurial (hgcia)</name>
     <version>%s</version>
     <url>%s</url>
     <user>%s</user>
   </generator>
   %s
   <body>
     <commit>
       <author>%s</author>
       <version>%s</version>
       <log>%s</log>
       %s
       <files>%s</files>
     </commit>
   </body>
   <timestamp>%d</timestamp>
 </message>
 """ % \
             (HGCIA_VERSION, saxutils.escape(HGCIA_URL),
             saxutils.escape(self.cia.user), src, author, rev, log, url,
             self.fileelems(), timestamp)
 
         return msg
 
 
 class hgcia(object):
     """ CIA notification class """
 
     deftemplate = '{desc}'
     dstemplate = '{desc}\n-- \n{diffstat}'
 
     def __init__(self, ui, repo):
         self.ui = ui
         self.repo = repo
 
         self.ciaurl = self.ui.config('cia', 'url', 'http://cia.vc')
         self.user = self.ui.config('cia', 'user')
         self.project = self.ui.config('cia', 'project')
         self.module = self.ui.config('cia', 'module')
         self.diffstat = self.ui.configbool('cia', 'diffstat')
         self.emailfrom = self.ui.config('email', 'from')
         self.dryrun = self.ui.configbool('cia', 'test')
         self.url = self.ui.config('web', 'baseurl')
         # Default to -1 for backward compatibility
         self.stripcount = int(self.ui.config('cia', 'strip', -1))
         self.root = self.strip(self.repo.root)
 
         style = self.ui.config('cia', 'style')
         template = self.ui.config('cia', 'template')
         if not template:
             if self.diffstat:
                 template = self.dstemplate
             else:
                 template = self.deftemplate
         t = cmdutil.changeset_templater(self.ui, self.repo, False, None,
                                         template, style, False)
         self.templater = t
 
     def strip(self, path):
         '''strip leading slashes from local path, turn into web-safe path.'''
 
         path = util.pconvert(path)
         count = self.stripcount
         if count < 0:
             return ''
         while count > 0:
             c = path.find('/')
             if c == -1:
                 break
             path = path[c + 1:]
             count -= 1
         return path
 
     def sendrpc(self, msg):
         srv = xmlrpclib.Server(self.ciaurl)
         res = srv.hub.deliver(msg)
         if res is not True and res != 'queued.':
             raise util.Abort(_('%s returned an error: %s') %
                              (self.ciaurl, res))
 
     def sendemail(self, address, data):
         p = email.Parser.Parser()
         msg = p.parsestr(data)
         msg['Date'] = util.datestr(format="%a, %d %b %Y %H:%M:%S %1%2")
         msg['To'] = address
         msg['From'] = self.emailfrom
         msg['Subject'] = 'DeliverXML'
         msg['Content-type'] = 'text/xml'
         msgtext = msg.as_string()
 
         self.ui.status(_('hgcia: sending update to %s\n') % address)
         mail.sendmail(self.ui, util.email(self.emailfrom),
                       [address], msgtext)
 
 
 def hook(ui, repo, hooktype, node=None, url=None, **kwargs):
     """ send CIA notification """
     def sendmsg(cia, ctx):
         msg = ciamsg(cia, ctx).xml()
         if cia.dryrun:
             ui.write(msg)
         elif cia.ciaurl.startswith('mailto:'):
             if not cia.emailfrom:
                 raise util.Abort(_('email.from must be defined when '
                                    'sending by email'))
             cia.sendemail(cia.ciaurl[7:], msg)
         else:
             cia.sendrpc(msg)
 
     n = bin(node)
     cia = hgcia(ui, repo)
     if not cia.user:
         ui.debug('cia: no user specified')
         return
     if not cia.project:
         ui.debug('cia: no project specified')
         return
     if hooktype == 'changegroup':
         start = repo.changelog.rev(n)
         end = len(repo.changelog)
         for rev in xrange(start, end):
             n = repo.changelog.node(rev)
             ctx = repo.changectx(n)
             sendmsg(cia, ctx)
     else:
         ctx = repo.changectx(n)
         sendmsg(cia, ctx)

hgext/hgk.py

@@ -1,331 +1,335 b''
 # Minimal support for git commands on an hg repository
 #
 # Copyright 2005, 2006 Chris Mason <[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.
 
 '''browse the repository in a graphical way
 
 The hgk extension allows browsing the history of a repository in a
 graphical way. It requires Tcl/Tk version 8.4 or later. (Tcl/Tk is not
 distributed with Mercurial.)
 
 hgk consists of two parts: a Tcl script that does the displaying and
 querying of information, and an extension to Mercurial named hgk.py,
 which provides hooks for hgk to get information. hgk can be found in
 the contrib directory, and the extension is shipped in the hgext
 repository, and needs to be enabled.
 
 The :hg:`view` command will launch the hgk Tcl script. For this command
 to work, hgk must be in your search path. Alternately, you can specify
 the path to hgk in your configuration file::
 
   [hgk]
   path=/location/of/hgk
 
 hgk can make use of the extdiff extension to visualize revisions.
 Assuming you had already configured extdiff vdiff command, just add::
 
   [hgk]
   vdiff=vdiff
 
 Revisions context menu will now display additional entries to fire
 vdiff on hovered and selected revisions.
 '''
 
 import os
 from mercurial import cmdutil, commands, patch, scmutil, obsolete
 from mercurial.node import nullid, nullrev, short
 from mercurial.i18n import _
 
 cmdtable = {}
 command = cmdutil.command(cmdtable)
+# Note for extension authors: ONLY specify testedwith = 'internal' for
+# extensions which SHIP WITH MERCURIAL. Non-mainline extensions should
+# be specifying the version(s) of Mercurial they are tested with, or
+# leave the attribute unspecified.
 testedwith = 'internal'
 
 @command('debug-diff-tree',
     [('p', 'patch', None, _('generate patch')),
     ('r', 'recursive', None, _('recursive')),
     ('P', 'pretty', None, _('pretty')),
     ('s', 'stdin', None, _('stdin')),
     ('C', 'copy', None, _('detect copies')),
     ('S', 'search', "", _('search'))],
     ('[OPTION]... NODE1 NODE2 [FILE]...'),
     inferrepo=True)
 def difftree(ui, repo, node1=None, node2=None, *files, **opts):
     """diff trees from two commits"""
     def __difftree(repo, node1, node2, files=[]):
         assert node2 is not None
         mmap = repo[node1].manifest()
         mmap2 = repo[node2].manifest()
         m = scmutil.match(repo[node1], files)
         modified, added, removed  = repo.status(node1, node2, m)[:3]
         empty = short(nullid)
 
         for f in modified:
             # TODO get file permissions
             ui.write(":100664 100664 %s %s M\t%s\t%s\n" %
                      (short(mmap[f]), short(mmap2[f]), f, f))
         for f in added:
             ui.write(":000000 100664 %s %s N\t%s\t%s\n" %
                      (empty, short(mmap2[f]), f, f))
         for f in removed:
             ui.write(":100664 000000 %s %s D\t%s\t%s\n" %
                      (short(mmap[f]), empty, f, f))
     ##
 
     while True:
         if opts['stdin']:
             try:
                 line = raw_input().split(' ')
                 node1 = line[0]
                 if len(line) > 1:
                     node2 = line[1]
                 else:
                     node2 = None
             except EOFError:
                 break
         node1 = repo.lookup(node1)
         if node2:
             node2 = repo.lookup(node2)
         else:
             node2 = node1
             node1 = repo.changelog.parents(node1)[0]
         if opts['patch']:
             if opts['pretty']:
                 catcommit(ui, repo, node2, "")
             m = scmutil.match(repo[node1], files)
             diffopts = patch.difffeatureopts(ui)
             diffopts.git = True
             chunks = patch.diff(repo, node1, node2, match=m,
                                 opts=diffopts)
             for chunk in chunks:
                 ui.write(chunk)
         else:
             __difftree(repo, node1, node2, files=files)
         if not opts['stdin']:
             break
 
 def catcommit(ui, repo, n, prefix, ctx=None):
     nlprefix = '\n' + prefix
     if ctx is None:
         ctx = repo[n]
     # use ctx.node() instead ??
     ui.write(("tree %s\n" % short(ctx.changeset()[0])))
     for p in ctx.parents():
         ui.write(("parent %s\n" % p))
 
     date = ctx.date()
     description = ctx.description().replace("\0", "")
     ui.write(("author %s %s %s\n" % (ctx.user(), int(date[0]), date[1])))
 
     if 'committer' in ctx.extra():
         ui.write(("committer %s\n" % ctx.extra()['committer']))
 
     ui.write(("revision %d\n" % ctx.rev()))
     ui.write(("branch %s\n" % ctx.branch()))
     if obsolete.isenabled(repo, obsolete.createmarkersopt):
         if ctx.obsolete():
             ui.write(("obsolete\n"))
     ui.write(("phase %s\n\n" % ctx.phasestr()))
 
     if prefix != "":
         ui.write("%s%s\n" % (prefix,
                              description.replace('\n', nlprefix).strip()))
     else:
         ui.write(description + "\n")
     if prefix:
         ui.write('\0')
 
 @command('debug-merge-base', [], _('REV REV'))
 def base(ui, repo, node1, node2):
     """output common ancestor information"""
     node1 = repo.lookup(node1)
     node2 = repo.lookup(node2)
     n = repo.changelog.ancestor(node1, node2)
     ui.write(short(n) + "\n")
 
 @command('debug-cat-file',
     [('s', 'stdin', None, _('stdin'))],
     _('[OPTION]... TYPE FILE'),
     inferrepo=True)
 def catfile(ui, repo, type=None, r=None, **opts):
     """cat a specific revision"""
     # in stdin mode, every line except the commit is prefixed with two
     # spaces.  This way the our caller can find the commit without magic
     # strings
     #
     prefix = ""
     if opts['stdin']:
         try:
             (type, r) = raw_input().split(' ')
             prefix = "    "
         except EOFError:
             return
 
     else:
         if not type or not r:
             ui.warn(_("cat-file: type or revision not supplied\n"))
             commands.help_(ui, 'cat-file')
 
     while r:
         if type != "commit":
             ui.warn(_("aborting hg cat-file only understands commits\n"))
             return 1
         n = repo.lookup(r)
         catcommit(ui, repo, n, prefix)
         if opts['stdin']:
             try:
                 (type, r) = raw_input().split(' ')
             except EOFError:
                 break
         else:
             break
 
 # git rev-tree is a confusing thing.  You can supply a number of
 # commit sha1s on the command line, and it walks the commit history
 # telling you which commits are reachable from the supplied ones via
 # a bitmask based on arg position.
 # you can specify a commit to stop at by starting the sha1 with ^
 def revtree(ui, args, repo, full="tree", maxnr=0, parents=False):
     def chlogwalk():
         count = len(repo)
         i = count
         l = [0] * 100
         chunk = 100
         while True:
             if chunk > i:
                 chunk = i
                 i = 0
             else:
                 i -= chunk
 
             for x in xrange(chunk):
                 if i + x >= count:
                     l[chunk - x:] = [0] * (chunk - x)
                     break
                 if full is not None:
                     if (i + x) in repo:
                         l[x] = repo[i + x]
                         l[x].changeset() # force reading
                 else:
                     if (i + x) in repo:
                         l[x] = 1
             for x in xrange(chunk - 1, -1, -1):
                 if l[x] != 0:
                     yield (i + x, full is not None and l[x] or None)
             if i == 0:
                 break
 
     # calculate and return the reachability bitmask for sha
     def is_reachable(ar, reachable, sha):
         if len(ar) == 0:
             return 1
         mask = 0
         for i in xrange(len(ar)):
             if sha in reachable[i]:
                 mask |= 1 << i
 
         return mask
 
     reachable = []
     stop_sha1 = []
     want_sha1 = []
     count = 0
 
     # figure out which commits they are asking for and which ones they
     # want us to stop on
     for i, arg in enumerate(args):
         if arg.startswith('^'):
             s = repo.lookup(arg[1:])
             stop_sha1.append(s)
             want_sha1.append(s)
         elif arg != 'HEAD':
             want_sha1.append(repo.lookup(arg))
 
     # calculate the graph for the supplied commits
     for i, n in enumerate(want_sha1):
         reachable.append(set())
         visit = [n]
         reachable[i].add(n)
         while visit:
             n = visit.pop(0)
             if n in stop_sha1:
                 continue
             for p in repo.changelog.parents(n):
                 if p not in reachable[i]:
                     reachable[i].add(p)
                     visit.append(p)
                 if p in stop_sha1:
                     continue
 
     # walk the repository looking for commits that are in our
     # reachability graph
     for i, ctx in chlogwalk():
         if i not in repo:
             continue
         n = repo.changelog.node(i)
         mask = is_reachable(want_sha1, reachable, n)
         if mask:
             parentstr = ""
             if parents:
                 pp = repo.changelog.parents(n)
                 if pp[0] != nullid:
                     parentstr += " " + short(pp[0])
                 if pp[1] != nullid:
                     parentstr += " " + short(pp[1])
             if not full:
                 ui.write("%s%s\n" % (short(n), parentstr))
             elif full == "commit":
                 ui.write("%s%s\n" % (short(n), parentstr))
                 catcommit(ui, repo, n, '    ', ctx)
             else:
                 (p1, p2) = repo.changelog.parents(n)
                 (h, h1, h2) = map(short, (n, p1, p2))
                 (i1, i2) = map(repo.changelog.rev, (p1, p2))
 
                 date = ctx.date()[0]
                 ui.write("%s %s:%s" % (date, h, mask))
                 mask = is_reachable(want_sha1, reachable, p1)
                 if i1 != nullrev and mask > 0:
                     ui.write("%s:%s " % (h1, mask)),
                 mask = is_reachable(want_sha1, reachable, p2)
                 if i2 != nullrev and mask > 0:
                     ui.write("%s:%s " % (h2, mask))
                 ui.write("\n")
             if maxnr and count >= maxnr:
                 break
             count += 1
 
 # git rev-list tries to order things by date, and has the ability to stop
 # at a given commit without walking the whole repo.  TODO add the stop
 # parameter
 @command('debug-rev-list',
     [('H', 'header', None, _('header')),
     ('t', 'topo-order', None, _('topo-order')),
     ('p', 'parents', None, _('parents')),
     ('n', 'max-count', 0, _('max-count'))],
     ('[OPTION]... REV...'))
 def revlist(ui, repo, *revs, **opts):
     """print revisions"""
     if opts['header']:
         full = "commit"
     else:
         full = None
     copy = [x for x in revs]
     revtree(ui, copy, repo, full, opts['max_count'], opts['parents'])
 
 @command('view',
     [('l', 'limit', '',
      _('limit number of changes displayed'), _('NUM'))],
     _('[-l LIMIT] [REVRANGE]'))
 def view(ui, repo, *etc, **opts):
     "start interactive history viewer"
     os.chdir(repo.root)
     optstr = ' '.join(['--%s %s' % (k, v) for k, v in opts.iteritems() if v])
     if repo.filtername is None:
         optstr += '--hidden'
 
     cmd = ui.config("hgk", "path", "hgk") + " %s %s" % (optstr, " ".join(etc))
     ui.debug("running %s\n" % cmd)
     ui.system(cmd)

hgext/highlight/__init__.py

@@ -1,64 +1,68 b''
 # highlight - syntax highlighting in hgweb, based on Pygments
 #
 #  Copyright 2008, 2009 Patrick Mezard <[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 original module was split in an interface and an implementation
 # file to defer pygments loading and speedup extension setup.
 
 """syntax highlighting for hgweb (requires Pygments)
 
 It depends on the Pygments syntax highlighting library:
 http://pygments.org/
 
 There is a single configuration option::
 
   [web]
   pygments_style = <style>
 
 The default is 'colorful'.
 """
 
 import highlight
 from mercurial.hgweb import webcommands, webutil, common
 from mercurial import extensions, encoding
+# Note for extension authors: ONLY specify testedwith = 'internal' for
+# extensions which SHIP WITH MERCURIAL. Non-mainline extensions should
+# be specifying the version(s) of Mercurial they are tested with, or
+# leave the attribute unspecified.
 testedwith = 'internal'
 
 def filerevision_highlight(orig, web, tmpl, fctx):
     mt = ''.join(tmpl('mimetype', encoding=encoding.encoding))
     # only pygmentize for mimetype containing 'html' so we both match
     # 'text/html' and possibly 'application/xhtml+xml' in the future
     # so that we don't have to touch the extension when the mimetype
     # for a template changes; also hgweb optimizes the case that a
     # raw file is sent using rawfile() and doesn't call us, so we
     # can't clash with the file's content-type here in case we
     # pygmentize a html file
     if 'html' in mt:
         style = web.config('web', 'pygments_style', 'colorful')
         highlight.pygmentize('fileline', fctx, style, tmpl)
     return orig(web, tmpl, fctx)
 
 def annotate_highlight(orig, web, req, tmpl):
     mt = ''.join(tmpl('mimetype', encoding=encoding.encoding))
     if 'html' in mt:
         fctx = webutil.filectx(web.repo, req)
         style = web.config('web', 'pygments_style', 'colorful')
         highlight.pygmentize('annotateline', fctx, style, tmpl)
     return orig(web, req, tmpl)
 
 def generate_css(web, req, tmpl):
     pg_style = web.config('web', 'pygments_style', 'colorful')
     fmter = highlight.HtmlFormatter(style=pg_style)
     req.respond(common.HTTP_OK, 'text/css')
     return ['/* pygments_style = %s */\n\n' % pg_style,
             fmter.get_style_defs('')]
 
 def extsetup():
     # monkeypatch in the new version
     extensions.wrapfunction(webcommands, '_filerevision',
                             filerevision_highlight)
     extensions.wrapfunction(webcommands, 'annotate', annotate_highlight)
     webcommands.highlightcss = generate_css
     webcommands.__all__.append('highlightcss')

hgext/histedit.py

@@ -1,1151 +1,1155 b''
 # histedit.py - interactive history editing for mercurial
 #
 # Copyright 2009 Augie Fackler <[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.
 """interactive history editing
 
 With this extension installed, Mercurial gains one new command: histedit. Usage
 is as follows, assuming the following history::
 
  @  3[tip]   7c2fd3b9020c   2009-04-27 18:04 -0500   durin42
  |    Add delta
  |
  o  2   030b686bedc4   2009-04-27 18:04 -0500   durin42
  |    Add gamma
  |
  o  1   c561b4e977df   2009-04-27 18:04 -0500   durin42
  |    Add beta
  |
  o  0   d8d2fcd0e319   2009-04-27 18:04 -0500   durin42
       Add alpha
 
 If you were to run ``hg histedit c561b4e977df``, you would see the following
 file open in your editor::
 
  pick c561b4e977df Add beta
  pick 030b686bedc4 Add gamma
  pick 7c2fd3b9020c Add delta
 
  # Edit history between c561b4e977df and 7c2fd3b9020c
  #
  # Commits are listed from least to most recent
  #
  # Commands:
  #  p, pick = use commit
  #  e, edit = use commit, but stop for amending
  #  f, fold = use commit, but combine it with the one above
  #  r, roll = like fold, but discard this commit's description
  #  d, drop = remove commit from history
  #  m, mess = edit message without changing commit content
  #
 
 In this file, lines beginning with ``#`` are ignored. You must specify a rule
 for each revision in your history. For example, if you had meant to add gamma
 before beta, and then wanted to add delta in the same revision as beta, you
 would reorganize the file to look like this::
 
  pick 030b686bedc4 Add gamma
  pick c561b4e977df Add beta
  fold 7c2fd3b9020c Add delta
 
  # Edit history between c561b4e977df and 7c2fd3b9020c
  #
  # Commits are listed from least to most recent
  #
  # Commands:
  #  p, pick = use commit
  #  e, edit = use commit, but stop for amending
  #  f, fold = use commit, but combine it with the one above
  #  r, roll = like fold, but discard this commit's description
  #  d, drop = remove commit from history
  #  m, mess = edit message without changing commit content
  #
 
 At which point you close the editor and ``histedit`` starts working. When you
 specify a ``fold`` operation, ``histedit`` will open an editor when it folds
 those revisions together, offering you a chance to clean up the commit message::
 
  Add beta
  ***
  Add delta
 
 Edit the commit message to your liking, then close the editor. For
 this example, let's assume that the commit message was changed to
 ``Add beta and delta.`` After histedit has run and had a chance to
 remove any old or temporary revisions it needed, the history looks
 like this::
 
  @  2[tip]   989b4d060121   2009-04-27 18:04 -0500   durin42
  |    Add beta and delta.
  |
  o  1   081603921c3f   2009-04-27 18:04 -0500   durin42
  |    Add gamma
  |
  o  0   d8d2fcd0e319   2009-04-27 18:04 -0500   durin42
       Add alpha
 
 Note that ``histedit`` does *not* remove any revisions (even its own temporary
 ones) until after it has completed all the editing operations, so it will
 probably perform several strip operations when it's done. For the above example,
 it had to run strip twice. Strip can be slow depending on a variety of factors,
 so you might need to be a little patient. You can choose to keep the original
 revisions by passing the ``--keep`` flag.
 
 The ``edit`` operation will drop you back to a command prompt,
 allowing you to edit files freely, or even use ``hg record`` to commit
 some changes as a separate commit. When you're done, any remaining
 uncommitted changes will be committed as well. When done, run ``hg
 histedit --continue`` to finish this step. You'll be prompted for a
 new commit message, but the default commit message will be the
 original message for the ``edit`` ed revision.
 
 The ``message`` operation will give you a chance to revise a commit
 message without changing the contents. It's a shortcut for doing
 ``edit`` immediately followed by `hg histedit --continue``.
 
 If ``histedit`` encounters a conflict when moving a revision (while
 handling ``pick`` or ``fold``), it'll stop in a similar manner to
 ``edit`` with the difference that it won't prompt you for a commit
 message when done. If you decide at this point that you don't like how
 much work it will be to rearrange history, or that you made a mistake,
 you can use ``hg histedit --abort`` to abandon the new changes you
 have made and return to the state before you attempted to edit your
 history.
 
 If we clone the histedit-ed example repository above and add four more
 changes, such that we have the following history::
 
    @  6[tip]   038383181893   2009-04-27 18:04 -0500   stefan
    |    Add theta
    |
    o  5   140988835471   2009-04-27 18:04 -0500   stefan
    |    Add eta
    |
    o  4   122930637314   2009-04-27 18:04 -0500   stefan
    |    Add zeta
    |
    o  3   836302820282   2009-04-27 18:04 -0500   stefan
    |    Add epsilon
    |
    o  2   989b4d060121   2009-04-27 18:04 -0500   durin42
    |    Add beta and delta.
    |
    o  1   081603921c3f   2009-04-27 18:04 -0500   durin42
    |    Add gamma
    |
    o  0   d8d2fcd0e319   2009-04-27 18:04 -0500   durin42
         Add alpha
 
 If you run ``hg histedit --outgoing`` on the clone then it is the same
 as running ``hg histedit 836302820282``. If you need plan to push to a
 repository that Mercurial does not detect to be related to the source
 repo, you can add a ``--force`` option.
 
 Histedit rule lines are truncated to 80 characters by default. You
 can customise this behaviour by setting a different length in your
 configuration file::
 
   [histedit]
   linelen = 120      # truncate rule lines at 120 characters
 """
 
 try:
     import cPickle as pickle
     pickle.dump # import now
 except ImportError:
     import pickle
 import errno
 import os
 import sys
 
 from mercurial import cmdutil
 from mercurial import discovery
 from mercurial import error
 from mercurial import changegroup
 from mercurial import copies
 from mercurial import context
 from mercurial import exchange
 from mercurial import extensions
 from mercurial import hg
 from mercurial import node
 from mercurial import repair
 from mercurial import scmutil
 from mercurial import util
 from mercurial import obsolete
 from mercurial import merge as mergemod
 from mercurial.lock import release
 from mercurial.i18n import _
 
 cmdtable = {}
 command = cmdutil.command(cmdtable)
 
+# Note for extension authors: ONLY specify testedwith = 'internal' for
+# extensions which SHIP WITH MERCURIAL. Non-mainline extensions should
+# be specifying the version(s) of Mercurial they are tested with, or
+# leave the attribute unspecified.
 testedwith = 'internal'
 
 # i18n: command names and abbreviations must remain untranslated
 editcomment = _("""# Edit history between %s and %s
 #
 # Commits are listed from least to most recent
 #
 # Commands:
 #  p, pick = use commit
 #  e, edit = use commit, but stop for amending
 #  f, fold = use commit, but combine it with the one above
 #  r, roll = like fold, but discard this commit's description
 #  d, drop = remove commit from history
 #  m, mess = edit message without changing commit content
 #
 """)
 
 class histeditstate(object):
     def __init__(self, repo, parentctxnode=None, rules=None, keep=None,
             topmost=None, replacements=None, lock=None, wlock=None):
         self.repo = repo
         self.rules = rules
         self.keep = keep
         self.topmost = topmost
         self.parentctxnode = parentctxnode
         self.lock = lock
         self.wlock = wlock
         self.backupfile = None
         if replacements is None:
             self.replacements = []
         else:
             self.replacements = replacements
 
     def read(self):
         """Load histedit state from disk and set fields appropriately."""
         try:
             fp = self.repo.vfs('histedit-state', 'r')
         except IOError, err:
             if err.errno != errno.ENOENT:
                 raise
             raise util.Abort(_('no histedit in progress'))
 
         try:
             data = pickle.load(fp)
             parentctxnode, rules, keep, topmost, replacements = data
             backupfile = None
         except pickle.UnpicklingError:
             data = self._load()
             parentctxnode, rules, keep, topmost, replacements, backupfile = data
 
         self.parentctxnode = parentctxnode
         self.rules = rules
         self.keep = keep
         self.topmost = topmost
         self.replacements = replacements
         self.backupfile = backupfile
 
     def write(self):
         fp = self.repo.vfs('histedit-state', 'w')
         fp.write('v1\n')
         fp.write('%s\n' % node.hex(self.parentctxnode))
         fp.write('%s\n' % node.hex(self.topmost))
         fp.write('%s\n' % self.keep)
         fp.write('%d\n' % len(self.rules))
         for rule in self.rules:
             fp.write('%s\n' % rule[0]) # action
             fp.write('%s\n' % rule[1]) # remainder
         fp.write('%d\n' % len(self.replacements))
         for replacement in self.replacements:
             fp.write('%s%s\n' % (node.hex(replacement[0]), ''.join(node.hex(r)
                 for r in replacement[1])))
         backupfile = self.backupfile
         if not backupfile:
             backupfile = ''
         fp.write('%s\n' % backupfile)
         fp.close()
 
     def _load(self):
         fp = self.repo.vfs('histedit-state', 'r')
         lines = [l[:-1] for l in fp.readlines()]
 
         index = 0
         lines[index] # version number
         index += 1
 
         parentctxnode = node.bin(lines[index])
         index += 1
 
         topmost = node.bin(lines[index])
         index += 1
 
         keep = lines[index] == 'True'
         index += 1
 
         # Rules
         rules = []
         rulelen = int(lines[index])
         index += 1
         for i in xrange(rulelen):
             ruleaction = lines[index]
             index += 1
             rule = lines[index]
             index += 1
             rules.append((ruleaction, rule))
 
         # Replacements
         replacements = []
         replacementlen = int(lines[index])
         index += 1
         for i in xrange(replacementlen):
             replacement = lines[index]
             original = node.bin(replacement[:40])
             succ = [node.bin(replacement[i:i + 40]) for i in
                     range(40, len(replacement), 40)]
             replacements.append((original, succ))
             index += 1
 
         backupfile = lines[index]
         index += 1
 
         fp.close()
 
         return parentctxnode, rules, keep, topmost, replacements, backupfile
 
     def clear(self):
         self.repo.vfs.unlink('histedit-state')
 
 class histeditaction(object):
     def __init__(self, state, node):
         self.state = state
         self.repo = state.repo
         self.node = node
 
     @classmethod
     def fromrule(cls, state, rule):
         """Parses the given rule, returning an instance of the histeditaction.
         """
         repo = state.repo
         rulehash = rule.strip().split(' ', 1)[0]
         try:
             node = repo[rulehash].node()
         except error.RepoError:
             raise util.Abort(_('unknown changeset %s listed') % rulehash[:12])
         return cls(state, node)
 
     def run(self):
         """Runs the action. The default behavior is simply apply the action's
         rulectx onto the current parentctx."""
         self.applychange()
         self.continuedirty()
         return self.continueclean()
 
     def applychange(self):
         """Applies the changes from this action's rulectx onto the current
         parentctx, but does not commit them."""
         repo = self.repo
         rulectx = repo[self.node]
         hg.update(repo, self.state.parentctxnode)
         stats = applychanges(repo.ui, repo, rulectx, {})
         if stats and stats[3] > 0:
             raise error.InterventionRequired(_('Fix up the change and run '
                                             'hg histedit --continue'))
 
     def continuedirty(self):
         """Continues the action when changes have been applied to the working
         copy. The default behavior is to commit the dirty changes."""
         repo = self.repo
         rulectx = repo[self.node]
 
         editor = self.commiteditor()
         commit = commitfuncfor(repo, rulectx)
 
         commit(text=rulectx.description(), user=rulectx.user(),
                date=rulectx.date(), extra=rulectx.extra(), editor=editor)
 
     def commiteditor(self):
         """The editor to be used to edit the commit message."""
         return False
 
     def continueclean(self):
         """Continues the action when the working copy is clean. The default
         behavior is to accept the current commit as the new version of the
         rulectx."""
         ctx = self.repo['.']
         if ctx.node() == self.state.parentctxnode:
             self.repo.ui.warn(_('%s: empty changeset\n') %
                               node.short(self.node))
             return ctx, [(self.node, tuple())]
         if ctx.node() == self.node:
             # Nothing changed
             return ctx, []
         return ctx, [(self.node, (ctx.node(),))]
 
 def commitfuncfor(repo, src):
     """Build a commit function for the replacement of <src>
 
     This function ensure we apply the same treatment to all changesets.
 
     - Add a 'histedit_source' entry in extra.
 
     Note that fold have its own separated logic because its handling is a bit
     different and not easily factored out of the fold method.
     """
     phasemin = src.phase()
     def commitfunc(**kwargs):
         phasebackup = repo.ui.backupconfig('phases', 'new-commit')
         try:
             repo.ui.setconfig('phases', 'new-commit', phasemin,
                               'histedit')
             extra = kwargs.get('extra', {}).copy()
             extra['histedit_source'] = src.hex()
             kwargs['extra'] = extra
             return repo.commit(**kwargs)
         finally:
             repo.ui.restoreconfig(phasebackup)
     return commitfunc
 
 def applychanges(ui, repo, ctx, opts):
     """Merge changeset from ctx (only) in the current working directory"""
     wcpar = repo.dirstate.parents()[0]
     if ctx.p1().node() == wcpar:
         # edition ar "in place" we do not need to make any merge,
         # just applies changes on parent for edition
         cmdutil.revert(ui, repo, ctx, (wcpar, node.nullid), all=True)
         stats = None
     else:
         try:
             # ui.forcemerge is an internal variable, do not document
             repo.ui.setconfig('ui', 'forcemerge', opts.get('tool', ''),
                               'histedit')
             stats = mergemod.graft(repo, ctx, ctx.p1(), ['local', 'histedit'])
         finally:
             repo.ui.setconfig('ui', 'forcemerge', '', 'histedit')
     return stats
 
 def collapse(repo, first, last, commitopts, skipprompt=False):
     """collapse the set of revisions from first to last as new one.
 
     Expected commit options are:
         - message
         - date
         - username
     Commit message is edited in all cases.
 
     This function works in memory."""
     ctxs = list(repo.set('%d::%d', first, last))
     if not ctxs:
         return None
     base = first.parents()[0]
 
     # commit a new version of the old changeset, including the update
     # collect all files which might be affected
     files = set()
     for ctx in ctxs:
         files.update(ctx.files())
 
     # Recompute copies (avoid recording a -> b -> a)
     copied = copies.pathcopies(base, last)
 
     # prune files which were reverted by the updates
     def samefile(f):
         if f in last.manifest():
             a = last.filectx(f)
             if f in base.manifest():
                 b = base.filectx(f)
                 return (a.data() == b.data()
                         and a.flags() == b.flags())
             else:
                 return False
         else:
             return f not in base.manifest()
     files = [f for f in files if not samefile(f)]
     # commit version of these files as defined by head
     headmf = last.manifest()
     def filectxfn(repo, ctx, path):
         if path in headmf:
             fctx = last[path]
             flags = fctx.flags()
             mctx = context.memfilectx(repo,
                                       fctx.path(), fctx.data(),
                                       islink='l' in flags,
                                       isexec='x' in flags,
                                       copied=copied.get(path))
             return mctx
         return None
 
     if commitopts.get('message'):
         message = commitopts['message']
     else:
         message = first.description()
     user = commitopts.get('user')
     date = commitopts.get('date')
     extra = commitopts.get('extra')
 
     parents = (first.p1().node(), first.p2().node())
     editor = None
     if not skipprompt:
         editor = cmdutil.getcommiteditor(edit=True, editform='histedit.fold')
     new = context.memctx(repo,
                          parents=parents,
                          text=message,
                          files=files,
                          filectxfn=filectxfn,
                          user=user,
                          date=date,
                          extra=extra,
                          editor=editor)
     return repo.commitctx(new)
 
 class pick(histeditaction):
     def run(self):
         rulectx = self.repo[self.node]
         if rulectx.parents()[0].node() == self.state.parentctxnode:
             self.repo.ui.debug('node %s unchanged\n' % node.short(self.node))
             return rulectx, []
 
         return super(pick, self).run()
 
 class edit(histeditaction):
     def run(self):
         repo = self.repo
         rulectx = repo[self.node]
         hg.update(repo, self.state.parentctxnode)
         applychanges(repo.ui, repo, rulectx, {})
         raise error.InterventionRequired(
             _('Make changes as needed, you may commit or record as needed '
               'now.\nWhen you are finished, run hg histedit --continue to '
               'resume.'))
 
     def commiteditor(self):
         return cmdutil.getcommiteditor(edit=True, editform='histedit.edit')
 
 class fold(histeditaction):
     def continuedirty(self):
         repo = self.repo
         rulectx = repo[self.node]
 
         commit = commitfuncfor(repo, rulectx)
         commit(text='fold-temp-revision %s' % node.short(self.node),
                user=rulectx.user(), date=rulectx.date(),
                extra=rulectx.extra())
 
     def continueclean(self):
         repo = self.repo
         ctx = repo['.']
         rulectx = repo[self.node]
         parentctxnode = self.state.parentctxnode
         if ctx.node() == parentctxnode:
             repo.ui.warn(_('%s: empty changeset\n') %
                               node.short(self.node))
             return ctx, [(self.node, (parentctxnode,))]
 
         parentctx = repo[parentctxnode]
         newcommits = set(c.node() for c in repo.set('(%d::. - %d)', parentctx,
                                                  parentctx))
         if not newcommits:
             repo.ui.warn(_('%s: cannot fold - working copy is not a '
                            'descendant of previous commit %s\n') %
                            (node.short(self.node), node.short(parentctxnode)))
             return ctx, [(self.node, (ctx.node(),))]
 
         middlecommits = newcommits.copy()
         middlecommits.discard(ctx.node())
 
         return self.finishfold(repo.ui, repo, parentctx, rulectx, ctx.node(),
                                middlecommits)
 
     def skipprompt(self):
         return False
 
     def finishfold(self, ui, repo, ctx, oldctx, newnode, internalchanges):
         parent = ctx.parents()[0].node()
         hg.update(repo, parent)
         ### prepare new commit data
         commitopts = {}
         commitopts['user'] = ctx.user()
         # commit message
         if self.skipprompt():
             newmessage = ctx.description()
         else:
             newmessage = '\n***\n'.join(
                 [ctx.description()] +
                 [repo[r].description() for r in internalchanges] +
                 [oldctx.description()]) + '\n'
         commitopts['message'] = newmessage
         # date
         commitopts['date'] = max(ctx.date(), oldctx.date())
         extra = ctx.extra().copy()
         # histedit_source
         # note: ctx is likely a temporary commit but that the best we can do
         #       here. This is sufficient to solve issue3681 anyway.
         extra['histedit_source'] = '%s,%s' % (ctx.hex(), oldctx.hex())
         commitopts['extra'] = extra
         phasebackup = repo.ui.backupconfig('phases', 'new-commit')
         try:
             phasemin = max(ctx.phase(), oldctx.phase())
             repo.ui.setconfig('phases', 'new-commit', phasemin, 'histedit')
             n = collapse(repo, ctx, repo[newnode], commitopts,
                          skipprompt=self.skipprompt())
         finally:
             repo.ui.restoreconfig(phasebackup)
         if n is None:
             return ctx, []
         hg.update(repo, n)
         replacements = [(oldctx.node(), (newnode,)),
                         (ctx.node(), (n,)),
                         (newnode, (n,)),
                        ]
         for ich in internalchanges:
             replacements.append((ich, (n,)))
         return repo[n], replacements
 
 class rollup(fold):
     def skipprompt(self):
         return True
 
 class drop(histeditaction):
     def run(self):
         parentctx = self.repo[self.state.parentctxnode]
         return parentctx, [(self.node, tuple())]
 
 class message(histeditaction):
     def commiteditor(self):
         return cmdutil.getcommiteditor(edit=True, editform='histedit.mess')
 
 def findoutgoing(ui, repo, remote=None, force=False, opts={}):
     """utility function to find the first outgoing changeset
 
     Used by initialisation code"""
     dest = ui.expandpath(remote or 'default-push', remote or 'default')
     dest, revs = hg.parseurl(dest, None)[:2]
     ui.status(_('comparing with %s\n') % util.hidepassword(dest))
 
     revs, checkout = hg.addbranchrevs(repo, repo, revs, None)
     other = hg.peer(repo, opts, dest)
 
     if revs:
         revs = [repo.lookup(rev) for rev in revs]
 
     outgoing = discovery.findcommonoutgoing(repo, other, revs, force=force)
     if not outgoing.missing:
         raise util.Abort(_('no outgoing ancestors'))
     roots = list(repo.revs("roots(%ln)", outgoing.missing))
     if 1 < len(roots):
         msg = _('there are ambiguous outgoing revisions')
         hint = _('see "hg help histedit" for more detail')
         raise util.Abort(msg, hint=hint)
     return repo.lookup(roots[0])
 
 actiontable = {'p': pick,
                'pick': pick,
                'e': edit,
                'edit': edit,
                'f': fold,
                'fold': fold,
                'r': rollup,
                'roll': rollup,
                'd': drop,
                'drop': drop,
                'm': message,
                'mess': message,
                }
 
 @command('histedit',
     [('', 'commands', '',
       _('read history edits from the specified file'), _('FILE')),
      ('c', 'continue', False, _('continue an edit already in progress')),
      ('', 'edit-plan', False, _('edit remaining actions list')),
      ('k', 'keep', False,
       _("don't strip old nodes after edit is complete")),
      ('', 'abort', False, _('abort an edit in progress')),
      ('o', 'outgoing', False, _('changesets not found in destination')),
      ('f', 'force', False,
       _('force outgoing even for unrelated repositories')),
      ('r', 'rev', [], _('first revision to be edited'), _('REV'))],
      _("ANCESTOR | --outgoing [URL]"))
 def histedit(ui, repo, *freeargs, **opts):
     """interactively edit changeset history
 
     This command edits changesets between ANCESTOR and the parent of
     the working directory.
 
     With --outgoing, this edits changesets not found in the
     destination repository. If URL of the destination is omitted, the
     'default-push' (or 'default') path will be used.
 
     For safety, this command is aborted, also if there are ambiguous
     outgoing revisions which may confuse users: for example, there are
     multiple branches containing outgoing revisions.
 
     Use "min(outgoing() and ::.)" or similar revset specification
     instead of --outgoing to specify edit target revision exactly in
     such ambiguous situation. See :hg:`help revsets` for detail about
     selecting revisions.
 
     Returns 0 on success, 1 if user intervention is required (not only
     for intentional "edit" command, but also for resolving unexpected
     conflicts).
     """
     state = histeditstate(repo)
     try:
         state.wlock = repo.wlock()
         state.lock = repo.lock()
         _histedit(ui, repo, state, *freeargs, **opts)
     finally:
         release(state.lock, state.wlock)
 
 def _histedit(ui, repo, state, *freeargs, **opts):
     # TODO only abort if we try and histedit mq patches, not just
     # blanket if mq patches are applied somewhere
     mq = getattr(repo, 'mq', None)
     if mq and mq.applied:
         raise util.Abort(_('source has mq patches applied'))
 
     # basic argument incompatibility processing
     outg = opts.get('outgoing')
     cont = opts.get('continue')
     editplan = opts.get('edit_plan')
     abort = opts.get('abort')
     force = opts.get('force')
     rules = opts.get('commands', '')
     revs = opts.get('rev', [])
     goal = 'new' # This invocation goal, in new, continue, abort
     if force and not outg:
         raise util.Abort(_('--force only allowed with --outgoing'))
     if cont:
         if any((outg, abort, revs, freeargs, rules, editplan)):
             raise util.Abort(_('no arguments allowed with --continue'))
         goal = 'continue'
     elif abort:
         if any((outg, revs, freeargs, rules, editplan)):
             raise util.Abort(_('no arguments allowed with --abort'))
         goal = 'abort'
     elif editplan:
         if any((outg, revs, freeargs)):
             raise util.Abort(_('only --commands argument allowed with '
                                '--edit-plan'))
         goal = 'edit-plan'
     else:
         if os.path.exists(os.path.join(repo.path, 'histedit-state')):
             raise util.Abort(_('history edit already in progress, try '
                                '--continue or --abort'))
         if outg:
             if revs:
                 raise util.Abort(_('no revisions allowed with --outgoing'))
             if len(freeargs) > 1:
                 raise util.Abort(
                     _('only one repo argument allowed with --outgoing'))
         else:
             revs.extend(freeargs)
             if len(revs) == 0:
                 histeditdefault = ui.config('histedit', 'defaultrev')
                 if histeditdefault:
                     revs.append(histeditdefault)
             if len(revs) != 1:
                 raise util.Abort(
                     _('histedit requires exactly one ancestor revision'))
 
 
     replacements = []
     keep = opts.get('keep', False)
 
     # rebuild state
     if goal == 'continue':
         state.read()
         state = bootstrapcontinue(ui, state, opts)
     elif goal == 'edit-plan':
         state.read()
         if not rules:
             comment = editcomment % (node.short(state.parentctxnode),
                                      node.short(state.topmost))
             rules = ruleeditor(repo, ui, state.rules, comment)
         else:
             if rules == '-':
                 f = sys.stdin
             else:
                 f = open(rules)
             rules = f.read()
             f.close()
         rules = [l for l in (r.strip() for r in rules.splitlines())
                  if l and not l.startswith('#')]
         rules = verifyrules(rules, repo, [repo[c] for [_a, c] in state.rules])
         state.rules = rules
         state.write()
         return
     elif goal == 'abort':
         state.read()
         mapping, tmpnodes, leafs, _ntm = processreplacement(state)
         ui.debug('restore wc to old parent %s\n' % node.short(state.topmost))
 
         # Recover our old commits if necessary
         if not state.topmost in repo and state.backupfile:
             backupfile = repo.join(state.backupfile)
             f = hg.openpath(ui, backupfile)
             gen = exchange.readbundle(ui, f, backupfile)
             changegroup.addchangegroup(repo, gen, 'histedit',
                                        'bundle:' + backupfile)
             os.remove(backupfile)
 
         # check whether we should update away
         parentnodes = [c.node() for c in repo[None].parents()]
         for n in leafs | set([state.parentctxnode]):
             if n in parentnodes:
                 hg.clean(repo, state.topmost)
                 break
         else:
             pass
         cleanupnode(ui, repo, 'created', tmpnodes)
         cleanupnode(ui, repo, 'temp', leafs)
         state.clear()
         return
     else:
         cmdutil.checkunfinished(repo)
         cmdutil.bailifchanged(repo)
 
         topmost, empty = repo.dirstate.parents()
         if outg:
             if freeargs:
                 remote = freeargs[0]
             else:
                 remote = None
             root = findoutgoing(ui, repo, remote, force, opts)
         else:
             rr = list(repo.set('roots(%ld)', scmutil.revrange(repo, revs)))
             if len(rr) != 1:
                 raise util.Abort(_('The specified revisions must have '
                     'exactly one common root'))
             root = rr[0].node()
 
         revs = between(repo, root, topmost, keep)
         if not revs:
             raise util.Abort(_('%s is not an ancestor of working directory') %
                              node.short(root))
 
         ctxs = [repo[r] for r in revs]
         if not rules:
             comment = editcomment % (node.short(root), node.short(topmost))
             rules = ruleeditor(repo, ui, [['pick', c] for c in ctxs], comment)
         else:
             if rules == '-':
                 f = sys.stdin
             else:
                 f = open(rules)
             rules = f.read()
             f.close()
         rules = [l for l in (r.strip() for r in rules.splitlines())
                  if l and not l.startswith('#')]
         rules = verifyrules(rules, repo, ctxs)
 
         parentctxnode = repo[root].parents()[0].node()
 
         state.parentctxnode = parentctxnode
         state.rules = rules
         state.keep = keep
         state.topmost = topmost
         state.replacements = replacements
 
         # Create a backup so we can always abort completely.
         backupfile = None
         if not obsolete.isenabled(repo, obsolete.createmarkersopt):
             backupfile = repair._bundle(repo, [parentctxnode], [topmost], root,
                                         'histedit')
         state.backupfile = backupfile
 
     while state.rules:
         state.write()
         action, ha = state.rules.pop(0)
         ui.debug('histedit: processing %s %s\n' % (action, ha[:12]))
         actobj = actiontable[action].fromrule(state, ha)
         parentctx, replacement_ = actobj.run()
         state.parentctxnode = parentctx.node()
         state.replacements.extend(replacement_)
     state.write()
 
     hg.update(repo, state.parentctxnode)
 
     mapping, tmpnodes, created, ntm = processreplacement(state)
     if mapping:
         for prec, succs in mapping.iteritems():
             if not succs:
                 ui.debug('histedit: %s is dropped\n' % node.short(prec))
             else:
                 ui.debug('histedit: %s is replaced by %s\n' % (
                     node.short(prec), node.short(succs[0])))
                 if len(succs) > 1:
                     m = 'histedit:                            %s'
                     for n in succs[1:]:
                         ui.debug(m % node.short(n))
 
     if not keep:
         if mapping:
             movebookmarks(ui, repo, mapping, state.topmost, ntm)
             # TODO update mq state
         if obsolete.isenabled(repo, obsolete.createmarkersopt):
             markers = []
             # sort by revision number because it sound "right"
             for prec in sorted(mapping, key=repo.changelog.rev):
                 succs = mapping[prec]
                 markers.append((repo[prec],
                                 tuple(repo[s] for s in succs)))
             if markers:
                 obsolete.createmarkers(repo, markers)
         else:
             cleanupnode(ui, repo, 'replaced', mapping)
 
     cleanupnode(ui, repo, 'temp', tmpnodes)
     state.clear()
     if os.path.exists(repo.sjoin('undo')):
         os.unlink(repo.sjoin('undo'))
 
 def bootstrapcontinue(ui, state, opts):
     repo = state.repo
     if state.rules:
         action, currentnode = state.rules.pop(0)
 
         actobj = actiontable[action].fromrule(state, currentnode)
 
         s = repo.status()
         if s.modified or s.added or s.removed or s.deleted:
             actobj.continuedirty()
             s = repo.status()
             if s.modified or s.added or s.removed or s.deleted:
                 raise util.Abort(_("working copy still dirty"))
 
         parentctx, replacements = actobj.continueclean()
 
         state.parentctxnode = parentctx.node()
         state.replacements.extend(replacements)
 
     return state
 
 def between(repo, old, new, keep):
     """select and validate the set of revision to edit
 
     When keep is false, the specified set can't have children."""
     ctxs = list(repo.set('%n::%n', old, new))
     if ctxs and not keep:
         if (not obsolete.isenabled(repo, obsolete.allowunstableopt) and
             repo.revs('(%ld::) - (%ld)', ctxs, ctxs)):
             raise util.Abort(_('cannot edit history that would orphan nodes'))
         if repo.revs('(%ld) and merge()', ctxs):
             raise util.Abort(_('cannot edit history that contains merges'))
         root = ctxs[0] # list is already sorted by repo.set
         if not root.mutable():
             raise util.Abort(_('cannot edit immutable changeset: %s') % root)
     return [c.node() for c in ctxs]
 
 def makedesc(repo, action, rev):
     """build a initial action line for a ctx
 
     line are in the form:
 
       <action> <hash> <rev> <summary>
     """
     ctx = repo[rev]
     summary = ''
     if ctx.description():
         summary = ctx.description().splitlines()[0]
     line = '%s %s %d %s' % (action, ctx, ctx.rev(), summary)
     # trim to 80 columns so it's not stupidly wide in my editor
     maxlen = repo.ui.configint('histedit', 'linelen', default=80)
     maxlen = max(maxlen, 22) # avoid truncating hash
     return util.ellipsis(line, maxlen)
 
 def ruleeditor(repo, ui, rules, editcomment=""):
     """open an editor to edit rules
 
     rules are in the format [ [act, ctx], ...] like in state.rules
     """
     rules = '\n'.join([makedesc(repo, act, rev) for [act, rev] in rules])
     rules += '\n\n'
     rules += editcomment
     rules = ui.edit(rules, ui.username())
 
     # Save edit rules in .hg/histedit-last-edit.txt in case
     # the user needs to ask for help after something
     # surprising happens.
     f = open(repo.join('histedit-last-edit.txt'), 'w')
     f.write(rules)
     f.close()
 
     return rules
 
 def verifyrules(rules, repo, ctxs):
     """Verify that there exists exactly one edit rule per given changeset.
 
     Will abort if there are to many or too few rules, a malformed rule,
     or a rule on a changeset outside of the user-given range.
     """
     parsed = []
     expected = set(c.hex() for c in ctxs)
     seen = set()
     for r in rules:
         if ' ' not in r:
             raise util.Abort(_('malformed line "%s"') % r)
         action, rest = r.split(' ', 1)
         ha = rest.strip().split(' ', 1)[0]
         try:
             ha = repo[ha].hex()
         except error.RepoError:
             raise util.Abort(_('unknown changeset %s listed') % ha[:12])
         if ha not in expected:
             raise util.Abort(
                 _('may not use changesets other than the ones listed'))
         if ha in seen:
             raise util.Abort(_('duplicated command for changeset %s') %
                     ha[:12])
         seen.add(ha)
         if action not in actiontable:
             raise util.Abort(_('unknown action "%s"') % action)
         parsed.append([action, ha])
     missing = sorted(expected - seen)  # sort to stabilize output
     if missing:
         raise util.Abort(_('missing rules for changeset %s') %
                 missing[0][:12],
                 hint=_('do you want to use the drop action?'))
     return parsed
 
 def processreplacement(state):
     """process the list of replacements to return
 
     1) the final mapping between original and created nodes
     2) the list of temporary node created by histedit
     3) the list of new commit created by histedit"""
     replacements = state.replacements
     allsuccs = set()
     replaced = set()
     fullmapping = {}
     # initialise basic set
     # fullmapping record all operation recorded in replacement
     for rep in replacements:
         allsuccs.update(rep[1])
         replaced.add(rep[0])
         fullmapping.setdefault(rep[0], set()).update(rep[1])
     new = allsuccs - replaced
     tmpnodes = allsuccs & replaced
     # Reduce content fullmapping  into direct relation between original nodes
     # and final node created during history edition
     # Dropped changeset are replaced by an empty list
     toproceed = set(fullmapping)
     final = {}
     while toproceed:
         for x in list(toproceed):
             succs = fullmapping[x]
             for s in list(succs):
                 if s in toproceed:
                     # non final node with unknown closure
                     # We can't process this now
                     break
                 elif s in final:
                     # non final node, replace with closure
                     succs.remove(s)
                     succs.update(final[s])
             else:
                 final[x] = succs
                 toproceed.remove(x)
     # remove tmpnodes from final mapping
     for n in tmpnodes:
         del final[n]
     # we expect all changes involved in final to exist in the repo
     # turn `final` into list (topologically sorted)
     nm = state.repo.changelog.nodemap
     for prec, succs in final.items():
         final[prec] = sorted(succs, key=nm.get)
 
     # computed topmost element (necessary for bookmark)
     if new:
         newtopmost = sorted(new, key=state.repo.changelog.rev)[-1]
     elif not final:
         # Nothing rewritten at all. we won't need `newtopmost`
         # It is the same as `oldtopmost` and `processreplacement` know it
         newtopmost = None
     else:
         # every body died. The newtopmost is the parent of the root.
         r = state.repo.changelog.rev
         newtopmost = state.repo[sorted(final, key=r)[0]].p1().node()
 
     return final, tmpnodes, new, newtopmost
 
 def movebookmarks(ui, repo, mapping, oldtopmost, newtopmost):
     """Move bookmark from old to newly created node"""
     if not mapping:
         # if nothing got rewritten there is not purpose for this function
         return
     moves = []
     for bk, old in sorted(repo._bookmarks.iteritems()):
         if old == oldtopmost:
             # special case ensure bookmark stay on tip.
             #
             # This is arguably a feature and we may only want that for the
             # active bookmark. But the behavior is kept compatible with the old
             # version for now.
             moves.append((bk, newtopmost))
             continue
         base = old
         new = mapping.get(base, None)
         if new is None:
             continue
         while not new:
             # base is killed, trying with parent
             base = repo[base].p1().node()
             new = mapping.get(base, (base,))
             # nothing to move
         moves.append((bk, new[-1]))
     if moves:
         marks = repo._bookmarks
         for mark, new in moves:
             old = marks[mark]
             ui.note(_('histedit: moving bookmarks %s from %s to %s\n')
                     % (mark, node.short(old), node.short(new)))
             marks[mark] = new
         marks.write()
 
 def cleanupnode(ui, repo, name, nodes):
     """strip a group of nodes from the repository
 
     The set of node to strip may contains unknown nodes."""
     ui.debug('should strip %s nodes %s\n' %
              (name, ', '.join([node.short(n) for n in nodes])))
     lock = None
     try:
         lock = repo.lock()
         # Find all node that need to be stripped
         # (we hg %lr instead of %ln to silently ignore unknown item
         nm = repo.changelog.nodemap
         nodes = sorted(n for n in nodes if n in nm)
         roots = [c.node() for c in repo.set("roots(%ln)", nodes)]
         for c in roots:
             # We should process node in reverse order to strip tip most first.
             # but this trigger a bug in changegroup hook.
             # This would reduce bundle overhead
             repair.strip(ui, repo, c)
     finally:
         release(lock)
 
 def stripwrapper(orig, ui, repo, nodelist, *args, **kwargs):
     if isinstance(nodelist, str):
         nodelist = [nodelist]
     if os.path.exists(os.path.join(repo.path, 'histedit-state')):
         state = histeditstate(repo)
         state.read()
         histedit_nodes = set([repo[rulehash].node() for (action, rulehash)
                              in state.rules if rulehash in repo])
         strip_nodes = set([repo[n].node() for n in nodelist])
         common_nodes = histedit_nodes & strip_nodes
         if common_nodes:
             raise util.Abort(_("histedit in progress, can't strip %s")
                              % ', '.join(node.short(x) for x in common_nodes))
     return orig(ui, repo, nodelist, *args, **kwargs)
 
 extensions.wrapfunction(repair, 'strip', stripwrapper)
 
 def summaryhook(ui, repo):
     if not os.path.exists(repo.join('histedit-state')):
         return
     state = histeditstate(repo)
     state.read()
     if state.rules:
         # i18n: column positioning for "hg summary"
         ui.write(_('hist:   %s (histedit --continue)\n') %
                  (ui.label(_('%d remaining'), 'histedit.remaining') %
                   len(state.rules)))
 
 def extsetup(ui):
     cmdutil.summaryhooks.add('histedit', summaryhook)
     cmdutil.unfinishedstates.append(
         ['histedit-state', False, True, _('histedit in progress'),
          _("use 'hg histedit --continue' or 'hg histedit --abort'")])

hgext/keyword.py

@@ -1,742 +1,746 b''
 # keyword.py - $Keyword$ expansion for Mercurial
 #
 # Copyright 2007-2015 Christian Ebert <[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.
 #
 # $Id$
 #
 # Keyword expansion hack against the grain of a Distributed SCM
 #
 # There are many good reasons why this is not needed in a distributed
 # SCM, still it may be useful in very small projects based on single
 # files (like LaTeX packages), that are mostly addressed to an
 # audience not running a version control system.
 #
 # For in-depth discussion refer to
 # <http://mercurial.selenic.com/wiki/KeywordPlan>.
 #
 # Keyword expansion is based on Mercurial's changeset template mappings.
 #
 # Binary files are not touched.
 #
 # Files to act upon/ignore are specified in the [keyword] section.
 # Customized keyword template mappings in the [keywordmaps] section.
 #
 # Run "hg help keyword" and "hg kwdemo" to get info on configuration.
 
 '''expand keywords in tracked files
 
 This extension expands RCS/CVS-like or self-customized $Keywords$ in
 tracked text files selected by your configuration.
 
 Keywords are only expanded in local repositories and not stored in the
 change history. The mechanism can be regarded as a convenience for the
 current user or for archive distribution.
 
 Keywords expand to the changeset data pertaining to the latest change
 relative to the working directory parent of each file.
 
 Configuration is done in the [keyword], [keywordset] and [keywordmaps]
 sections of hgrc files.
 
 Example::
 
     [keyword]
     # expand keywords in every python file except those matching "x*"
     **.py =
     x*    = ignore
 
     [keywordset]
     # prefer svn- over cvs-like default keywordmaps
     svn = True
 
 .. note::
 
    The more specific you are in your filename patterns the less you
    lose speed in huge repositories.
 
 For [keywordmaps] template mapping and expansion demonstration and
 control run :hg:`kwdemo`. See :hg:`help templates` for a list of
 available templates and filters.
 
 Three additional date template filters are provided:
 
 :``utcdate``:    "2006/09/18 15:13:13"
 :``svnutcdate``: "2006-09-18 15:13:13Z"
 :``svnisodate``: "2006-09-18 08:13:13 -700 (Mon, 18 Sep 2006)"
 
 The default template mappings (view with :hg:`kwdemo -d`) can be
 replaced with customized keywords and templates. Again, run
 :hg:`kwdemo` to control the results of your configuration changes.
 
 Before changing/disabling active keywords, you must run :hg:`kwshrink`
 to avoid storing expanded keywords in the change history.
 
 To force expansion after enabling it, or a configuration change, run
 :hg:`kwexpand`.
 
 Expansions spanning more than one line and incremental expansions,
 like CVS' $Log$, are not supported. A keyword template map "Log =
 {desc}" expands to the first line of the changeset description.
 '''
 
 from mercurial import commands, context, cmdutil, dispatch, filelog, extensions
 from mercurial import localrepo, match, patch, templatefilters, util
 from mercurial import scmutil, pathutil
 from mercurial.hgweb import webcommands
 from mercurial.i18n import _
 import os, re, tempfile
 
 cmdtable = {}
 command = cmdutil.command(cmdtable)
+# Note for extension authors: ONLY specify testedwith = 'internal' for
+# extensions which SHIP WITH MERCURIAL. Non-mainline extensions should
+# be specifying the version(s) of Mercurial they are tested with, or
+# leave the attribute unspecified.
 testedwith = 'internal'
 
 # hg commands that do not act on keywords
 nokwcommands = ('add addremove annotate bundle export grep incoming init log'
                 ' outgoing push tip verify convert email glog')
 
 # hg commands that trigger expansion only when writing to working dir,
 # not when reading filelog, and unexpand when reading from working dir
 restricted = ('merge kwexpand kwshrink record qrecord resolve transplant'
               ' unshelve rebase graft backout histedit fetch')
 
 # names of extensions using dorecord
 recordextensions = 'record'
 
 colortable = {
     'kwfiles.enabled': 'green bold',
     'kwfiles.deleted': 'cyan bold underline',
     'kwfiles.enabledunknown': 'green',
     'kwfiles.ignored': 'bold',
     'kwfiles.ignoredunknown': 'none'
 }
 
 # date like in cvs' $Date
 def utcdate(text):
     ''':utcdate: Date. Returns a UTC-date in this format: "2009/08/18 11:00:13".
     '''
     return util.datestr((util.parsedate(text)[0], 0), '%Y/%m/%d %H:%M:%S')
 # date like in svn's $Date
 def svnisodate(text):
     ''':svnisodate: Date. Returns a date in this format: "2009-08-18 13:00:13
     +0200 (Tue, 18 Aug 2009)".
     '''
     return util.datestr(text, '%Y-%m-%d %H:%M:%S %1%2 (%a, %d %b %Y)')
 # date like in svn's $Id
 def svnutcdate(text):
     ''':svnutcdate: Date. Returns a UTC-date in this format: "2009-08-18
     11:00:13Z".
     '''
     return util.datestr((util.parsedate(text)[0], 0), '%Y-%m-%d %H:%M:%SZ')
 
 templatefilters.filters.update({'utcdate': utcdate,
                                 'svnisodate': svnisodate,
                                 'svnutcdate': svnutcdate})
 
 # make keyword tools accessible
 kwtools = {'templater': None, 'hgcmd': ''}
 
 def _defaultkwmaps(ui):
     '''Returns default keywordmaps according to keywordset configuration.'''
     templates = {
         'Revision': '{node|short}',
         'Author': '{author|user}',
     }
     kwsets = ({
         'Date': '{date|utcdate}',
         'RCSfile': '{file|basename},v',
         'RCSFile': '{file|basename},v', # kept for backwards compatibility
                                         # with hg-keyword
         'Source': '{root}/{file},v',
         'Id': '{file|basename},v {node|short} {date|utcdate} {author|user}',
         'Header': '{root}/{file},v {node|short} {date|utcdate} {author|user}',
     }, {
         'Date': '{date|svnisodate}',
         'Id': '{file|basename},v {node|short} {date|svnutcdate} {author|user}',
         'LastChangedRevision': '{node|short}',
         'LastChangedBy': '{author|user}',
         'LastChangedDate': '{date|svnisodate}',
     })
     templates.update(kwsets[ui.configbool('keywordset', 'svn')])
     return templates
 
 def _shrinktext(text, subfunc):
     '''Helper for keyword expansion removal in text.
     Depending on subfunc also returns number of substitutions.'''
     return subfunc(r'$\1$', text)
 
 def _preselect(wstatus, changed):
     '''Retrieves modified and added files from a working directory state
     and returns the subset of each contained in given changed files
     retrieved from a change context.'''
     modified = [f for f in wstatus.modified if f in changed]
     added = [f for f in wstatus.added if f in changed]
     return modified, added
 
 
 class kwtemplater(object):
     '''
     Sets up keyword templates, corresponding keyword regex, and
     provides keyword substitution functions.
     '''
 
     def __init__(self, ui, repo, inc, exc):
         self.ui = ui
         self.repo = repo
         self.match = match.match(repo.root, '', [], inc, exc)
         self.restrict = kwtools['hgcmd'] in restricted.split()
         self.postcommit = False
 
         kwmaps = self.ui.configitems('keywordmaps')
         if kwmaps: # override default templates
             self.templates = dict(kwmaps)
         else:
             self.templates = _defaultkwmaps(self.ui)
 
     @util.propertycache
     def escape(self):
         '''Returns bar-separated and escaped keywords.'''
         return '|'.join(map(re.escape, self.templates.keys()))
 
     @util.propertycache
     def rekw(self):
         '''Returns regex for unexpanded keywords.'''
         return re.compile(r'\$(%s)\$' % self.escape)
 
     @util.propertycache
     def rekwexp(self):
         '''Returns regex for expanded keywords.'''
         return re.compile(r'\$(%s): [^$\n\r]*? \$' % self.escape)
 
     def substitute(self, data, path, ctx, subfunc):
         '''Replaces keywords in data with expanded template.'''
         def kwsub(mobj):
             kw = mobj.group(1)
             ct = cmdutil.changeset_templater(self.ui, self.repo, False, None,
                                              self.templates[kw], '', False)
             self.ui.pushbuffer()
             ct.show(ctx, root=self.repo.root, file=path)
             ekw = templatefilters.firstline(self.ui.popbuffer())
             return '$%s: %s $' % (kw, ekw)
         return subfunc(kwsub, data)
 
     def linkctx(self, path, fileid):
         '''Similar to filelog.linkrev, but returns a changectx.'''
         return self.repo.filectx(path, fileid=fileid).changectx()
 
     def expand(self, path, node, data):
         '''Returns data with keywords expanded.'''
         if not self.restrict and self.match(path) and not util.binary(data):
             ctx = self.linkctx(path, node)
             return self.substitute(data, path, ctx, self.rekw.sub)
         return data
 
     def iskwfile(self, cand, ctx):
         '''Returns subset of candidates which are configured for keyword
         expansion but are not symbolic links.'''
         return [f for f in cand if self.match(f) and 'l' not in ctx.flags(f)]
 
     def overwrite(self, ctx, candidates, lookup, expand, rekw=False):
         '''Overwrites selected files expanding/shrinking keywords.'''
         if self.restrict or lookup or self.postcommit: # exclude kw_copy
             candidates = self.iskwfile(candidates, ctx)
         if not candidates:
             return
         kwcmd = self.restrict and lookup # kwexpand/kwshrink
         if self.restrict or expand and lookup:
             mf = ctx.manifest()
         if self.restrict or rekw:
             re_kw = self.rekw
         else:
             re_kw = self.rekwexp
         if expand:
             msg = _('overwriting %s expanding keywords\n')
         else:
             msg = _('overwriting %s shrinking keywords\n')
         for f in candidates:
             if self.restrict:
                 data = self.repo.file(f).read(mf[f])
             else:
                 data = self.repo.wread(f)
             if util.binary(data):
                 continue
             if expand:
                 parents = ctx.parents()
                 if lookup:
                     ctx = self.linkctx(f, mf[f])
                 elif self.restrict and len(parents) > 1:
                     # merge commit
                     # in case of conflict f is in modified state during
                     # merge, even if f does not differ from f in parent
                     for p in parents:
                         if f in p and not p[f].cmp(ctx[f]):
                             ctx = p[f].changectx()
                             break
                 data, found = self.substitute(data, f, ctx, re_kw.subn)
             elif self.restrict:
                 found = re_kw.search(data)
             else:
                 data, found = _shrinktext(data, re_kw.subn)
             if found:
                 self.ui.note(msg % f)
                 fp = self.repo.wvfs(f, "wb", atomictemp=True)
                 fp.write(data)
                 fp.close()
                 if kwcmd:
                     self.repo.dirstate.normal(f)
                 elif self.postcommit:
                     self.repo.dirstate.normallookup(f)
 
     def shrink(self, fname, text):
         '''Returns text with all keyword substitutions removed.'''
         if self.match(fname) and not util.binary(text):
             return _shrinktext(text, self.rekwexp.sub)
         return text
 
     def shrinklines(self, fname, lines):
         '''Returns lines with keyword substitutions removed.'''
         if self.match(fname):
             text = ''.join(lines)
             if not util.binary(text):
                 return _shrinktext(text, self.rekwexp.sub).splitlines(True)
         return lines
 
     def wread(self, fname, data):
         '''If in restricted mode returns data read from wdir with
         keyword substitutions removed.'''
         if self.restrict:
             return self.shrink(fname, data)
         return data
 
 class kwfilelog(filelog.filelog):
     '''
     Subclass of filelog to hook into its read, add, cmp methods.
     Keywords are "stored" unexpanded, and processed on reading.
     '''
     def __init__(self, opener, kwt, path):
         super(kwfilelog, self).__init__(opener, path)
         self.kwt = kwt
         self.path = path
 
     def read(self, node):
         '''Expands keywords when reading filelog.'''
         data = super(kwfilelog, self).read(node)
         if self.renamed(node):
             return data
         return self.kwt.expand(self.path, node, data)
 
     def add(self, text, meta, tr, link, p1=None, p2=None):
         '''Removes keyword substitutions when adding to filelog.'''
         text = self.kwt.shrink(self.path, text)
         return super(kwfilelog, self).add(text, meta, tr, link, p1, p2)
 
     def cmp(self, node, text):
         '''Removes keyword substitutions for comparison.'''
         text = self.kwt.shrink(self.path, text)
         return super(kwfilelog, self).cmp(node, text)
 
 def _status(ui, repo, wctx, kwt, *pats, **opts):
     '''Bails out if [keyword] configuration is not active.
     Returns status of working directory.'''
     if kwt:
         return repo.status(match=scmutil.match(wctx, pats, opts), clean=True,
                            unknown=opts.get('unknown') or opts.get('all'))
     if ui.configitems('keyword'):
         raise util.Abort(_('[keyword] patterns cannot match'))
     raise util.Abort(_('no [keyword] patterns configured'))
 
 def _kwfwrite(ui, repo, expand, *pats, **opts):
     '''Selects files and passes them to kwtemplater.overwrite.'''
     wctx = repo[None]
     if len(wctx.parents()) > 1:
         raise util.Abort(_('outstanding uncommitted merge'))
     kwt = kwtools['templater']
     wlock = repo.wlock()
     try:
         status = _status(ui, repo, wctx, kwt, *pats, **opts)
         if status.modified or status.added or status.removed or status.deleted:
             raise util.Abort(_('outstanding uncommitted changes'))
         kwt.overwrite(wctx, status.clean, True, expand)
     finally:
         wlock.release()
 
 @command('kwdemo',
          [('d', 'default', None, _('show default keyword template maps')),
           ('f', 'rcfile', '',
            _('read maps from rcfile'), _('FILE'))],
          _('hg kwdemo [-d] [-f RCFILE] [TEMPLATEMAP]...'),
          optionalrepo=True)
 def demo(ui, repo, *args, **opts):
     '''print [keywordmaps] configuration and an expansion example
 
     Show current, custom, or default keyword template maps and their
     expansions.
 
     Extend the current configuration by specifying maps as arguments
     and using -f/--rcfile to source an external hgrc file.
 
     Use -d/--default to disable current configuration.
 
     See :hg:`help templates` for information on templates and filters.
     '''
     def demoitems(section, items):
         ui.write('[%s]\n' % section)
         for k, v in sorted(items):
             ui.write('%s = %s\n' % (k, v))
 
     fn = 'demo.txt'
     tmpdir = tempfile.mkdtemp('', 'kwdemo.')
     ui.note(_('creating temporary repository at %s\n') % tmpdir)
     repo = localrepo.localrepository(repo.baseui, tmpdir, True)
     ui.setconfig('keyword', fn, '', 'keyword')
     svn = ui.configbool('keywordset', 'svn')
     # explicitly set keywordset for demo output
     ui.setconfig('keywordset', 'svn', svn, 'keyword')
 
     uikwmaps = ui.configitems('keywordmaps')
     if args or opts.get('rcfile'):
         ui.status(_('\n\tconfiguration using custom keyword template maps\n'))
         if uikwmaps:
             ui.status(_('\textending current template maps\n'))
         if opts.get('default') or not uikwmaps:
             if svn:
                 ui.status(_('\toverriding default svn keywordset\n'))
             else:
                 ui.status(_('\toverriding default cvs keywordset\n'))
         if opts.get('rcfile'):
             ui.readconfig(opts.get('rcfile'))
         if args:
             # simulate hgrc parsing
             rcmaps = ['[keywordmaps]\n'] + [a + '\n' for a in args]
             fp = repo.vfs('hgrc', 'w')
             fp.writelines(rcmaps)
             fp.close()
             ui.readconfig(repo.join('hgrc'))
         kwmaps = dict(ui.configitems('keywordmaps'))
     elif opts.get('default'):
         if svn:
             ui.status(_('\n\tconfiguration using default svn keywordset\n'))
         else:
             ui.status(_('\n\tconfiguration using default cvs keywordset\n'))
         kwmaps = _defaultkwmaps(ui)
         if uikwmaps:
             ui.status(_('\tdisabling current template maps\n'))
             for k, v in kwmaps.iteritems():
                 ui.setconfig('keywordmaps', k, v, 'keyword')
     else:
         ui.status(_('\n\tconfiguration using current keyword template maps\n'))
         if uikwmaps:
             kwmaps = dict(uikwmaps)
         else:
             kwmaps = _defaultkwmaps(ui)
 
     uisetup(ui)
     reposetup(ui, repo)
     ui.write('[extensions]\nkeyword =\n')
     demoitems('keyword', ui.configitems('keyword'))
     demoitems('keywordset', ui.configitems('keywordset'))
     demoitems('keywordmaps', kwmaps.iteritems())
     keywords = '$' + '$\n$'.join(sorted(kwmaps.keys())) + '$\n'
     repo.wvfs.write(fn, keywords)
     repo[None].add([fn])
     ui.note(_('\nkeywords written to %s:\n') % fn)
     ui.note(keywords)
     wlock = repo.wlock()
     try:
         repo.dirstate.setbranch('demobranch')
     finally:
         wlock.release()
     for name, cmd in ui.configitems('hooks'):
         if name.split('.', 1)[0].find('commit') > -1:
             repo.ui.setconfig('hooks', name, '', 'keyword')
     msg = _('hg keyword configuration and expansion example')
     ui.note(("hg ci -m '%s'\n" % msg))
     repo.commit(text=msg)
     ui.status(_('\n\tkeywords expanded\n'))
     ui.write(repo.wread(fn))
     repo.wvfs.rmtree(repo.root)
 
 @command('kwexpand',
     commands.walkopts,
     _('hg kwexpand [OPTION]... [FILE]...'),
     inferrepo=True)
 def expand(ui, repo, *pats, **opts):
     '''expand keywords in the working directory
 
     Run after (re)enabling keyword expansion.
 
     kwexpand refuses to run if given files contain local changes.
     '''
     # 3rd argument sets expansion to True
     _kwfwrite(ui, repo, True, *pats, **opts)
 
 @command('kwfiles',
          [('A', 'all', None, _('show keyword status flags of all files')),
           ('i', 'ignore', None, _('show files excluded from expansion')),
           ('u', 'unknown', None, _('only show unknown (not tracked) files')),
          ] + commands.walkopts,
          _('hg kwfiles [OPTION]... [FILE]...'),
          inferrepo=True)
 def files(ui, repo, *pats, **opts):
     '''show files configured for keyword expansion
 
     List which files in the working directory are matched by the
     [keyword] configuration patterns.
 
     Useful to prevent inadvertent keyword expansion and to speed up
     execution by including only files that are actual candidates for
     expansion.
 
     See :hg:`help keyword` on how to construct patterns both for
     inclusion and exclusion of files.
 
     With -A/--all and -v/--verbose the codes used to show the status
     of files are::
 
       K = keyword expansion candidate
       k = keyword expansion candidate (not tracked)
       I = ignored
       i = ignored (not tracked)
     '''
     kwt = kwtools['templater']
     wctx = repo[None]
     status = _status(ui, repo, wctx, kwt, *pats, **opts)
     if pats:
         cwd = repo.getcwd()
     else:
         cwd = ''
     files = []
     if not opts.get('unknown') or opts.get('all'):
         files = sorted(status.modified + status.added + status.clean)
     kwfiles = kwt.iskwfile(files, wctx)
     kwdeleted = kwt.iskwfile(status.deleted, wctx)
     kwunknown = kwt.iskwfile(status.unknown, wctx)
     if not opts.get('ignore') or opts.get('all'):
         showfiles = kwfiles, kwdeleted, kwunknown
     else:
         showfiles = [], [], []
     if opts.get('all') or opts.get('ignore'):
         showfiles += ([f for f in files if f not in kwfiles],
                       [f for f in status.unknown if f not in kwunknown])
     kwlabels = 'enabled deleted enabledunknown ignored ignoredunknown'.split()
     kwstates = zip(kwlabels, 'K!kIi', showfiles)
     fm = ui.formatter('kwfiles', opts)
     fmt = '%.0s%s\n'
     if opts.get('all') or ui.verbose:
         fmt = '%s %s\n'
     for kwstate, char, filenames in kwstates:
         label = 'kwfiles.' + kwstate
         for f in filenames:
             fm.startitem()
             fm.write('kwstatus path', fmt, char,
                      repo.pathto(f, cwd), label=label)
     fm.end()
 
 @command('kwshrink',
     commands.walkopts,
     _('hg kwshrink [OPTION]... [FILE]...'),
     inferrepo=True)
 def shrink(ui, repo, *pats, **opts):
     '''revert expanded keywords in the working directory
 
     Must be run before changing/disabling active keywords.
 
     kwshrink refuses to run if given files contain local changes.
     '''
     # 3rd argument sets expansion to False
     _kwfwrite(ui, repo, False, *pats, **opts)
 
 
 def uisetup(ui):
     ''' Monkeypatches dispatch._parse to retrieve user command.'''
 
     def kwdispatch_parse(orig, ui, args):
         '''Monkeypatch dispatch._parse to obtain running hg command.'''
         cmd, func, args, options, cmdoptions = orig(ui, args)
         kwtools['hgcmd'] = cmd
         return cmd, func, args, options, cmdoptions
 
     extensions.wrapfunction(dispatch, '_parse', kwdispatch_parse)
 
 def reposetup(ui, repo):
     '''Sets up repo as kwrepo for keyword substitution.
     Overrides file method to return kwfilelog instead of filelog
     if file matches user configuration.
     Wraps commit to overwrite configured files with updated
     keyword substitutions.
     Monkeypatches patch and webcommands.'''
 
     try:
         if (not repo.local() or kwtools['hgcmd'] in nokwcommands.split()
             or '.hg' in util.splitpath(repo.root)
             or repo._url.startswith('bundle:')):
             return
     except AttributeError:
         pass
 
     inc, exc = [], ['.hg*']
     for pat, opt in ui.configitems('keyword'):
         if opt != 'ignore':
             inc.append(pat)
         else:
             exc.append(pat)
     if not inc:
         return
 
     kwtools['templater'] = kwt = kwtemplater(ui, repo, inc, exc)
 
     class kwrepo(repo.__class__):
         def file(self, f):
             if f[0] == '/':
                 f = f[1:]
             return kwfilelog(self.svfs, kwt, f)
 
         def wread(self, filename):
             data = super(kwrepo, self).wread(filename)
             return kwt.wread(filename, data)
 
         def commit(self, *args, **opts):
             # use custom commitctx for user commands
             # other extensions can still wrap repo.commitctx directly
             self.commitctx = self.kwcommitctx
             try:
                 return super(kwrepo, self).commit(*args, **opts)
             finally:
                 del self.commitctx
 
         def kwcommitctx(self, ctx, error=False):
             n = super(kwrepo, self).commitctx(ctx, error)
             # no lock needed, only called from repo.commit() which already locks
             if not kwt.postcommit:
                 restrict = kwt.restrict
                 kwt.restrict = True
                 kwt.overwrite(self[n], sorted(ctx.added() + ctx.modified()),
                               False, True)
                 kwt.restrict = restrict
             return n
 
         def rollback(self, dryrun=False, force=False):
             wlock = self.wlock()
             try:
                 if not dryrun:
                     changed = self['.'].files()
                 ret = super(kwrepo, self).rollback(dryrun, force)
                 if not dryrun:
                     ctx = self['.']
                     modified, added = _preselect(ctx.status(), changed)
                     kwt.overwrite(ctx, modified, True, True)
                     kwt.overwrite(ctx, added, True, False)
                 return ret
             finally:
                 wlock.release()
 
     # monkeypatches
     def kwpatchfile_init(orig, self, ui, gp, backend, store, eolmode=None):
         '''Monkeypatch/wrap patch.patchfile.__init__ to avoid
         rejects or conflicts due to expanded keywords in working dir.'''
         orig(self, ui, gp, backend, store, eolmode)
         # shrink keywords read from working dir
         self.lines = kwt.shrinklines(self.fname, self.lines)
 
     def kwdiff(orig, *args, **kwargs):
         '''Monkeypatch patch.diff to avoid expansion.'''
         kwt.restrict = True
         return orig(*args, **kwargs)
 
     def kwweb_skip(orig, web, req, tmpl):
         '''Wraps webcommands.x turning off keyword expansion.'''
         kwt.match = util.never
         return orig(web, req, tmpl)
 
     def kw_amend(orig, ui, repo, commitfunc, old, extra, pats, opts):
         '''Wraps cmdutil.amend expanding keywords after amend.'''
         wlock = repo.wlock()
         try:
             kwt.postcommit = True
             newid = orig(ui, repo, commitfunc, old, extra, pats, opts)
             if newid != old.node():
                 ctx = repo[newid]
                 kwt.restrict = True
                 kwt.overwrite(ctx, ctx.files(), False, True)
                 kwt.restrict = False
             return newid
         finally:
             wlock.release()
 
     def kw_copy(orig, ui, repo, pats, opts, rename=False):
         '''Wraps cmdutil.copy so that copy/rename destinations do not
         contain expanded keywords.
         Note that the source of a regular file destination may also be a
         symlink:
         hg cp sym x                -> x is symlink
         cp sym x; hg cp -A sym x   -> x is file (maybe expanded keywords)
         For the latter we have to follow the symlink to find out whether its
         target is configured for expansion and we therefore must unexpand the
         keywords in the destination.'''
         wlock = repo.wlock()
         try:
             orig(ui, repo, pats, opts, rename)
             if opts.get('dry_run'):
                 return
             wctx = repo[None]
             cwd = repo.getcwd()
 
             def haskwsource(dest):
                 '''Returns true if dest is a regular file and configured for
                 expansion or a symlink which points to a file configured for
                 expansion. '''
                 source = repo.dirstate.copied(dest)
                 if 'l' in wctx.flags(source):
                     source = pathutil.canonpath(repo.root, cwd,
                                                os.path.realpath(source))
                 return kwt.match(source)
 
             candidates = [f for f in repo.dirstate.copies() if
                           'l' not in wctx.flags(f) and haskwsource(f)]
             kwt.overwrite(wctx, candidates, False, False)
         finally:
             wlock.release()
 
     def kw_dorecord(orig, ui, repo, commitfunc, *pats, **opts):
         '''Wraps record.dorecord expanding keywords after recording.'''
         wlock = repo.wlock()
         try:
             # record returns 0 even when nothing has changed
             # therefore compare nodes before and after
             kwt.postcommit = True
             ctx = repo['.']
             wstatus = ctx.status()
             ret = orig(ui, repo, commitfunc, *pats, **opts)
             recctx = repo['.']
             if ctx != recctx:
                 modified, added = _preselect(wstatus, recctx.files())
                 kwt.restrict = False
                 kwt.overwrite(recctx, modified, False, True)
                 kwt.overwrite(recctx, added, False, True, True)
                 kwt.restrict = True
             return ret
         finally:
             wlock.release()
 
     def kwfilectx_cmp(orig, self, fctx):
         # keyword affects data size, comparing wdir and filelog size does
         # not make sense
         if (fctx._filerev is None and
             (self._repo._encodefilterpats or
              kwt.match(fctx.path()) and 'l' not in fctx.flags() or
              self.size() - 4 == fctx.size()) or
             self.size() == fctx.size()):
             return self._filelog.cmp(self._filenode, fctx.data())
         return True
 
     extensions.wrapfunction(context.filectx, 'cmp', kwfilectx_cmp)
     extensions.wrapfunction(patch.patchfile, '__init__', kwpatchfile_init)
     extensions.wrapfunction(patch, 'diff', kwdiff)
     extensions.wrapfunction(cmdutil, 'amend', kw_amend)
     extensions.wrapfunction(cmdutil, 'copy', kw_copy)
     extensions.wrapfunction(cmdutil, 'dorecord', kw_dorecord)
     for c in 'annotate changeset rev filediff diff'.split():
         extensions.wrapfunction(webcommands, c, kwweb_skip)
     repo.__class__ = kwrepo

hgext/largefiles/__init__.py

@@ -1,128 +1,132 b''
 # Copyright 2009-2010 Gregory P. Ward
 # Copyright 2009-2010 Intelerad Medical Systems Incorporated
 # Copyright 2010-2011 Fog Creek Software
 # Copyright 2010-2011 Unity Technologies
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 '''track large binary files
 
 Large binary files tend to be not very compressible, not very
 diffable, and not at all mergeable. Such files are not handled
 efficiently by Mercurial's storage format (revlog), which is based on
 compressed binary deltas; storing large binary files as regular
 Mercurial files wastes bandwidth and disk space and increases
 Mercurial's memory usage. The largefiles extension addresses these
 problems by adding a centralized client-server layer on top of
 Mercurial: largefiles live in a *central store* out on the network
 somewhere, and you only fetch the revisions that you need when you
 need them.
 
 largefiles works by maintaining a "standin file" in .hglf/ for each
 largefile. The standins are small (41 bytes: an SHA-1 hash plus
 newline) and are tracked by Mercurial. Largefile revisions are
 identified by the SHA-1 hash of their contents, which is written to
 the standin. largefiles uses that revision ID to get/put largefile
 revisions from/to the central store. This saves both disk space and
 bandwidth, since you don't need to retrieve all historical revisions
 of large files when you clone or pull.
 
 To start a new repository or add new large binary files, just add
 --large to your :hg:`add` command. For example::
 
   $ dd if=/dev/urandom of=randomdata count=2000
   $ hg add --large randomdata
   $ hg commit -m 'add randomdata as a largefile'
 
 When you push a changeset that adds/modifies largefiles to a remote
 repository, its largefile revisions will be uploaded along with it.
 Note that the remote Mercurial must also have the largefiles extension
 enabled for this to work.
 
 When you pull a changeset that affects largefiles from a remote
 repository, the largefiles for the changeset will by default not be
 pulled down. However, when you update to such a revision, any
 largefiles needed by that revision are downloaded and cached (if
 they have never been downloaded before). One way to pull largefiles
 when pulling is thus to use --update, which will update your working
 copy to the latest pulled revision (and thereby downloading any new
 largefiles).
 
 If you want to pull largefiles you don't need for update yet, then
 you can use pull with the `--lfrev` option or the :hg:`lfpull` command.
 
 If you know you are pulling from a non-default location and want to
 download all the largefiles that correspond to the new changesets at
 the same time, then you can pull with `--lfrev "pulled()"`.
 
 If you just want to ensure that you will have the largefiles needed to
 merge or rebase with new heads that you are pulling, then you can pull
 with `--lfrev "head(pulled())"` flag to pre-emptively download any largefiles
 that are new in the heads you are pulling.
 
 Keep in mind that network access may now be required to update to
 changesets that you have not previously updated to. The nature of the
 largefiles extension means that updating is no longer guaranteed to
 be a local-only operation.
 
 If you already have large files tracked by Mercurial without the
 largefiles extension, you will need to convert your repository in
 order to benefit from largefiles. This is done with the
 :hg:`lfconvert` command::
 
   $ hg lfconvert --size 10 oldrepo newrepo
 
 In repositories that already have largefiles in them, any new file
 over 10MB will automatically be added as a largefile. To change this
 threshold, set ``largefiles.minsize`` in your Mercurial config file
 to the minimum size in megabytes to track as a largefile, or use the
 --lfsize option to the add command (also in megabytes)::
 
   [largefiles]
   minsize = 2
 
   $ hg add --lfsize 2
 
 The ``largefiles.patterns`` config option allows you to specify a list
 of filename patterns (see :hg:`help patterns`) that should always be
 tracked as largefiles::
 
   [largefiles]
   patterns =
     *.jpg
     re:.*\.(png|bmp)$
     library.zip
     content/audio/*
 
 Files that match one of these patterns will be added as largefiles
 regardless of their size.
 
 The ``largefiles.minsize`` and ``largefiles.patterns`` config options
 will be ignored for any repositories not already containing a
 largefile. To add the first largefile to a repository, you must
 explicitly do so with the --large flag passed to the :hg:`add`
 command.
 '''
 
 from mercurial import hg, localrepo
 
 import lfcommands
 import proto
 import reposetup
 import uisetup as uisetupmod
 
+# Note for extension authors: ONLY specify testedwith = 'internal' for
+# extensions which SHIP WITH MERCURIAL. Non-mainline extensions should
+# be specifying the version(s) of Mercurial they are tested with, or
+# leave the attribute unspecified.
 testedwith = 'internal'
 
 reposetup = reposetup.reposetup
 
 def featuresetup(ui, supported):
     # don't die on seeing a repo with the largefiles requirement
     supported |= set(['largefiles'])
 
 def uisetup(ui):
     localrepo.localrepository.featuresetupfuncs.add(featuresetup)
     hg.wirepeersetupfuncs.append(proto.wirereposetup)
     uisetupmod.uisetup(ui)
 
 cmdtable = lfcommands.cmdtable

hgext/mq.py

@@ -1,3579 +1,3583 b''
 # mq.py - patch queues for mercurial
 #
 # Copyright 2005, 2006 Chris Mason <[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.
 
 '''manage a stack of patches
 
 This extension lets you work with a stack of patches in a Mercurial
 repository. It manages two stacks of patches - all known patches, and
 applied patches (subset of known patches).
 
 Known patches are represented as patch files in the .hg/patches
 directory. Applied patches are both patch files and changesets.
 
 Common tasks (use :hg:`help command` for more details)::
 
   create new patch                          qnew
   import existing patch                     qimport
 
   print patch series                        qseries
   print applied patches                     qapplied
 
   add known patch to applied stack          qpush
   remove patch from applied stack           qpop
   refresh contents of top applied patch     qrefresh
 
 By default, mq will automatically use git patches when required to
 avoid losing file mode changes, copy records, binary files or empty
 files creations or deletions. This behaviour can be configured with::
 
   [mq]
   git = auto/keep/yes/no
 
 If set to 'keep', mq will obey the [diff] section configuration while
 preserving existing git patches upon qrefresh. If set to 'yes' or
 'no', mq will override the [diff] section and always generate git or
 regular patches, possibly losing data in the second case.
 
 It may be desirable for mq changesets to be kept in the secret phase (see
 :hg:`help phases`), which can be enabled with the following setting::
 
   [mq]
   secret = True
 
 You will by default be managing a patch queue named "patches". You can
 create other, independent patch queues with the :hg:`qqueue` command.
 
 If the working directory contains uncommitted files, qpush, qpop and
 qgoto abort immediately. If -f/--force is used, the changes are
 discarded. Setting::
 
   [mq]
   keepchanges = True
 
 make them behave as if --keep-changes were passed, and non-conflicting
 local changes will be tolerated and preserved. If incompatible options
 such as -f/--force or --exact are passed, this setting is ignored.
 
 This extension used to provide a strip command. This command now lives
 in the strip extension.
 '''
 
 from mercurial.i18n import _
 from mercurial.node import bin, hex, short, nullid, nullrev
 from mercurial.lock import release
 from mercurial import commands, cmdutil, hg, scmutil, util, revset
 from mercurial import extensions, error, phases
 from mercurial import patch as patchmod
 from mercurial import localrepo
 from mercurial import subrepo
 import os, re, errno, shutil
 
 seriesopts = [('s', 'summary', None, _('print first line of patch header'))]
 
 cmdtable = {}
 command = cmdutil.command(cmdtable)
+# Note for extension authors: ONLY specify testedwith = 'internal' for
+# extensions which SHIP WITH MERCURIAL. Non-mainline extensions should
+# be specifying the version(s) of Mercurial they are tested with, or
+# leave the attribute unspecified.
 testedwith = 'internal'
 
 # force load strip extension formerly included in mq and import some utility
 try:
     stripext = extensions.find('strip')
 except KeyError:
     # note: load is lazy so we could avoid the try-except,
     # but I (marmoute) prefer this explicit code.
     class dummyui(object):
         def debug(self, msg):
             pass
     stripext = extensions.load(dummyui(), 'strip', '')
 
 strip = stripext.strip
 checksubstate = stripext.checksubstate
 checklocalchanges = stripext.checklocalchanges
 
 
 # Patch names looks like unix-file names.
 # They must be joinable with queue directory and result in the patch path.
 normname = util.normpath
 
 class statusentry(object):
     def __init__(self, node, name):
         self.node, self.name = node, name
     def __repr__(self):
         return hex(self.node) + ':' + self.name
 
 # The order of the headers in 'hg export' HG patches:
 HGHEADERS = [
 #   '# HG changeset patch',
     '# User ',
     '# Date ',
     '#      ',
     '# Branch ',
     '# Node ID ',
     '# Parent  ', # can occur twice for merges - but that is not relevant for mq
     ]
 # The order of headers in plain 'mail style' patches:
 PLAINHEADERS = {
     'from': 0,
     'date': 1,
     'subject': 2,
     }
 
 def inserthgheader(lines, header, value):
     """Assuming lines contains a HG patch header, add a header line with value.
     >>> try: inserthgheader([], '# Date ', 'z')
     ... except ValueError, inst: print "oops"
     oops
     >>> inserthgheader(['# HG changeset patch'], '# Date ', 'z')
     ['# HG changeset patch', '# Date z']
     >>> inserthgheader(['# HG changeset patch', ''], '# Date ', 'z')
     ['# HG changeset patch', '# Date z', '']
     >>> inserthgheader(['# HG changeset patch', '# User y'], '# Date ', 'z')
     ['# HG changeset patch', '# User y', '# Date z']
     >>> inserthgheader(['# HG changeset patch', '# Date x', '# User y'],
     ...                '# User ', 'z')
     ['# HG changeset patch', '# Date x', '# User z']
     >>> inserthgheader(['# HG changeset patch', '# Date y'], '# Date ', 'z')
     ['# HG changeset patch', '# Date z']
     >>> inserthgheader(['# HG changeset patch', '', '# Date y'], '# Date ', 'z')
     ['# HG changeset patch', '# Date z', '', '# Date y']
     >>> inserthgheader(['# HG changeset patch', '# Parent  y'], '# Date ', 'z')
     ['# HG changeset patch', '# Date z', '# Parent  y']
     """
     start = lines.index('# HG changeset patch') + 1
     newindex = HGHEADERS.index(header)
     bestpos = len(lines)
     for i in range(start, len(lines)):
         line = lines[i]
         if not line.startswith('# '):
             bestpos = min(bestpos, i)
             break
         for lineindex, h in enumerate(HGHEADERS):
             if line.startswith(h):
                 if lineindex == newindex:
                     lines[i] = header + value
                     return lines
                 if lineindex > newindex:
                     bestpos = min(bestpos, i)
                 break # next line
     lines.insert(bestpos, header + value)
     return lines
 
 def insertplainheader(lines, header, value):
     """For lines containing a plain patch header, add a header line with value.
     >>> insertplainheader([], 'Date', 'z')
     ['Date: z']
     >>> insertplainheader([''], 'Date', 'z')
     ['Date: z', '']
     >>> insertplainheader(['x'], 'Date', 'z')
     ['Date: z', '', 'x']
     >>> insertplainheader(['From: y', 'x'], 'Date', 'z')
     ['From: y', 'Date: z', '', 'x']
     >>> insertplainheader([' date : x', ' from : y', ''], 'From', 'z')
     [' date : x', 'From: z', '']
     >>> insertplainheader(['', 'Date: y'], 'Date', 'z')
     ['Date: z', '', 'Date: y']
     >>> insertplainheader(['foo: bar', 'DATE: z', 'x'], 'From', 'y')
     ['From: y', 'foo: bar', 'DATE: z', '', 'x']
     """
     newprio = PLAINHEADERS[header.lower()]
     bestpos = len(lines)
     for i, line in enumerate(lines):
         if ':' in line:
             lheader = line.split(':', 1)[0].strip().lower()
             lprio = PLAINHEADERS.get(lheader, newprio + 1)
             if lprio == newprio:
                 lines[i] = '%s: %s' % (header, value)
                 return lines
             if lprio > newprio and i < bestpos:
                 bestpos = i
         else:
             if line:
                 lines.insert(i, '')
             if i < bestpos:
                 bestpos = i
             break
     lines.insert(bestpos, '%s: %s' % (header, value))
     return lines
 
 class patchheader(object):
     def __init__(self, pf, plainmode=False):
         def eatdiff(lines):
             while lines:
                 l = lines[-1]
                 if (l.startswith("diff -") or
                     l.startswith("Index:") or
                     l.startswith("===========")):
                     del lines[-1]
                 else:
                     break
         def eatempty(lines):
             while lines:
                 if not lines[-1].strip():
                     del lines[-1]
                 else:
                     break
 
         message = []
         comments = []
         user = None
         date = None
         parent = None
         format = None
         subject = None
         branch = None
         nodeid = None
         diffstart = 0
 
         for line in file(pf):
             line = line.rstrip()
             if (line.startswith('diff --git')
                 or (diffstart and line.startswith('+++ '))):
                 diffstart = 2
                 break
             diffstart = 0 # reset
             if line.startswith("--- "):
                 diffstart = 1
                 continue
             elif format == "hgpatch":
                 # parse values when importing the result of an hg export
                 if line.startswith("# User "):
                     user = line[7:]
                 elif line.startswith("# Date "):
                     date = line[7:]
                 elif line.startswith("# Parent "):
                     parent = line[9:].lstrip() # handle double trailing space
                 elif line.startswith("# Branch "):
                     branch = line[9:]
                 elif line.startswith("# Node ID "):
                     nodeid = line[10:]
                 elif not line.startswith("# ") and line:
                     message.append(line)
                     format = None
             elif line == '# HG changeset patch':
                 message = []
                 format = "hgpatch"
             elif (format != "tagdone" and (line.startswith("Subject: ") or
                                            line.startswith("subject: "))):
                 subject = line[9:]
                 format = "tag"
             elif (format != "tagdone" and (line.startswith("From: ") or
                                            line.startswith("from: "))):
                 user = line[6:]
                 format = "tag"
             elif (format != "tagdone" and (line.startswith("Date: ") or
                                            line.startswith("date: "))):
                 date = line[6:]
                 format = "tag"
             elif format == "tag" and line == "":
                 # when looking for tags (subject: from: etc) they
                 # end once you find a blank line in the source
                 format = "tagdone"
             elif message or line:
                 message.append(line)
             comments.append(line)
 
         eatdiff(message)
         eatdiff(comments)
         # Remember the exact starting line of the patch diffs before consuming
         # empty lines, for external use by TortoiseHg and others
         self.diffstartline = len(comments)
         eatempty(message)
         eatempty(comments)
 
         # make sure message isn't empty
         if format and format.startswith("tag") and subject:
             message.insert(0, subject)
 
         self.message = message
         self.comments = comments
         self.user = user
         self.date = date
         self.parent = parent
         # nodeid and branch are for external use by TortoiseHg and others
         self.nodeid = nodeid
         self.branch = branch
         self.haspatch = diffstart > 1
         self.plainmode = (plainmode or
                           '# HG changeset patch' not in self.comments and
                           any(c.startswith('Date: ') or
                                    c.startswith('From: ')
                                    for c in self.comments))
 
     def setuser(self, user):
         try:
             inserthgheader(self.comments, '# User ', user)
         except ValueError:
             if self.plainmode:
                 insertplainheader(self.comments, 'From', user)
             else:
                 tmp = ['# HG changeset patch', '# User ' + user]
                 self.comments = tmp + self.comments
         self.user = user
 
     def setdate(self, date):
         try:
             inserthgheader(self.comments, '# Date ', date)
         except ValueError:
             if self.plainmode:
                 insertplainheader(self.comments, 'Date', date)
             else:
                 tmp = ['# HG changeset patch', '# Date ' + date]
                 self.comments = tmp + self.comments
         self.date = date
 
     def setparent(self, parent):
         try:
             inserthgheader(self.comments, '# Parent  ', parent)
         except ValueError:
             if not self.plainmode:
                 tmp = ['# HG changeset patch', '# Parent  ' + parent]
                 self.comments = tmp + self.comments
         self.parent = parent
 
     def setmessage(self, message):
         if self.comments:
             self._delmsg()
         self.message = [message]
         if message:
             if self.plainmode and self.comments and self.comments[-1]:
                 self.comments.append('')
             self.comments.append(message)
 
     def __str__(self):
         s = '\n'.join(self.comments).rstrip()
         if not s:
             return ''
         return s + '\n\n'
 
     def _delmsg(self):
         '''Remove existing message, keeping the rest of the comments fields.
         If comments contains 'subject: ', message will prepend
         the field and a blank line.'''
         if self.message:
             subj = 'subject: ' + self.message[0].lower()
             for i in xrange(len(self.comments)):
                 if subj == self.comments[i].lower():
                     del self.comments[i]
                     self.message = self.message[2:]
                     break
         ci = 0
         for mi in self.message:
             while mi != self.comments[ci]:
                 ci += 1
             del self.comments[ci]
 
 def newcommit(repo, phase, *args, **kwargs):
     """helper dedicated to ensure a commit respect mq.secret setting
 
     It should be used instead of repo.commit inside the mq source for operation
     creating new changeset.
     """
     repo = repo.unfiltered()
     if phase is None:
         if repo.ui.configbool('mq', 'secret', False):
             phase = phases.secret
     if phase is not None:
         phasebackup = repo.ui.backupconfig('phases', 'new-commit')
     allowemptybackup = repo.ui.backupconfig('ui', 'allowemptycommit')
     try:
         if phase is not None:
             repo.ui.setconfig('phases', 'new-commit', phase, 'mq')
         repo.ui.setconfig('ui', 'allowemptycommit', True)
         return repo.commit(*args, **kwargs)
     finally:
         repo.ui.restoreconfig(allowemptybackup)
         if phase is not None:
             repo.ui.restoreconfig(phasebackup)
 
 class AbortNoCleanup(error.Abort):
     pass
 
 class queue(object):
     def __init__(self, ui, baseui, path, patchdir=None):
         self.basepath = path
         try:
             fh = open(os.path.join(path, 'patches.queue'))
             cur = fh.read().rstrip()
             fh.close()
             if not cur:
                 curpath = os.path.join(path, 'patches')
             else:
                 curpath = os.path.join(path, 'patches-' + cur)
         except IOError:
             curpath = os.path.join(path, 'patches')
         self.path = patchdir or curpath
         self.opener = scmutil.opener(self.path)
         self.ui = ui
         self.baseui = baseui
         self.applieddirty = False
         self.seriesdirty = False
         self.added = []
         self.seriespath = "series"
         self.statuspath = "status"
         self.guardspath = "guards"
         self.activeguards = None
         self.guardsdirty = False
         # Handle mq.git as a bool with extended values
         try:
             gitmode = ui.configbool('mq', 'git', None)
             if gitmode is None:
                 raise error.ConfigError
             if gitmode:
                 self.gitmode = 'yes'
             else:
                 self.gitmode = 'no'
         except error.ConfigError:
             self.gitmode = ui.config('mq', 'git', 'auto').lower()
         self.plainmode = ui.configbool('mq', 'plain', False)
         self.checkapplied = True
 
     @util.propertycache
     def applied(self):
         def parselines(lines):
             for l in lines:
                 entry = l.split(':', 1)
                 if len(entry) > 1:
                     n, name = entry
                     yield statusentry(bin(n), name)
                 elif l.strip():
                     self.ui.warn(_('malformated mq status line: %s\n') % entry)
                 # else we ignore empty lines
         try:
             lines = self.opener.read(self.statuspath).splitlines()
             return list(parselines(lines))
         except IOError, e:
             if e.errno == errno.ENOENT:
                 return []
             raise
 
     @util.propertycache
     def fullseries(self):
         try:
             return self.opener.read(self.seriespath).splitlines()
         except IOError, e:
             if e.errno == errno.ENOENT:
                 return []
             raise
 
     @util.propertycache
     def series(self):
         self.parseseries()
         return self.series
 
     @util.propertycache
     def seriesguards(self):
         self.parseseries()
         return self.seriesguards
 
     def invalidate(self):
         for a in 'applied fullseries series seriesguards'.split():
             if a in self.__dict__:
                 delattr(self, a)
         self.applieddirty = False
         self.seriesdirty = False
         self.guardsdirty = False
         self.activeguards = None
 
     def diffopts(self, opts={}, patchfn=None):
         diffopts = patchmod.diffopts(self.ui, opts)
         if self.gitmode == 'auto':
             diffopts.upgrade = True
         elif self.gitmode == 'keep':
             pass
         elif self.gitmode in ('yes', 'no'):
             diffopts.git = self.gitmode == 'yes'
         else:
             raise util.Abort(_('mq.git option can be auto/keep/yes/no'
                                ' got %s') % self.gitmode)
         if patchfn:
             diffopts = self.patchopts(diffopts, patchfn)
         return diffopts
 
     def patchopts(self, diffopts, *patches):
         """Return a copy of input diff options with git set to true if
         referenced patch is a git patch and should be preserved as such.
         """
         diffopts = diffopts.copy()
         if not diffopts.git and self.gitmode == 'keep':
             for patchfn in patches:
                 patchf = self.opener(patchfn, 'r')
                 # if the patch was a git patch, refresh it as a git patch
                 for line in patchf:
                     if line.startswith('diff --git'):
                         diffopts.git = True
                         break
                 patchf.close()
         return diffopts
 
     def join(self, *p):
         return os.path.join(self.path, *p)
 
     def findseries(self, patch):
         def matchpatch(l):
             l = l.split('#', 1)[0]
             return l.strip() == patch
         for index, l in enumerate(self.fullseries):
             if matchpatch(l):
                 return index
         return None
 
     guard_re = re.compile(r'\s?#([-+][^-+# \t\r\n\f][^# \t\r\n\f]*)')
 
     def parseseries(self):
         self.series = []
         self.seriesguards = []
         for l in self.fullseries:
             h = l.find('#')
             if h == -1:
                 patch = l
                 comment = ''
             elif h == 0:
                 continue
             else:
                 patch = l[:h]
                 comment = l[h:]
             patch = patch.strip()
             if patch:
                 if patch in self.series:
                     raise util.Abort(_('%s appears more than once in %s') %
                                      (patch, self.join(self.seriespath)))
                 self.series.append(patch)
                 self.seriesguards.append(self.guard_re.findall(comment))
 
     def checkguard(self, guard):
         if not guard:
             return _('guard cannot be an empty string')
         bad_chars = '# \t\r\n\f'
         first = guard[0]
         if first in '-+':
             return (_('guard %r starts with invalid character: %r') %
                       (guard, first))
         for c in bad_chars:
             if c in guard:
                 return _('invalid character in guard %r: %r') % (guard, c)
 
     def setactive(self, guards):
         for guard in guards:
             bad = self.checkguard(guard)
             if bad:
                 raise util.Abort(bad)
         guards = sorted(set(guards))
         self.ui.debug('active guards: %s\n' % ' '.join(guards))
         self.activeguards = guards
         self.guardsdirty = True
 
     def active(self):
         if self.activeguards is None:
             self.activeguards = []
             try:
                 guards = self.opener.read(self.guardspath).split()
             except IOError, err:
                 if err.errno != errno.ENOENT:
                     raise
                 guards = []
             for i, guard in enumerate(guards):
                 bad = self.checkguard(guard)
                 if bad:
                     self.ui.warn('%s:%d: %s\n' %
                                  (self.join(self.guardspath), i + 1, bad))
                 else:
                     self.activeguards.append(guard)
         return self.activeguards
 
     def setguards(self, idx, guards):
         for g in guards:
             if len(g) < 2:
                 raise util.Abort(_('guard %r too short') % g)
             if g[0] not in '-+':
                 raise util.Abort(_('guard %r starts with invalid char') % g)
             bad = self.checkguard(g[1:])
             if bad:
                 raise util.Abort(bad)
         drop = self.guard_re.sub('', self.fullseries[idx])
         self.fullseries[idx] = drop + ''.join([' #' + g for g in guards])
         self.parseseries()
         self.seriesdirty = True
 
     def pushable(self, idx):
         if isinstance(idx, str):
             idx = self.series.index(idx)
         patchguards = self.seriesguards[idx]
         if not patchguards:
             return True, None
         guards = self.active()
         exactneg = [g for g in patchguards if g[0] == '-' and g[1:] in guards]
         if exactneg:
             return False, repr(exactneg[0])
         pos = [g for g in patchguards if g[0] == '+']
         exactpos = [g for g in pos if g[1:] in guards]
         if pos:
             if exactpos:
                 return True, repr(exactpos[0])
             return False, ' '.join(map(repr, pos))
         return True, ''
 
     def explainpushable(self, idx, all_patches=False):
         if all_patches:
             write = self.ui.write
         else:
             write = self.ui.warn
 
         if all_patches or self.ui.verbose:
             if isinstance(idx, str):
                 idx = self.series.index(idx)
             pushable, why = self.pushable(idx)
             if all_patches and pushable:
                 if why is None:
                     write(_('allowing %s - no guards in effect\n') %
                           self.series[idx])
                 else:
                     if not why:
                         write(_('allowing %s - no matching negative guards\n') %
                               self.series[idx])
                     else:
                         write(_('allowing %s - guarded by %s\n') %
                               (self.series[idx], why))
             if not pushable:
                 if why:
                     write(_('skipping %s - guarded by %s\n') %
                           (self.series[idx], why))
                 else:
                     write(_('skipping %s - no matching guards\n') %
                           self.series[idx])
 
     def savedirty(self):
         def writelist(items, path):
             fp = self.opener(path, 'w')
             for i in items:
                 fp.write("%s\n" % i)
             fp.close()
         if self.applieddirty:
             writelist(map(str, self.applied), self.statuspath)
             self.applieddirty = False
         if self.seriesdirty:
             writelist(self.fullseries, self.seriespath)
             self.seriesdirty = False
         if self.guardsdirty:
             writelist(self.activeguards, self.guardspath)
             self.guardsdirty = False
         if self.added:
             qrepo = self.qrepo()
             if qrepo:
                 qrepo[None].add(f for f in self.added if f not in qrepo[None])
             self.added = []
 
     def removeundo(self, repo):
         undo = repo.sjoin('undo')
         if not os.path.exists(undo):
             return
         try:
             os.unlink(undo)
         except OSError, inst:
             self.ui.warn(_('error removing undo: %s\n') % str(inst))
 
     def backup(self, repo, files, copy=False):
         # backup local changes in --force case
         for f in sorted(files):
             absf = repo.wjoin(f)
             if os.path.lexists(absf):
                 self.ui.note(_('saving current version of %s as %s\n') %
                              (f, f + '.orig'))
                 if copy:
                     util.copyfile(absf, absf + '.orig')
                 else:
                     util.rename(absf, absf + '.orig')
 
     def printdiff(self, repo, diffopts, node1, node2=None, files=None,
                   fp=None, changes=None, opts={}):
         stat = opts.get('stat')
         m = scmutil.match(repo[node1], files, opts)
         cmdutil.diffordiffstat(self.ui, repo, diffopts, node1, node2,  m,
                                changes, stat, fp)
 
     def mergeone(self, repo, mergeq, head, patch, rev, diffopts):
         # first try just applying the patch
         (err, n) = self.apply(repo, [patch], update_status=False,
                               strict=True, merge=rev)
 
         if err == 0:
             return (err, n)
 
         if n is None:
             raise util.Abort(_("apply failed for patch %s") % patch)
 
         self.ui.warn(_("patch didn't work out, merging %s\n") % patch)
 
         # apply failed, strip away that rev and merge.
         hg.clean(repo, head)
         strip(self.ui, repo, [n], update=False, backup=False)
 
         ctx = repo[rev]
         ret = hg.merge(repo, rev)
         if ret:
             raise util.Abort(_("update returned %d") % ret)
         n = newcommit(repo, None, ctx.description(), ctx.user(), force=True)
         if n is None:
             raise util.Abort(_("repo commit failed"))
         try:
             ph = patchheader(mergeq.join(patch), self.plainmode)
         except Exception:
             raise util.Abort(_("unable to read %s") % patch)
 
         diffopts = self.patchopts(diffopts, patch)
         patchf = self.opener(patch, "w")
         comments = str(ph)
         if comments:
             patchf.write(comments)
         self.printdiff(repo, diffopts, head, n, fp=patchf)
         patchf.close()
         self.removeundo(repo)
         return (0, n)
 
     def qparents(self, repo, rev=None):
         """return the mq handled parent or p1
 
         In some case where mq get himself in being the parent of a merge the
         appropriate parent may be p2.
         (eg: an in progress merge started with mq disabled)
 
         If no parent are managed by mq, p1 is returned.
         """
         if rev is None:
             (p1, p2) = repo.dirstate.parents()
             if p2 == nullid:
                 return p1
             if not self.applied:
                 return None
             return self.applied[-1].node
         p1, p2 = repo.changelog.parents(rev)
         if p2 != nullid and p2 in [x.node for x in self.applied]:
             return p2
         return p1
 
     def mergepatch(self, repo, mergeq, series, diffopts):
         if not self.applied:
             # each of the patches merged in will have two parents.  This
             # can confuse the qrefresh, qdiff, and strip code because it
             # needs to know which parent is actually in the patch queue.
             # so, we insert a merge marker with only one parent.  This way
             # the first patch in the queue is never a merge patch
             #
             pname = ".hg.patches.merge.marker"
             n = newcommit(repo, None, '[mq]: merge marker', force=True)
             self.removeundo(repo)
             self.applied.append(statusentry(n, pname))
             self.applieddirty = True
 
         head = self.qparents(repo)
 
         for patch in series:
             patch = mergeq.lookup(patch, strict=True)
             if not patch:
                 self.ui.warn(_("patch %s does not exist\n") % patch)
                 return (1, None)
             pushable, reason = self.pushable(patch)
             if not pushable:
                 self.explainpushable(patch, all_patches=True)
                 continue
             info = mergeq.isapplied(patch)
             if not info:
                 self.ui.warn(_("patch %s is not applied\n") % patch)
                 return (1, None)
             rev = info[1]
             err, head = self.mergeone(repo, mergeq, head, patch, rev, diffopts)
             if head:
                 self.applied.append(statusentry(head, patch))
                 self.applieddirty = True
             if err:
                 return (err, head)
         self.savedirty()
         return (0, head)
 
     def patch(self, repo, patchfile):
         '''Apply patchfile  to the working directory.
         patchfile: name of patch file'''
         files = set()
         try:
             fuzz = patchmod.patch(self.ui, repo, patchfile, strip=1,
                                   files=files, eolmode=None)
             return (True, list(files), fuzz)
         except Exception, inst:
             self.ui.note(str(inst) + '\n')
             if not self.ui.verbose:
                 self.ui.warn(_("patch failed, unable to continue (try -v)\n"))
             self.ui.traceback()
             return (False, list(files), False)
 
     def apply(self, repo, series, list=False, update_status=True,
               strict=False, patchdir=None, merge=None, all_files=None,
               tobackup=None, keepchanges=False):
         wlock = dsguard = lock = tr = None
         try:
             wlock = repo.wlock()
             dsguard = cmdutil.dirstateguard(repo, 'mq.apply')
             lock = repo.lock()
             tr = repo.transaction("qpush")
             try:
                 ret = self._apply(repo, series, list, update_status,
                                   strict, patchdir, merge, all_files=all_files,
                                   tobackup=tobackup, keepchanges=keepchanges)
                 tr.close()
                 self.savedirty()
                 dsguard.close()
                 return ret
             except AbortNoCleanup:
                 tr.close()
                 self.savedirty()
                 dsguard.close()
                 raise
             except: # re-raises
                 try:
                     tr.abort()
                 finally:
                     repo.invalidate()
                     self.invalidate()
                 raise
         finally:
             release(tr, lock, dsguard, wlock)
             self.removeundo(repo)
 
     def _apply(self, repo, series, list=False, update_status=True,
                strict=False, patchdir=None, merge=None, all_files=None,
                tobackup=None, keepchanges=False):
         """returns (error, hash)
 
         error = 1 for unable to read, 2 for patch failed, 3 for patch
         fuzz. tobackup is None or a set of files to backup before they
         are modified by a patch.
         """
         # TODO unify with commands.py
         if not patchdir:
             patchdir = self.path
         err = 0
         n = None
         for patchname in series:
             pushable, reason = self.pushable(patchname)
             if not pushable:
                 self.explainpushable(patchname, all_patches=True)
                 continue
             self.ui.status(_("applying %s\n") % patchname)
             pf = os.path.join(patchdir, patchname)
 
             try:
                 ph = patchheader(self.join(patchname), self.plainmode)
             except IOError:
                 self.ui.warn(_("unable to read %s\n") % patchname)
                 err = 1
                 break
 
             message = ph.message
             if not message:
                 # The commit message should not be translated
                 message = "imported patch %s\n" % patchname
             else:
                 if list:
                     # The commit message should not be translated
                     message.append("\nimported patch %s" % patchname)
                 message = '\n'.join(message)
 
             if ph.haspatch:
                 if tobackup:
                     touched = patchmod.changedfiles(self.ui, repo, pf)
                     touched = set(touched) & tobackup
                     if touched and keepchanges:
                         raise AbortNoCleanup(
                             _("conflicting local changes found"),
                             hint=_("did you forget to qrefresh?"))
                     self.backup(repo, touched, copy=True)
                     tobackup = tobackup - touched
                 (patcherr, files, fuzz) = self.patch(repo, pf)
                 if all_files is not None:
                     all_files.update(files)
                 patcherr = not patcherr
             else:
                 self.ui.warn(_("patch %s is empty\n") % patchname)
                 patcherr, files, fuzz = 0, [], 0
 
             if merge and files:
                 # Mark as removed/merged and update dirstate parent info
                 removed = []
                 merged = []
                 for f in files:
                     if os.path.lexists(repo.wjoin(f)):
                         merged.append(f)
                     else:
                         removed.append(f)
                 repo.dirstate.beginparentchange()
                 for f in removed:
                     repo.dirstate.remove(f)
                 for f in merged:
                     repo.dirstate.merge(f)
                 p1, p2 = repo.dirstate.parents()
                 repo.setparents(p1, merge)
                 repo.dirstate.endparentchange()
 
             if all_files and '.hgsubstate' in all_files:
                 wctx = repo[None]
                 pctx = repo['.']
                 overwrite = False
                 mergedsubstate = subrepo.submerge(repo, pctx, wctx, wctx,
                     overwrite)
                 files += mergedsubstate.keys()
 
             match = scmutil.matchfiles(repo, files or [])
             oldtip = repo['tip']
             n = newcommit(repo, None, message, ph.user, ph.date, match=match,
                           force=True)
             if repo['tip'] == oldtip:
                 raise util.Abort(_("qpush exactly duplicates child changeset"))
             if n is None:
                 raise util.Abort(_("repository commit failed"))
 
             if update_status:
                 self.applied.append(statusentry(n, patchname))
 
             if patcherr:
                 self.ui.warn(_("patch failed, rejects left in working "
                                "directory\n"))
                 err = 2
                 break
 
             if fuzz and strict:
                 self.ui.warn(_("fuzz found when applying patch, stopping\n"))
                 err = 3
                 break
         return (err, n)
 
     def _cleanup(self, patches, numrevs, keep=False):
         if not keep:
             r = self.qrepo()
             if r:
                 r[None].forget(patches)
             for p in patches:
                 try:
                     os.unlink(self.join(p))
                 except OSError, inst:
                     if inst.errno != errno.ENOENT:
                         raise
 
         qfinished = []
         if numrevs:
             qfinished = self.applied[:numrevs]
             del self.applied[:numrevs]
             self.applieddirty = True
 
         unknown = []
 
         for (i, p) in sorted([(self.findseries(p), p) for p in patches],
                              reverse=True):
             if i is not None:
                 del self.fullseries[i]
             else:
                 unknown.append(p)
 
         if unknown:
             if numrevs:
                 rev  = dict((entry.name, entry.node) for entry in qfinished)
                 for p in unknown:
                     msg = _('revision %s refers to unknown patches: %s\n')
                     self.ui.warn(msg % (short(rev[p]), p))
             else:
                 msg = _('unknown patches: %s\n')
                 raise util.Abort(''.join(msg % p for p in unknown))
 
         self.parseseries()
         self.seriesdirty = True
         return [entry.node for entry in qfinished]
 
     def _revpatches(self, repo, revs):
         firstrev = repo[self.applied[0].node].rev()
         patches = []
         for i, rev in enumerate(revs):
 
             if rev < firstrev:
                 raise util.Abort(_('revision %d is not managed') % rev)
 
             ctx = repo[rev]
             base = self.applied[i].node
             if ctx.node() != base:
                 msg = _('cannot delete revision %d above applied patches')
                 raise util.Abort(msg % rev)
 
             patch = self.applied[i].name
             for fmt in ('[mq]: %s', 'imported patch %s'):
                 if ctx.description() == fmt % patch:
                     msg = _('patch %s finalized without changeset message\n')
                     repo.ui.status(msg % patch)
                     break
 
             patches.append(patch)
         return patches
 
     def finish(self, repo, revs):
         # Manually trigger phase computation to ensure phasedefaults is
         # executed before we remove the patches.
         repo._phasecache
         patches = self._revpatches(repo, sorted(revs))
         qfinished = self._cleanup(patches, len(patches))
         if qfinished and repo.ui.configbool('mq', 'secret', False):
             # only use this logic when the secret option is added
             oldqbase = repo[qfinished[0]]
             tphase = repo.ui.config('phases', 'new-commit', phases.draft)
             if oldqbase.phase() > tphase and oldqbase.p1().phase() <= tphase:
                 tr = repo.transaction('qfinish')
                 try:
                     phases.advanceboundary(repo, tr, tphase, qfinished)
                     tr.close()
                 finally:
                     tr.release()
 
     def delete(self, repo, patches, opts):
         if not patches and not opts.get('rev'):
             raise util.Abort(_('qdelete requires at least one revision or '
                                'patch name'))
 
         realpatches = []
         for patch in patches:
             patch = self.lookup(patch, strict=True)
             info = self.isapplied(patch)
             if info:
                 raise util.Abort(_("cannot delete applied patch %s") % patch)
             if patch not in self.series:
                 raise util.Abort(_("patch %s not in series file") % patch)
             if patch not in realpatches:
                 realpatches.append(patch)
 
         numrevs = 0
         if opts.get('rev'):
             if not self.applied:
                 raise util.Abort(_('no patches applied'))
             revs = scmutil.revrange(repo, opts.get('rev'))
             revs.sort()
             revpatches = self._revpatches(repo, revs)
             realpatches += revpatches
             numrevs = len(revpatches)
 
         self._cleanup(realpatches, numrevs, opts.get('keep'))
 
     def checktoppatch(self, repo):
         '''check that working directory is at qtip'''
         if self.applied:
             top = self.applied[-1].node
             patch = self.applied[-1].name
             if repo.dirstate.p1() != top:
                 raise util.Abort(_("working directory revision is not qtip"))
             return top, patch
         return None, None
 
     def putsubstate2changes(self, substatestate, changes):
         for files in changes[:3]:
             if '.hgsubstate' in files:
                 return # already listed up
         # not yet listed up
         if substatestate in 'a?':
             changes[1].append('.hgsubstate')
         elif substatestate in 'r':
             changes[2].append('.hgsubstate')
         else: # modified
             changes[0].append('.hgsubstate')
 
     def checklocalchanges(self, repo, force=False, refresh=True):
         excsuffix = ''
         if refresh:
             excsuffix = ', refresh first'
             # plain versions for i18n tool to detect them
             _("local changes found, refresh first")
             _("local changed subrepos found, refresh first")
         return checklocalchanges(repo, force, excsuffix)
 
     _reserved = ('series', 'status', 'guards', '.', '..')
     def checkreservedname(self, name):
         if name in self._reserved:
             raise util.Abort(_('"%s" cannot be used as the name of a patch')
                              % name)
         for prefix in ('.hg', '.mq'):
             if name.startswith(prefix):
                 raise util.Abort(_('patch name cannot begin with "%s"')
                                  % prefix)
         for c in ('#', ':'):
             if c in name:
                 raise util.Abort(_('"%s" cannot be used in the name of a patch')
                                  % c)
 
     def checkpatchname(self, name, force=False):
         self.checkreservedname(name)
         if not force and os.path.exists(self.join(name)):
             if os.path.isdir(self.join(name)):
                 raise util.Abort(_('"%s" already exists as a directory')
                                  % name)
             else:
                 raise util.Abort(_('patch "%s" already exists') % name)
 
     def checkkeepchanges(self, keepchanges, force):
         if force and keepchanges:
             raise util.Abort(_('cannot use both --force and --keep-changes'))
 
     def new(self, repo, patchfn, *pats, **opts):
         """options:
            msg: a string or a no-argument function returning a string
         """
         msg = opts.get('msg')
         edit = opts.get('edit')
         editform = opts.get('editform', 'mq.qnew')
         user = opts.get('user')
         date = opts.get('date')
         if date:
             date = util.parsedate(date)
         diffopts = self.diffopts({'git': opts.get('git')})
         if opts.get('checkname', True):
             self.checkpatchname(patchfn)
         inclsubs = checksubstate(repo)
         if inclsubs:
             substatestate = repo.dirstate['.hgsubstate']
         if opts.get('include') or opts.get('exclude') or pats:
             match = scmutil.match(repo[None], pats, opts)
             # detect missing files in pats
             def badfn(f, msg):
                 if f != '.hgsubstate': # .hgsubstate is auto-created
                     raise util.Abort('%s: %s' % (f, msg))
             match.bad = badfn
             changes = repo.status(match=match)
         else:
             changes = self.checklocalchanges(repo, force=True)
         commitfiles = list(inclsubs)
         for files in changes[:3]:
             commitfiles.extend(files)
         match = scmutil.matchfiles(repo, commitfiles)
         if len(repo[None].parents()) > 1:
             raise util.Abort(_('cannot manage merge changesets'))
         self.checktoppatch(repo)
         insert = self.fullseriesend()
         wlock = repo.wlock()
         try:
             try:
                 # if patch file write fails, abort early
                 p = self.opener(patchfn, "w")
             except IOError, e:
                 raise util.Abort(_('cannot write patch "%s": %s')
                                  % (patchfn, e.strerror))
             try:
                 defaultmsg = "[mq]: %s" % patchfn
                 editor = cmdutil.getcommiteditor(editform=editform)
                 if edit:
                     def finishdesc(desc):
                         if desc.rstrip():
                             return desc
                         else:
                             return defaultmsg
                     # i18n: this message is shown in editor with "HG: " prefix
                     extramsg = _('Leave message empty to use default message.')
                     editor = cmdutil.getcommiteditor(finishdesc=finishdesc,
                                                      extramsg=extramsg,
                                                      editform=editform)
                     commitmsg = msg
                 else:
                     commitmsg = msg or defaultmsg
 
                 n = newcommit(repo, None, commitmsg, user, date, match=match,
                               force=True, editor=editor)
                 if n is None:
                     raise util.Abort(_("repo commit failed"))
                 try:
                     self.fullseries[insert:insert] = [patchfn]
                     self.applied.append(statusentry(n, patchfn))
                     self.parseseries()
                     self.seriesdirty = True
                     self.applieddirty = True
                     nctx = repo[n]
                     ph = patchheader(self.join(patchfn), self.plainmode)
                     if user:
                         ph.setuser(user)
                     if date:
                         ph.setdate('%s %s' % date)
                     ph.setparent(hex(nctx.p1().node()))
                     msg = nctx.description().strip()
                     if msg == defaultmsg.strip():
                         msg = ''
                     ph.setmessage(msg)
                     p.write(str(ph))
                     if commitfiles:
                         parent = self.qparents(repo, n)
                         if inclsubs:
                             self.putsubstate2changes(substatestate, changes)
                         chunks = patchmod.diff(repo, node1=parent, node2=n,
                                                changes=changes, opts=diffopts)
                         for chunk in chunks:
                             p.write(chunk)
                     p.close()
                     r = self.qrepo()
                     if r:
                         r[None].add([patchfn])
                 except: # re-raises
                     repo.rollback()
                     raise
             except Exception:
                 patchpath = self.join(patchfn)
                 try:
                     os.unlink(patchpath)
                 except OSError:
                     self.ui.warn(_('error unlinking %s\n') % patchpath)
                 raise
             self.removeundo(repo)
         finally:
             release(wlock)
 
     def isapplied(self, patch):
         """returns (index, rev, patch)"""
         for i, a in enumerate(self.applied):
             if a.name == patch:
                 return (i, a.node, a.name)
         return None
 
     # if the exact patch name does not exist, we try a few
     # variations.  If strict is passed, we try only #1
     #
     # 1) a number (as string) to indicate an offset in the series file
     # 2) a unique substring of the patch name was given
     # 3) patchname[-+]num to indicate an offset in the series file
     def lookup(self, patch, strict=False):
         def partialname(s):
             if s in self.series:
                 return s
             matches = [x for x in self.series if s in x]
             if len(matches) > 1:
                 self.ui.warn(_('patch name "%s" is ambiguous:\n') % s)
                 for m in matches:
                     self.ui.warn('  %s\n' % m)
                 return None
             if matches:
                 return matches[0]
             if self.series and self.applied:
                 if s == 'qtip':
                     return self.series[self.seriesend(True) - 1]
                 if s == 'qbase':
                     return self.series[0]
             return None
 
         if patch in self.series:
             return patch
 
         if not os.path.isfile(self.join(patch)):
             try:
                 sno = int(patch)
             except (ValueError, OverflowError):
                 pass
             else:
                 if -len(self.series) <= sno < len(self.series):
                     return self.series[sno]
 
             if not strict:
                 res = partialname(patch)
                 if res:
                     return res
                 minus = patch.rfind('-')
                 if minus >= 0:
                     res = partialname(patch[:minus])
                     if res:
                         i = self.series.index(res)
                         try:
                             off = int(patch[minus + 1:] or 1)
                         except (ValueError, OverflowError):
                             pass
                         else:
                             if i - off >= 0:
                                 return self.series[i - off]
                 plus = patch.rfind('+')
                 if plus >= 0:
                     res = partialname(patch[:plus])
                     if res:
                         i = self.series.index(res)
                         try:
                             off = int(patch[plus + 1:] or 1)
                         except (ValueError, OverflowError):
                             pass
                         else:
                             if i + off < len(self.series):
                                 return self.series[i + off]
         raise util.Abort(_("patch %s not in series") % patch)
 
     def push(self, repo, patch=None, force=False, list=False, mergeq=None,
              all=False, move=False, exact=False, nobackup=False,
              keepchanges=False):
         self.checkkeepchanges(keepchanges, force)
         diffopts = self.diffopts()
         wlock = repo.wlock()
         try:
             heads = []
             for hs in repo.branchmap().itervalues():
                 heads.extend(hs)
             if not heads:
                 heads = [nullid]
             if repo.dirstate.p1() not in heads and not exact:
                 self.ui.status(_("(working directory not at a head)\n"))
 
             if not self.series:
                 self.ui.warn(_('no patches in series\n'))
                 return 0
 
             # Suppose our series file is: A B C and the current 'top'
             # patch is B. qpush C should be performed (moving forward)
             # qpush B is a NOP (no change) qpush A is an error (can't
             # go backwards with qpush)
             if patch:
                 patch = self.lookup(patch)
                 info = self.isapplied(patch)
                 if info and info[0] >= len(self.applied) - 1:
                     self.ui.warn(
                         _('qpush: %s is already at the top\n') % patch)
                     return 0
 
                 pushable, reason = self.pushable(patch)
                 if pushable:
                     if self.series.index(patch) < self.seriesend():
                         raise util.Abort(
                             _("cannot push to a previous patch: %s") % patch)
                 else:
                     if reason:
                         reason = _('guarded by %s') % reason
                     else:
                         reason = _('no matching guards')
                     self.ui.warn(_("cannot push '%s' - %s\n") % (patch, reason))
                     return 1
             elif all:
                 patch = self.series[-1]
                 if self.isapplied(patch):
                     self.ui.warn(_('all patches are currently applied\n'))
                     return 0
 
             # Following the above example, starting at 'top' of B:
             # qpush should be performed (pushes C), but a subsequent
             # qpush without an argument is an error (nothing to
             # apply). This allows a loop of "...while hg qpush..." to
             # work as it detects an error when done
             start = self.seriesend()
             if start == len(self.series):
                 self.ui.warn(_('patch series already fully applied\n'))
                 return 1
             if not force and not keepchanges:
                 self.checklocalchanges(repo, refresh=self.applied)
 
             if exact:
                 if keepchanges:
                     raise util.Abort(
                         _("cannot use --exact and --keep-changes together"))
                 if move:
                     raise util.Abort(_('cannot use --exact and --move '
                                        'together'))
                 if self.applied:
                     raise util.Abort(_('cannot push --exact with applied '
                                        'patches'))
                 root = self.series[start]
                 target = patchheader(self.join(root), self.plainmode).parent
                 if not target:
                     raise util.Abort(
                         _("%s does not have a parent recorded") % root)
                 if not repo[target] == repo['.']:
                     hg.update(repo, target)
 
             if move:
                 if not patch:
                     raise util.Abort(_("please specify the patch to move"))
                 for fullstart, rpn in enumerate(self.fullseries):
                     # strip markers for patch guards
                     if self.guard_re.split(rpn, 1)[0] == self.series[start]:
                         break
                 for i, rpn in enumerate(self.fullseries[fullstart:]):
                     # strip markers for patch guards
                     if self.guard_re.split(rpn, 1)[0] == patch:
                         break
                 index = fullstart + i
                 assert index < len(self.fullseries)
                 fullpatch = self.fullseries[index]
                 del self.fullseries[index]
                 self.fullseries.insert(fullstart, fullpatch)
                 self.parseseries()
                 self.seriesdirty = True
 
             self.applieddirty = True
             if start > 0:
                 self.checktoppatch(repo)
             if not patch:
                 patch = self.series[start]
                 end = start + 1
             else:
                 end = self.series.index(patch, start) + 1
 
             tobackup = set()
             if (not nobackup and force) or keepchanges:
                 status = self.checklocalchanges(repo, force=True)
                 if keepchanges:
                     tobackup.update(status.modified + status.added +
                                     status.removed + status.deleted)
                 else:
                     tobackup.update(status.modified + status.added)
 
             s = self.series[start:end]
             all_files = set()
             try:
                 if mergeq:
                     ret = self.mergepatch(repo, mergeq, s, diffopts)
                 else:
                     ret = self.apply(repo, s, list, all_files=all_files,
                                      tobackup=tobackup, keepchanges=keepchanges)
             except AbortNoCleanup:
                 raise
             except: # re-raises
                 self.ui.warn(_('cleaning up working directory...'))
                 node = repo.dirstate.p1()
                 hg.revert(repo, node, None)
                 # only remove unknown files that we know we touched or
                 # created while patching
                 for f in all_files:
                     if f not in repo.dirstate:
                         util.unlinkpath(repo.wjoin(f), ignoremissing=True)
                 self.ui.warn(_('done\n'))
                 raise
 
             if not self.applied:
                 return ret[0]
             top = self.applied[-1].name
             if ret[0] and ret[0] > 1:
                 msg = _("errors during apply, please fix and refresh %s\n")
                 self.ui.write(msg % top)
             else:
                 self.ui.write(_("now at: %s\n") % top)
             return ret[0]
 
         finally:
             wlock.release()
 
     def pop(self, repo, patch=None, force=False, update=True, all=False,
             nobackup=False, keepchanges=False):
         self.checkkeepchanges(keepchanges, force)
         wlock = repo.wlock()
         try:
             if patch:
                 # index, rev, patch
                 info = self.isapplied(patch)
                 if not info:
                     patch = self.lookup(patch)
                 info = self.isapplied(patch)
                 if not info:
                     raise util.Abort(_("patch %s is not applied") % patch)
 
             if not self.applied:
                 # Allow qpop -a to work repeatedly,
                 # but not qpop without an argument
                 self.ui.warn(_("no patches applied\n"))
                 return not all
 
             if all:
                 start = 0
             elif patch:
                 start = info[0] + 1
             else:
                 start = len(self.applied) - 1
 
             if start >= len(self.applied):
                 self.ui.warn(_("qpop: %s is already at the top\n") % patch)
                 return
 
             if not update:
                 parents = repo.dirstate.parents()
                 rr = [x.node for x in self.applied]
                 for p in parents:
                     if p in rr:
                         self.ui.warn(_("qpop: forcing dirstate update\n"))
                         update = True
             else:
                 parents = [p.node() for p in repo[None].parents()]
                 needupdate = False
                 for entry in self.applied[start:]:
                     if entry.node in parents:
                         needupdate = True
                         break
                 update = needupdate
 
             tobackup = set()
             if update:
                 s = self.checklocalchanges(repo, force=force or keepchanges)
                 if force:
                     if not nobackup:
                         tobackup.update(s.modified + s.added)
                 elif keepchanges:
                     tobackup.update(s.modified + s.added +
                                     s.removed + s.deleted)
 
             self.applieddirty = True
             end = len(self.applied)
             rev = self.applied[start].node
 
             try:
                 heads = repo.changelog.heads(rev)
             except error.LookupError:
                 node = short(rev)
                 raise util.Abort(_('trying to pop unknown node %s') % node)
 
             if heads != [self.applied[-1].node]:
                 raise util.Abort(_("popping would remove a revision not "
                                    "managed by this patch queue"))
             if not repo[self.applied[-1].node].mutable():
                 raise util.Abort(
                     _("popping would remove an immutable revision"),
                     hint=_('see "hg help phases" for details'))
 
             # we know there are no local changes, so we can make a simplified
             # form of hg.update.
             if update:
                 qp = self.qparents(repo, rev)
                 ctx = repo[qp]
                 m, a, r, d = repo.status(qp, '.')[:4]
                 if d:
                     raise util.Abort(_("deletions found between repo revs"))
 
                 tobackup = set(a + m + r) & tobackup
                 if keepchanges and tobackup:
                     raise util.Abort(_("local changes found, refresh first"))
                 self.backup(repo, tobackup)
                 repo.dirstate.beginparentchange()
                 for f in a:
                     util.unlinkpath(repo.wjoin(f), ignoremissing=True)
                     repo.dirstate.drop(f)
                 for f in m + r:
                     fctx = ctx[f]
                     repo.wwrite(f, fctx.data(), fctx.flags())
                     repo.dirstate.normal(f)
                 repo.setparents(qp, nullid)
                 repo.dirstate.endparentchange()
             for patch in reversed(self.applied[start:end]):
                 self.ui.status(_("popping %s\n") % patch.name)
             del self.applied[start:end]
             strip(self.ui, repo, [rev], update=False, backup=False)
             for s, state in repo['.'].substate.items():
                 repo['.'].sub(s).get(state)
             if self.applied:
                 self.ui.write(_("now at: %s\n") % self.applied[-1].name)
             else:
                 self.ui.write(_("patch queue now empty\n"))
         finally:
             wlock.release()
 
     def diff(self, repo, pats, opts):
         top, patch = self.checktoppatch(repo)
         if not top:
             self.ui.write(_("no patches applied\n"))
             return
         qp = self.qparents(repo, top)
         if opts.get('reverse'):
             node1, node2 = None, qp
         else:
             node1, node2 = qp, None
         diffopts = self.diffopts(opts, patch)
         self.printdiff(repo, diffopts, node1, node2, files=pats, opts=opts)
 
     def refresh(self, repo, pats=None, **opts):
         if not self.applied:
             self.ui.write(_("no patches applied\n"))
             return 1
         msg = opts.get('msg', '').rstrip()
         edit = opts.get('edit')
         editform = opts.get('editform', 'mq.qrefresh')
         newuser = opts.get('user')
         newdate = opts.get('date')
         if newdate:
             newdate = '%d %d' % util.parsedate(newdate)
         wlock = repo.wlock()
 
         try:
             self.checktoppatch(repo)
             (top, patchfn) = (self.applied[-1].node, self.applied[-1].name)
             if repo.changelog.heads(top) != [top]:
                 raise util.Abort(_("cannot refresh a revision with children"))
             if not repo[top].mutable():
                 raise util.Abort(_("cannot refresh immutable revision"),
                                  hint=_('see "hg help phases" for details'))
 
             cparents = repo.changelog.parents(top)
             patchparent = self.qparents(repo, top)
 
             inclsubs = checksubstate(repo, hex(patchparent))
             if inclsubs:
                 substatestate = repo.dirstate['.hgsubstate']
 
             ph = patchheader(self.join(patchfn), self.plainmode)
             diffopts = self.diffopts({'git': opts.get('git')}, patchfn)
             if newuser:
                 ph.setuser(newuser)
             if newdate:
                 ph.setdate(newdate)
             ph.setparent(hex(patchparent))
 
             # only commit new patch when write is complete
             patchf = self.opener(patchfn, 'w', atomictemp=True)
 
             # update the dirstate in place, strip off the qtip commit
             # and then commit.
             #
             # this should really read:
             #   mm, dd, aa = repo.status(top, patchparent)[:3]
             # but we do it backwards to take advantage of manifest/changelog
             # caching against the next repo.status call
             mm, aa, dd = repo.status(patchparent, top)[:3]
             changes = repo.changelog.read(top)
             man = repo.manifest.read(changes[0])
             aaa = aa[:]
             matchfn = scmutil.match(repo[None], pats, opts)
             # in short mode, we only diff the files included in the
             # patch already plus specified files
             if opts.get('short'):
                 # if amending a patch, we start with existing
                 # files plus specified files - unfiltered
                 match = scmutil.matchfiles(repo, mm + aa + dd + matchfn.files())
                 # filter with include/exclude options
                 matchfn = scmutil.match(repo[None], opts=opts)
             else:
                 match = scmutil.matchall(repo)
             m, a, r, d = repo.status(match=match)[:4]
             mm = set(mm)
             aa = set(aa)
             dd = set(dd)
 
             # we might end up with files that were added between
             # qtip and the dirstate parent, but then changed in the
             # local dirstate. in this case, we want them to only
             # show up in the added section
             for x in m:
                 if x not in aa:
                     mm.add(x)
             # we might end up with files added by the local dirstate that
             # were deleted by the patch.  In this case, they should only
             # show up in the changed section.
             for x in a:
                 if x in dd:
                     dd.remove(x)
                     mm.add(x)
                 else:
                     aa.add(x)
             # make sure any files deleted in the local dirstate
             # are not in the add or change column of the patch
             forget = []
             for x in d + r:
                 if x in aa:
                     aa.remove(x)
                     forget.append(x)
                     continue
                 else:
                     mm.discard(x)
                 dd.add(x)
 
             m = list(mm)
             r = list(dd)
             a = list(aa)
 
             # create 'match' that includes the files to be recommitted.
             # apply matchfn via repo.status to ensure correct case handling.
             cm, ca, cr, cd = repo.status(patchparent, match=matchfn)[:4]
             allmatches = set(cm + ca + cr + cd)
             refreshchanges = [x.intersection(allmatches) for x in (mm, aa, dd)]
 
             files = set(inclsubs)
             for x in refreshchanges:
                 files.update(x)
             match = scmutil.matchfiles(repo, files)
 
             bmlist = repo[top].bookmarks()
 
             dsguard = None
             try:
                 dsguard = cmdutil.dirstateguard(repo, 'mq.refresh')
                 if diffopts.git or diffopts.upgrade:
                     copies = {}
                     for dst in a:
                         src = repo.dirstate.copied(dst)
                         # during qfold, the source file for copies may
                         # be removed. Treat this as a simple add.
                         if src is not None and src in repo.dirstate:
                             copies.setdefault(src, []).append(dst)
                         repo.dirstate.add(dst)
                     # remember the copies between patchparent and qtip
                     for dst in aaa:
                         f = repo.file(dst)
                         src = f.renamed(man[dst])
                         if src:
                             copies.setdefault(src[0], []).extend(
                                 copies.get(dst, []))
                             if dst in a:
                                 copies[src[0]].append(dst)
                         # we can't copy a file created by the patch itself
                         if dst in copies:
                             del copies[dst]
                     for src, dsts in copies.iteritems():
                         for dst in dsts:
                             repo.dirstate.copy(src, dst)
                 else:
                     for dst in a:
                         repo.dirstate.add(dst)
                     # Drop useless copy information
                     for f in list(repo.dirstate.copies()):
                         repo.dirstate.copy(None, f)
                 for f in r:
                     repo.dirstate.remove(f)
                 # if the patch excludes a modified file, mark that
                 # file with mtime=0 so status can see it.
                 mm = []
                 for i in xrange(len(m) - 1, -1, -1):
                     if not matchfn(m[i]):
                         mm.append(m[i])
                         del m[i]
                 for f in m:
                     repo.dirstate.normal(f)
                 for f in mm:
                     repo.dirstate.normallookup(f)
                 for f in forget:
                     repo.dirstate.drop(f)
 
                 user = ph.user or changes[1]
 
                 oldphase = repo[top].phase()
 
                 # assumes strip can roll itself back if interrupted
                 repo.setparents(*cparents)
                 self.applied.pop()
                 self.applieddirty = True
                 strip(self.ui, repo, [top], update=False, backup=False)
                 dsguard.close()
             finally:
                 release(dsguard)
 
             try:
                 # might be nice to attempt to roll back strip after this
 
                 defaultmsg = "[mq]: %s" % patchfn
                 editor = cmdutil.getcommiteditor(editform=editform)
                 if edit:
                     def finishdesc(desc):
                         if desc.rstrip():
                             ph.setmessage(desc)
                             return desc
                         return defaultmsg
                     # i18n: this message is shown in editor with "HG: " prefix
                     extramsg = _('Leave message empty to use default message.')
                     editor = cmdutil.getcommiteditor(finishdesc=finishdesc,
                                                      extramsg=extramsg,
                                                      editform=editform)
                     message = msg or "\n".join(ph.message)
                 elif not msg:
                     if not ph.message:
                         message = defaultmsg
                     else:
                         message = "\n".join(ph.message)
                 else:
                     message = msg
                     ph.setmessage(msg)
 
                 # Ensure we create a new changeset in the same phase than
                 # the old one.
                 n = newcommit(repo, oldphase, message, user, ph.date,
                               match=match, force=True, editor=editor)
                 # only write patch after a successful commit
                 c = [list(x) for x in refreshchanges]
                 if inclsubs:
                     self.putsubstate2changes(substatestate, c)
                 chunks = patchmod.diff(repo, patchparent,
                                        changes=c, opts=diffopts)
                 comments = str(ph)
                 if comments:
                     patchf.write(comments)
                 for chunk in chunks:
                     patchf.write(chunk)
                 patchf.close()
 
                 marks = repo._bookmarks
                 for bm in bmlist:
                     marks[bm] = n
                 marks.write()
 
                 self.applied.append(statusentry(n, patchfn))
             except: # re-raises
                 ctx = repo[cparents[0]]
                 repo.dirstate.rebuild(ctx.node(), ctx.manifest())
                 self.savedirty()
                 self.ui.warn(_('refresh interrupted while patch was popped! '
                                '(revert --all, qpush to recover)\n'))
                 raise
         finally:
             wlock.release()
             self.removeundo(repo)
 
     def init(self, repo, create=False):
         if not create and os.path.isdir(self.path):
             raise util.Abort(_("patch queue directory already exists"))
         try:
             os.mkdir(self.path)
         except OSError, inst:
             if inst.errno != errno.EEXIST or not create:
                 raise
         if create:
             return self.qrepo(create=True)
 
     def unapplied(self, repo, patch=None):
         if patch and patch not in self.series:
             raise util.Abort(_("patch %s is not in series file") % patch)
         if not patch:
             start = self.seriesend()
         else:
             start = self.series.index(patch) + 1
         unapplied = []
         for i in xrange(start, len(self.series)):
             pushable, reason = self.pushable(i)
             if pushable:
                 unapplied.append((i, self.series[i]))
             self.explainpushable(i)
         return unapplied
 
     def qseries(self, repo, missing=None, start=0, length=None, status=None,
                 summary=False):
         def displayname(pfx, patchname, state):
             if pfx:
                 self.ui.write(pfx)
             if summary:
                 ph = patchheader(self.join(patchname), self.plainmode)
                 if ph.message:
                     msg = ph.message[0]
                 else:
                     msg = ''
 
                 if self.ui.formatted():
                     width = self.ui.termwidth() - len(pfx) - len(patchname) - 2
                     if width > 0:
                         msg = util.ellipsis(msg, width)
                     else:
                         msg = ''
                 self.ui.write(patchname, label='qseries.' + state)
                 self.ui.write(': ')
                 self.ui.write(msg, label='qseries.message.' + state)
             else:
                 self.ui.write(patchname, label='qseries.' + state)
             self.ui.write('\n')
 
         applied = set([p.name for p in self.applied])
         if length is None:
             length = len(self.series) - start
         if not missing:
             if self.ui.verbose:
                 idxwidth = len(str(start + length - 1))
             for i in xrange(start, start + length):
                 patch = self.series[i]
                 if patch in applied:
                     char, state = 'A', 'applied'
                 elif self.pushable(i)[0]:
                     char, state = 'U', 'unapplied'
                 else:
                     char, state = 'G', 'guarded'
                 pfx = ''
                 if self.ui.verbose:
                     pfx = '%*d %s ' % (idxwidth, i, char)
                 elif status and status != char:
                     continue
                 displayname(pfx, patch, state)
         else:
             msng_list = []
             for root, dirs, files in os.walk(self.path):
                 d = root[len(self.path) + 1:]
                 for f in files:
                     fl = os.path.join(d, f)
                     if (fl not in self.series and
                         fl not in (self.statuspath, self.seriespath,
                                    self.guardspath)
                         and not fl.startswith('.')):
                         msng_list.append(fl)
             for x in sorted(msng_list):
                 pfx = self.ui.verbose and ('D ') or ''
                 displayname(pfx, x, 'missing')
 
     def issaveline(self, l):
         if l.name == '.hg.patches.save.line':
             return True
 
     def qrepo(self, create=False):
         ui = self.baseui.copy()
         if create or os.path.isdir(self.join(".hg")):
             return hg.repository(ui, path=self.path, create=create)
 
     def restore(self, repo, rev, delete=None, qupdate=None):
         desc = repo[rev].description().strip()
         lines = desc.splitlines()
         i = 0
         datastart = None
         series = []
         applied = []
         qpp = None
         for i, line in enumerate(lines):
             if line == 'Patch Data:':
                 datastart = i + 1
             elif line.startswith('Dirstate:'):
                 l = line.rstrip()
                 l = l[10:].split(' ')
                 qpp = [bin(x) for x in l]
             elif datastart is not None:
                 l = line.rstrip()
                 n, name = l.split(':', 1)
                 if n:
                     applied.append(statusentry(bin(n), name))
                 else:
                     series.append(l)
         if datastart is None:
             self.ui.warn(_("no saved patch data found\n"))
             return 1
         self.ui.warn(_("restoring status: %s\n") % lines[0])
         self.fullseries = series
         self.applied = applied
         self.parseseries()
         self.seriesdirty = True
         self.applieddirty = True
         heads = repo.changelog.heads()
         if delete:
             if rev not in heads:
                 self.ui.warn(_("save entry has children, leaving it alone\n"))
             else:
                 self.ui.warn(_("removing save entry %s\n") % short(rev))
                 pp = repo.dirstate.parents()
                 if rev in pp:
                     update = True
                 else:
                     update = False
                 strip(self.ui, repo, [rev], update=update, backup=False)
         if qpp:
             self.ui.warn(_("saved queue repository parents: %s %s\n") %
                          (short(qpp[0]), short(qpp[1])))
             if qupdate:
                 self.ui.status(_("updating queue directory\n"))
                 r = self.qrepo()
                 if not r:
                     self.ui.warn(_("unable to load queue repository\n"))
                     return 1
                 hg.clean(r, qpp[0])
 
     def save(self, repo, msg=None):
         if not self.applied:
             self.ui.warn(_("save: no patches applied, exiting\n"))
             return 1
         if self.issaveline(self.applied[-1]):
             self.ui.warn(_("status is already saved\n"))
             return 1
 
         if not msg:
             msg = _("hg patches saved state")
         else:
             msg = "hg patches: " + msg.rstrip('\r\n')
         r = self.qrepo()
         if r:
             pp = r.dirstate.parents()
             msg += "\nDirstate: %s %s" % (hex(pp[0]), hex(pp[1]))
         msg += "\n\nPatch Data:\n"
         msg += ''.join('%s\n' % x for x in self.applied)
         msg += ''.join(':%s\n' % x for x in self.fullseries)
         n = repo.commit(msg, force=True)
         if not n:
             self.ui.warn(_("repo commit failed\n"))
             return 1
         self.applied.append(statusentry(n, '.hg.patches.save.line'))
         self.applieddirty = True
         self.removeundo(repo)
 
     def fullseriesend(self):
         if self.applied:
             p = self.applied[-1].name
             end = self.findseries(p)
             if end is None:
                 return len(self.fullseries)
             return end + 1
         return 0
 
     def seriesend(self, all_patches=False):
         """If all_patches is False, return the index of the next pushable patch
         in the series, or the series length. If all_patches is True, return the
         index of the first patch past the last applied one.
         """
         end = 0
         def nextpatch(start):
             if all_patches or start >= len(self.series):
                 return start
             for i in xrange(start, len(self.series)):
                 p, reason = self.pushable(i)
                 if p:
                     return i
                 self.explainpushable(i)
             return len(self.series)
         if self.applied:
             p = self.applied[-1].name
             try:
                 end = self.series.index(p)
             except ValueError:
                 return 0
             return nextpatch(end + 1)
         return nextpatch(end)
 
     def appliedname(self, index):
         pname = self.applied[index].name
         if not self.ui.verbose:
             p = pname
         else:
             p = str(self.series.index(pname)) + " " + pname
         return p
 
     def qimport(self, repo, files, patchname=None, rev=None, existing=None,
                 force=None, git=False):
         def checkseries(patchname):
             if patchname in self.series:
                 raise util.Abort(_('patch %s is already in the series file')
                                  % patchname)
 
         if rev:
             if files:
                 raise util.Abort(_('option "-r" not valid when importing '
                                    'files'))
             rev = scmutil.revrange(repo, rev)
             rev.sort(reverse=True)
         elif not files:
             raise util.Abort(_('no files or revisions specified'))
         if (len(files) > 1 or len(rev) > 1) and patchname:
             raise util.Abort(_('option "-n" not valid when importing multiple '
                                'patches'))
         imported = []
         if rev:
             # If mq patches are applied, we can only import revisions
             # that form a linear path to qbase.
             # Otherwise, they should form a linear path to a head.
             heads = repo.changelog.heads(repo.changelog.node(rev.first()))
             if len(heads) > 1:
                 raise util.Abort(_('revision %d is the root of more than one '
                                    'branch') % rev.last())
             if self.applied:
                 base = repo.changelog.node(rev.first())
                 if base in [n.node for n in self.applied]:
                     raise util.Abort(_('revision %d is already managed')
                                      % rev.first())
                 if heads != [self.applied[-1].node]:
                     raise util.Abort(_('revision %d is not the parent of '
                                        'the queue') % rev.first())
                 base = repo.changelog.rev(self.applied[0].node)
                 lastparent = repo.changelog.parentrevs(base)[0]
             else:
                 if heads != [repo.changelog.node(rev.first())]:
                     raise util.Abort(_('revision %d has unmanaged children')
                                      % rev.first())
                 lastparent = None
 
             diffopts = self.diffopts({'git': git})
             tr = repo.transaction('qimport')
             try:
                 for r in rev:
                     if not repo[r].mutable():
                         raise util.Abort(_('revision %d is not mutable') % r,
                                          hint=_('see "hg help phases" '
                                                 'for details'))
                     p1, p2 = repo.changelog.parentrevs(r)
                     n = repo.changelog.node(r)
                     if p2 != nullrev:
                         raise util.Abort(_('cannot import merge revision %d')
                                          % r)
                     if lastparent and lastparent != r:
                         raise util.Abort(_('revision %d is not the parent of '
                                            '%d')
                                          % (r, lastparent))
                     lastparent = p1
 
                     if not patchname:
                         patchname = normname('%d.diff' % r)
                     checkseries(patchname)
                     self.checkpatchname(patchname, force)
                     self.fullseries.insert(0, patchname)
 
                     patchf = self.opener(patchname, "w")
                     cmdutil.export(repo, [n], fp=patchf, opts=diffopts)
                     patchf.close()
 
                     se = statusentry(n, patchname)
                     self.applied.insert(0, se)
 
                     self.added.append(patchname)
                     imported.append(patchname)
                     patchname = None
                     if rev and repo.ui.configbool('mq', 'secret', False):
                         # if we added anything with --rev, move the secret root
                         phases.retractboundary(repo, tr, phases.secret, [n])
                     self.parseseries()
                     self.applieddirty = True
                     self.seriesdirty = True
                 tr.close()
             finally:
                 tr.release()
 
         for i, filename in enumerate(files):
             if existing:
                 if filename == '-':
                     raise util.Abort(_('-e is incompatible with import from -'))
                 filename = normname(filename)
                 self.checkreservedname(filename)
                 if util.url(filename).islocal():
                     originpath = self.join(filename)
                     if not os.path.isfile(originpath):
                         raise util.Abort(
                             _("patch %s does not exist") % filename)
 
                 if patchname:
                     self.checkpatchname(patchname, force)
 
                     self.ui.write(_('renaming %s to %s\n')
                                         % (filename, patchname))
                     util.rename(originpath, self.join(patchname))
                 else:
                     patchname = filename
 
             else:
                 if filename == '-' and not patchname:
                     raise util.Abort(_('need --name to import a patch from -'))
                 elif not patchname:
                     patchname = normname(os.path.basename(filename.rstrip('/')))
                 self.checkpatchname(patchname, force)
                 try:
                     if filename == '-':
                         text = self.ui.fin.read()
                     else:
                         fp = hg.openpath(self.ui, filename)
                         text = fp.read()
                         fp.close()
                 except (OSError, IOError):
                     raise util.Abort(_("unable to read file %s") % filename)
                 patchf = self.opener(patchname, "w")
                 patchf.write(text)
                 patchf.close()
             if not force:
                 checkseries(patchname)
             if patchname not in self.series:
                 index = self.fullseriesend() + i
                 self.fullseries[index:index] = [patchname]
             self.parseseries()
             self.seriesdirty = True
             self.ui.warn(_("adding %s to series file\n") % patchname)
             self.added.append(patchname)
             imported.append(patchname)
             patchname = None
 
         self.removeundo(repo)
         return imported
 
 def fixkeepchangesopts(ui, opts):
     if (not ui.configbool('mq', 'keepchanges') or opts.get('force')
         or opts.get('exact')):
         return opts
     opts = dict(opts)
     opts['keep_changes'] = True
     return opts
 
 @command("qdelete|qremove|qrm",
          [('k', 'keep', None, _('keep patch file')),
           ('r', 'rev', [],
            _('stop managing a revision (DEPRECATED)'), _('REV'))],
          _('hg qdelete [-k] [PATCH]...'))
 def delete(ui, repo, *patches, **opts):
     """remove patches from queue
 
     The patches must not be applied, and at least one patch is required. Exact
     patch identifiers must be given. With -k/--keep, the patch files are
     preserved in the patch directory.
 
     To stop managing a patch and move it into permanent history,
     use the :hg:`qfinish` command."""
     q = repo.mq
     q.delete(repo, patches, opts)
     q.savedirty()
     return 0
 
 @command("qapplied",
          [('1', 'last', None, _('show only the preceding applied patch'))
           ] + seriesopts,
          _('hg qapplied [-1] [-s] [PATCH]'))
 def applied(ui, repo, patch=None, **opts):
     """print the patches already applied
 
     Returns 0 on success."""
 
     q = repo.mq
 
     if patch:
         if patch not in q.series:
             raise util.Abort(_("patch %s is not in series file") % patch)
         end = q.series.index(patch) + 1
     else:
         end = q.seriesend(True)
 
     if opts.get('last') and not end:
         ui.write(_("no patches applied\n"))
         return 1
     elif opts.get('last') and end == 1:
         ui.write(_("only one patch applied\n"))
         return 1
     elif opts.get('last'):
         start = end - 2
         end = 1
     else:
         start = 0
 
     q.qseries(repo, length=end, start=start, status='A',
               summary=opts.get('summary'))
 
 
 @command("qunapplied",
          [('1', 'first', None, _('show only the first patch'))] + seriesopts,
          _('hg qunapplied [-1] [-s] [PATCH]'))
 def unapplied(ui, repo, patch=None, **opts):
     """print the patches not yet applied
 
     Returns 0 on success."""
 
     q = repo.mq
     if patch:
         if patch not in q.series:
             raise util.Abort(_("patch %s is not in series file") % patch)
         start = q.series.index(patch) + 1
     else:
         start = q.seriesend(True)
 
     if start == len(q.series) and opts.get('first'):
         ui.write(_("all patches applied\n"))
         return 1
 
     if opts.get('first'):
         length = 1
     else:
         length = None
     q.qseries(repo, start=start, length=length, status='U',
               summary=opts.get('summary'))
 
 @command("qimport",
          [('e', 'existing', None, _('import file in patch directory')),
           ('n', 'name', '',
            _('name of patch file'), _('NAME')),
           ('f', 'force', None, _('overwrite existing files')),
           ('r', 'rev', [],
            _('place existing revisions under mq control'), _('REV')),
           ('g', 'git', None, _('use git extended diff format')),
           ('P', 'push', None, _('qpush after importing'))],
          _('hg qimport [-e] [-n NAME] [-f] [-g] [-P] [-r REV]... [FILE]...'))
 def qimport(ui, repo, *filename, **opts):
     """import a patch or existing changeset
 
     The patch is inserted into the series after the last applied
     patch. If no patches have been applied, qimport prepends the patch
     to the series.
 
     The patch will have the same name as its source file unless you
     give it a new one with -n/--name.
 
     You can register an existing patch inside the patch directory with
     the -e/--existing flag.
 
     With -f/--force, an existing patch of the same name will be
     overwritten.
 
     An existing changeset may be placed under mq control with -r/--rev
     (e.g. qimport --rev . -n patch will place the current revision
     under mq control). With -g/--git, patches imported with --rev will
     use the git diff format. See the diffs help topic for information
     on why this is important for preserving rename/copy information
     and permission changes. Use :hg:`qfinish` to remove changesets
     from mq control.
 
     To import a patch from standard input, pass - as the patch file.
     When importing from standard input, a patch name must be specified
     using the --name flag.
 
     To import an existing patch while renaming it::
 
       hg qimport -e existing-patch -n new-name
 
     Returns 0 if import succeeded.
     """
     lock = repo.lock() # cause this may move phase
     try:
         q = repo.mq
         try:
             imported = q.qimport(
                 repo, filename, patchname=opts.get('name'),
                 existing=opts.get('existing'), force=opts.get('force'),
                 rev=opts.get('rev'), git=opts.get('git'))
         finally:
             q.savedirty()
     finally:
         lock.release()
 
     if imported and opts.get('push') and not opts.get('rev'):
         return q.push(repo, imported[-1])
     return 0
 
 def qinit(ui, repo, create):
     """initialize a new queue repository
 
     This command also creates a series file for ordering patches, and
     an mq-specific .hgignore file in the queue repository, to exclude
     the status and guards files (these contain mostly transient state).
 
     Returns 0 if initialization succeeded."""
     q = repo.mq
     r = q.init(repo, create)
     q.savedirty()
     if r:
         if not os.path.exists(r.wjoin('.hgignore')):
             fp = r.wvfs('.hgignore', 'w')
             fp.write('^\\.hg\n')
             fp.write('^\\.mq\n')
             fp.write('syntax: glob\n')
             fp.write('status\n')
             fp.write('guards\n')
             fp.close()
         if not os.path.exists(r.wjoin('series')):
             r.wvfs('series', 'w').close()
         r[None].add(['.hgignore', 'series'])
         commands.add(ui, r)
     return 0
 
 @command("^qinit",
          [('c', 'create-repo', None, _('create queue repository'))],
          _('hg qinit [-c]'))
 def init(ui, repo, **opts):
     """init a new queue repository (DEPRECATED)
 
     The queue repository is unversioned by default. If
     -c/--create-repo is specified, qinit will create a separate nested
     repository for patches (qinit -c may also be run later to convert
     an unversioned patch repository into a versioned one). You can use
     qcommit to commit changes to this queue repository.
 
     This command is deprecated. Without -c, it's implied by other relevant
     commands. With -c, use :hg:`init --mq` instead."""
     return qinit(ui, repo, create=opts.get('create_repo'))
 
 @command("qclone",
          [('', 'pull', None, _('use pull protocol to copy metadata')),
           ('U', 'noupdate', None,
            _('do not update the new working directories')),
           ('', 'uncompressed', None,
            _('use uncompressed transfer (fast over LAN)')),
           ('p', 'patches', '',
            _('location of source patch repository'), _('REPO')),
          ] + commands.remoteopts,
          _('hg qclone [OPTION]... SOURCE [DEST]'),
          norepo=True)
 def clone(ui, source, dest=None, **opts):
     '''clone main and patch repository at same time
 
     If source is local, destination will have no patches applied. If
     source is remote, this command can not check if patches are
     applied in source, so cannot guarantee that patches are not
     applied in destination. If you clone remote repository, be sure
     before that it has no patches applied.
 
     Source patch repository is looked for in <src>/.hg/patches by
     default. Use -p <url> to change.
 
     The patch directory must be a nested Mercurial repository, as
     would be created by :hg:`init --mq`.
 
     Return 0 on success.
     '''
     def patchdir(repo):
         """compute a patch repo url from a repo object"""
         url = repo.url()
         if url.endswith('/'):
             url = url[:-1]
         return url + '/.hg/patches'
 
     # main repo (destination and sources)
     if dest is None:
         dest = hg.defaultdest(source)
     sr = hg.peer(ui, opts, ui.expandpath(source))
 
     # patches repo (source only)
     if opts.get('patches'):
         patchespath = ui.expandpath(opts.get('patches'))
     else:
         patchespath = patchdir(sr)
     try:
         hg.peer(ui, opts, patchespath)
     except error.RepoError:
         raise util.Abort(_('versioned patch repository not found'
                            ' (see init --mq)'))
     qbase, destrev = None, None
     if sr.local():
         repo = sr.local()
         if repo.mq.applied and repo[qbase].phase() != phases.secret:
             qbase = repo.mq.applied[0].node
             if not hg.islocal(dest):
                 heads = set(repo.heads())
                 destrev = list(heads.difference(repo.heads(qbase)))
                 destrev.append(repo.changelog.parents(qbase)[0])
     elif sr.capable('lookup'):
         try:
             qbase = sr.lookup('qbase')
         except error.RepoError:
             pass
 
     ui.note(_('cloning main repository\n'))
     sr, dr = hg.clone(ui, opts, sr.url(), dest,
                       pull=opts.get('pull'),
                       rev=destrev,
                       update=False,
                       stream=opts.get('uncompressed'))
 
     ui.note(_('cloning patch repository\n'))
     hg.clone(ui, opts, opts.get('patches') or patchdir(sr), patchdir(dr),
              pull=opts.get('pull'), update=not opts.get('noupdate'),
              stream=opts.get('uncompressed'))
 
     if dr.local():
         repo = dr.local()
         if qbase:
             ui.note(_('stripping applied patches from destination '
                       'repository\n'))
             strip(ui, repo, [qbase], update=False, backup=None)
         if not opts.get('noupdate'):
             ui.note(_('updating destination repository\n'))
             hg.update(repo, repo.changelog.tip())
 
 @command("qcommit|qci",
          commands.table["^commit|ci"][1],
          _('hg qcommit [OPTION]... [FILE]...'),
          inferrepo=True)
 def commit(ui, repo, *pats, **opts):
     """commit changes in the queue repository (DEPRECATED)
 
     This command is deprecated; use :hg:`commit --mq` instead."""
     q = repo.mq
     r = q.qrepo()
     if not r:
         raise util.Abort('no queue repository')
     commands.commit(r.ui, r, *pats, **opts)
 
 @command("qseries",
          [('m', 'missing', None, _('print patches not in series')),
          ] + seriesopts,
           _('hg qseries [-ms]'))
 def series(ui, repo, **opts):
     """print the entire series file
 
     Returns 0 on success."""
     repo.mq.qseries(repo, missing=opts.get('missing'),
                     summary=opts.get('summary'))
     return 0
 
 @command("qtop", seriesopts, _('hg qtop [-s]'))
 def top(ui, repo, **opts):
     """print the name of the current patch
 
     Returns 0 on success."""
     q = repo.mq
     if q.applied:
         t = q.seriesend(True)
     else:
         t = 0
 
     if t:
         q.qseries(repo, start=t - 1, length=1, status='A',
                   summary=opts.get('summary'))
     else:
         ui.write(_("no patches applied\n"))
         return 1
 
 @command("qnext", seriesopts, _('hg qnext [-s]'))
 def next(ui, repo, **opts):
     """print the name of the next pushable patch
 
     Returns 0 on success."""
     q = repo.mq
     end = q.seriesend()
     if end == len(q.series):
         ui.write(_("all patches applied\n"))
         return 1
     q.qseries(repo, start=end, length=1, summary=opts.get('summary'))
 
 @command("qprev", seriesopts, _('hg qprev [-s]'))
 def prev(ui, repo, **opts):
     """print the name of the preceding applied patch
 
     Returns 0 on success."""
     q = repo.mq
     l = len(q.applied)
     if l == 1:
         ui.write(_("only one patch applied\n"))
         return 1
     if not l:
         ui.write(_("no patches applied\n"))
         return 1
     idx = q.series.index(q.applied[-2].name)
     q.qseries(repo, start=idx, length=1, status='A',
               summary=opts.get('summary'))
 
 def setupheaderopts(ui, opts):
     if not opts.get('user') and opts.get('currentuser'):
         opts['user'] = ui.username()
     if not opts.get('date') and opts.get('currentdate'):
         opts['date'] = "%d %d" % util.makedate()
 
 @command("^qnew",
          [('e', 'edit', None, _('invoke editor on commit messages')),
           ('f', 'force', None, _('import uncommitted changes (DEPRECATED)')),
           ('g', 'git', None, _('use git extended diff format')),
           ('U', 'currentuser', None, _('add "From: <current user>" to patch')),
           ('u', 'user', '',
            _('add "From: <USER>" to patch'), _('USER')),
           ('D', 'currentdate', None, _('add "Date: <current date>" to patch')),
           ('d', 'date', '',
            _('add "Date: <DATE>" to patch'), _('DATE'))
           ] + commands.walkopts + commands.commitopts,
          _('hg qnew [-e] [-m TEXT] [-l FILE] PATCH [FILE]...'),
          inferrepo=True)
 def new(ui, repo, patch, *args, **opts):
     """create a new patch
 
     qnew creates a new patch on top of the currently-applied patch (if
     any). The patch will be initialized with any outstanding changes
     in the working directory. You may also use -I/--include,
     -X/--exclude, and/or a list of files after the patch name to add
     only changes to matching files to the new patch, leaving the rest
     as uncommitted modifications.
 
     -u/--user and -d/--date can be used to set the (given) user and
     date, respectively. -U/--currentuser and -D/--currentdate set user
     to current user and date to current date.
 
     -e/--edit, -m/--message or -l/--logfile set the patch header as
     well as the commit message. If none is specified, the header is
     empty and the commit message is '[mq]: PATCH'.
 
     Use the -g/--git option to keep the patch in the git extended diff
     format. Read the diffs help topic for more information on why this
     is important for preserving permission changes and copy/rename
     information.
 
     Returns 0 on successful creation of a new patch.
     """
     msg = cmdutil.logmessage(ui, opts)
     q = repo.mq
     opts['msg'] = msg
     setupheaderopts(ui, opts)
     q.new(repo, patch, *args, **opts)
     q.savedirty()
     return 0
 
 @command("^qrefresh",
          [('e', 'edit', None, _('invoke editor on commit messages')),
           ('g', 'git', None, _('use git extended diff format')),
           ('s', 'short', None,
            _('refresh only files already in the patch and specified files')),
           ('U', 'currentuser', None,
            _('add/update author field in patch with current user')),
           ('u', 'user', '',
            _('add/update author field in patch with given user'), _('USER')),
           ('D', 'currentdate', None,
            _('add/update date field in patch with current date')),
           ('d', 'date', '',
            _('add/update date field in patch with given date'), _('DATE'))
           ] + commands.walkopts + commands.commitopts,
          _('hg qrefresh [-I] [-X] [-e] [-m TEXT] [-l FILE] [-s] [FILE]...'),
          inferrepo=True)
 def refresh(ui, repo, *pats, **opts):
     """update the current patch
 
     If any file patterns are provided, the refreshed patch will
     contain only the modifications that match those patterns; the
     remaining modifications will remain in the working directory.
 
     If -s/--short is specified, files currently included in the patch
     will be refreshed just like matched files and remain in the patch.
 
     If -e/--edit is specified, Mercurial will start your configured editor for
     you to enter a message. In case qrefresh fails, you will find a backup of
     your message in ``.hg/last-message.txt``.
 
     hg add/remove/copy/rename work as usual, though you might want to
     use git-style patches (-g/--git or [diff] git=1) to track copies
     and renames. See the diffs help topic for more information on the
     git diff format.
 
     Returns 0 on success.
     """
     q = repo.mq
     message = cmdutil.logmessage(ui, opts)
     setupheaderopts(ui, opts)
     wlock = repo.wlock()
     try:
         ret = q.refresh(repo, pats, msg=message, **opts)
         q.savedirty()
         return ret
     finally:
         wlock.release()
 
 @command("^qdiff",
          commands.diffopts + commands.diffopts2 + commands.walkopts,
          _('hg qdiff [OPTION]... [FILE]...'),
          inferrepo=True)
 def diff(ui, repo, *pats, **opts):
     """diff of the current patch and subsequent modifications
 
     Shows a diff which includes the current patch as well as any
     changes which have been made in the working directory since the
     last refresh (thus showing what the current patch would become
     after a qrefresh).
 
     Use :hg:`diff` if you only want to see the changes made since the
     last qrefresh, or :hg:`export qtip` if you want to see changes
     made by the current patch without including changes made since the
     qrefresh.
 
     Returns 0 on success.
     """
     repo.mq.diff(repo, pats, opts)
     return 0
 
 @command('qfold',
          [('e', 'edit', None, _('invoke editor on commit messages')),
           ('k', 'keep', None, _('keep folded patch files')),
          ] + commands.commitopts,
          _('hg qfold [-e] [-k] [-m TEXT] [-l FILE] PATCH...'))
 def fold(ui, repo, *files, **opts):
     """fold the named patches into the current patch
 
     Patches must not yet be applied. Each patch will be successively
     applied to the current patch in the order given. If all the
     patches apply successfully, the current patch will be refreshed
     with the new cumulative patch, and the folded patches will be
     deleted. With -k/--keep, the folded patch files will not be
     removed afterwards.
 
     The header for each folded patch will be concatenated with the
     current patch header, separated by a line of ``* * *``.
 
     Returns 0 on success."""
     q = repo.mq
     if not files:
         raise util.Abort(_('qfold requires at least one patch name'))
     if not q.checktoppatch(repo)[0]:
         raise util.Abort(_('no patches applied'))
     q.checklocalchanges(repo)
 
     message = cmdutil.logmessage(ui, opts)
 
     parent = q.lookup('qtip')
     patches = []
     messages = []
     for f in files:
         p = q.lookup(f)
         if p in patches or p == parent:
             ui.warn(_('skipping already folded patch %s\n') % p)
         if q.isapplied(p):
             raise util.Abort(_('qfold cannot fold already applied patch %s')
                              % p)
         patches.append(p)
 
     for p in patches:
         if not message:
             ph = patchheader(q.join(p), q.plainmode)
             if ph.message:
                 messages.append(ph.message)
         pf = q.join(p)
         (patchsuccess, files, fuzz) = q.patch(repo, pf)
         if not patchsuccess:
             raise util.Abort(_('error folding patch %s') % p)
 
     if not message:
         ph = patchheader(q.join(parent), q.plainmode)
         message = ph.message
         for msg in messages:
             if msg:
                 if message:
                     message.append('* * *')
                 message.extend(msg)
         message = '\n'.join(message)
 
     diffopts = q.patchopts(q.diffopts(), *patches)
     wlock = repo.wlock()
     try:
         q.refresh(repo, msg=message, git=diffopts.git, edit=opts.get('edit'),
                   editform='mq.qfold')
         q.delete(repo, patches, opts)
         q.savedirty()
     finally:
         wlock.release()
 
 @command("qgoto",
          [('', 'keep-changes', None,
            _('tolerate non-conflicting local changes')),
           ('f', 'force', None, _('overwrite any local changes')),
           ('', 'no-backup', None, _('do not save backup copies of files'))],
          _('hg qgoto [OPTION]... PATCH'))
 def goto(ui, repo, patch, **opts):
     '''push or pop patches until named patch is at top of stack
 
     Returns 0 on success.'''
     opts = fixkeepchangesopts(ui, opts)
     q = repo.mq
     patch = q.lookup(patch)
     nobackup = opts.get('no_backup')
     keepchanges = opts.get('keep_changes')
     if q.isapplied(patch):
         ret = q.pop(repo, patch, force=opts.get('force'), nobackup=nobackup,
                     keepchanges=keepchanges)
     else:
         ret = q.push(repo, patch, force=opts.get('force'), nobackup=nobackup,
                      keepchanges=keepchanges)
     q.savedirty()
     return ret
 
 @command("qguard",
          [('l', 'list', None, _('list all patches and guards')),
           ('n', 'none', None, _('drop all guards'))],
          _('hg qguard [-l] [-n] [PATCH] [-- [+GUARD]... [-GUARD]...]'))
 def guard(ui, repo, *args, **opts):
     '''set or print guards for a patch
 
     Guards control whether a patch can be pushed. A patch with no
     guards is always pushed. A patch with a positive guard ("+foo") is
     pushed only if the :hg:`qselect` command has activated it. A patch with
     a negative guard ("-foo") is never pushed if the :hg:`qselect` command
     has activated it.
 
     With no arguments, print the currently active guards.
     With arguments, set guards for the named patch.
 
     .. note::
 
        Specifying negative guards now requires '--'.
 
     To set guards on another patch::
 
       hg qguard other.patch -- +2.6.17 -stable
 
     Returns 0 on success.
     '''
     def status(idx):
         guards = q.seriesguards[idx] or ['unguarded']
         if q.series[idx] in applied:
             state = 'applied'
         elif q.pushable(idx)[0]:
             state = 'unapplied'
         else:
             state = 'guarded'
         label = 'qguard.patch qguard.%s qseries.%s' % (state, state)
         ui.write('%s: ' % ui.label(q.series[idx], label))
 
         for i, guard in enumerate(guards):
             if guard.startswith('+'):
                 ui.write(guard, label='qguard.positive')
             elif guard.startswith('-'):
                 ui.write(guard, label='qguard.negative')
             else:
                 ui.write(guard, label='qguard.unguarded')
             if i != len(guards) - 1:
                 ui.write(' ')
         ui.write('\n')
     q = repo.mq
     applied = set(p.name for p in q.applied)
     patch = None
     args = list(args)
     if opts.get('list'):
         if args or opts.get('none'):
             raise util.Abort(_('cannot mix -l/--list with options or '
                                'arguments'))
         for i in xrange(len(q.series)):
             status(i)
         return
     if not args or args[0][0:1] in '-+':
         if not q.applied:
             raise util.Abort(_('no patches applied'))
         patch = q.applied[-1].name
     if patch is None and args[0][0:1] not in '-+':
         patch = args.pop(0)
     if patch is None:
         raise util.Abort(_('no patch to work with'))
     if args or opts.get('none'):
         idx = q.findseries(patch)
         if idx is None:
             raise util.Abort(_('no patch named %s') % patch)
         q.setguards(idx, args)
         q.savedirty()
     else:
         status(q.series.index(q.lookup(patch)))
 
 @command("qheader", [], _('hg qheader [PATCH]'))
 def header(ui, repo, patch=None):
     """print the header of the topmost or specified patch
 
     Returns 0 on success."""
     q = repo.mq
 
     if patch:
         patch = q.lookup(patch)
     else:
         if not q.applied:
             ui.write(_('no patches applied\n'))
             return 1
         patch = q.lookup('qtip')
     ph = patchheader(q.join(patch), q.plainmode)
 
     ui.write('\n'.join(ph.message) + '\n')
 
 def lastsavename(path):
     (directory, base) = os.path.split(path)
     names = os.listdir(directory)
     namere = re.compile("%s.([0-9]+)" % base)
     maxindex = None
     maxname = None
     for f in names:
         m = namere.match(f)
         if m:
             index = int(m.group(1))
             if maxindex is None or index > maxindex:
                 maxindex = index
                 maxname = f
     if maxname:
         return (os.path.join(directory, maxname), maxindex)
     return (None, None)
 
 def savename(path):
     (last, index) = lastsavename(path)
     if last is None:
         index = 0
     newpath = path + ".%d" % (index + 1)
     return newpath
 
 @command("^qpush",
          [('', 'keep-changes', None,
            _('tolerate non-conflicting local changes')),
           ('f', 'force', None, _('apply on top of local changes')),
           ('e', 'exact', None,
            _('apply the target patch to its recorded parent')),
           ('l', 'list', None, _('list patch name in commit text')),
           ('a', 'all', None, _('apply all patches')),
           ('m', 'merge', None, _('merge from another queue (DEPRECATED)')),
           ('n', 'name', '',
            _('merge queue name (DEPRECATED)'), _('NAME')),
           ('', 'move', None,
            _('reorder patch series and apply only the patch')),
           ('', 'no-backup', None, _('do not save backup copies of files'))],
          _('hg qpush [-f] [-l] [-a] [--move] [PATCH | INDEX]'))
 def push(ui, repo, patch=None, **opts):
     """push the next patch onto the stack
 
     By default, abort if the working directory contains uncommitted
     changes. With --keep-changes, abort only if the uncommitted files
     overlap with patched files. With -f/--force, backup and patch over
     uncommitted changes.
 
     Return 0 on success.
     """
     q = repo.mq
     mergeq = None
 
     opts = fixkeepchangesopts(ui, opts)
     if opts.get('merge'):
         if opts.get('name'):
             newpath = repo.join(opts.get('name'))
         else:
             newpath, i = lastsavename(q.path)
         if not newpath:
             ui.warn(_("no saved queues found, please use -n\n"))
             return 1
         mergeq = queue(ui, repo.baseui, repo.path, newpath)
         ui.warn(_("merging with queue at: %s\n") % mergeq.path)
     ret = q.push(repo, patch, force=opts.get('force'), list=opts.get('list'),
                  mergeq=mergeq, all=opts.get('all'), move=opts.get('move'),
                  exact=opts.get('exact'), nobackup=opts.get('no_backup'),
                  keepchanges=opts.get('keep_changes'))
     return ret
 
 @command("^qpop",
          [('a', 'all', None, _('pop all patches')),
           ('n', 'name', '',
            _('queue name to pop (DEPRECATED)'), _('NAME')),
           ('', 'keep-changes', None,
            _('tolerate non-conflicting local changes')),
           ('f', 'force', None, _('forget any local changes to patched files')),
           ('', 'no-backup', None, _('do not save backup copies of files'))],
          _('hg qpop [-a] [-f] [PATCH | INDEX]'))
 def pop(ui, repo, patch=None, **opts):
     """pop the current patch off the stack
 
     Without argument, pops off the top of the patch stack. If given a
     patch name, keeps popping off patches until the named patch is at
     the top of the stack.
 
     By default, abort if the working directory contains uncommitted
     changes. With --keep-changes, abort only if the uncommitted files
     overlap with patched files. With -f/--force, backup and discard
     changes made to such files.
 
     Return 0 on success.
     """
     opts = fixkeepchangesopts(ui, opts)
     localupdate = True
     if opts.get('name'):
         q = queue(ui, repo.baseui, repo.path, repo.join(opts.get('name')))
         ui.warn(_('using patch queue: %s\n') % q.path)
         localupdate = False
     else:
         q = repo.mq
     ret = q.pop(repo, patch, force=opts.get('force'), update=localupdate,
                 all=opts.get('all'), nobackup=opts.get('no_backup'),
                 keepchanges=opts.get('keep_changes'))
     q.savedirty()
     return ret
 
 @command("qrename|qmv", [], _('hg qrename PATCH1 [PATCH2]'))
 def rename(ui, repo, patch, name=None, **opts):
     """rename a patch
 
     With one argument, renames the current patch to PATCH1.
     With two arguments, renames PATCH1 to PATCH2.
 
     Returns 0 on success."""
     q = repo.mq
     if not name:
         name = patch
         patch = None
 
     if patch:
         patch = q.lookup(patch)
     else:
         if not q.applied:
             ui.write(_('no patches applied\n'))
             return
         patch = q.lookup('qtip')
     absdest = q.join(name)
     if os.path.isdir(absdest):
         name = normname(os.path.join(name, os.path.basename(patch)))
         absdest = q.join(name)
     q.checkpatchname(name)
 
     ui.note(_('renaming %s to %s\n') % (patch, name))
     i = q.findseries(patch)
     guards = q.guard_re.findall(q.fullseries[i])
     q.fullseries[i] = name + ''.join([' #' + g for g in guards])
     q.parseseries()
     q.seriesdirty = True
 
     info = q.isapplied(patch)
     if info:
         q.applied[info[0]] = statusentry(info[1], name)
     q.applieddirty = True
 
     destdir = os.path.dirname(absdest)
     if not os.path.isdir(destdir):
         os.makedirs(destdir)
     util.rename(q.join(patch), absdest)
     r = q.qrepo()
     if r and patch in r.dirstate:
         wctx = r[None]
         wlock = r.wlock()
         try:
             if r.dirstate[patch] == 'a':
                 r.dirstate.drop(patch)
                 r.dirstate.add(name)
             else:
                 wctx.copy(patch, name)
                 wctx.forget([patch])
         finally:
             wlock.release()
 
     q.savedirty()
 
 @command("qrestore",
          [('d', 'delete', None, _('delete save entry')),
           ('u', 'update', None, _('update queue working directory'))],
          _('hg qrestore [-d] [-u] REV'))
 def restore(ui, repo, rev, **opts):
     """restore the queue state saved by a revision (DEPRECATED)
 
     This command is deprecated, use :hg:`rebase` instead."""
     rev = repo.lookup(rev)
     q = repo.mq
     q.restore(repo, rev, delete=opts.get('delete'),
               qupdate=opts.get('update'))
     q.savedirty()
     return 0
 
 @command("qsave",
          [('c', 'copy', None, _('copy patch directory')),
           ('n', 'name', '',
            _('copy directory name'), _('NAME')),
           ('e', 'empty', None, _('clear queue status file')),
           ('f', 'force', None, _('force copy'))] + commands.commitopts,
          _('hg qsave [-m TEXT] [-l FILE] [-c] [-n NAME] [-e] [-f]'))
 def save(ui, repo, **opts):
     """save current queue state (DEPRECATED)
 
     This command is deprecated, use :hg:`rebase` instead."""
     q = repo.mq
     message = cmdutil.logmessage(ui, opts)
     ret = q.save(repo, msg=message)
     if ret:
         return ret
     q.savedirty() # save to .hg/patches before copying
     if opts.get('copy'):
         path = q.path
         if opts.get('name'):
             newpath = os.path.join(q.basepath, opts.get('name'))
             if os.path.exists(newpath):
                 if not os.path.isdir(newpath):
                     raise util.Abort(_('destination %s exists and is not '
                                        'a directory') % newpath)
                 if not opts.get('force'):
                     raise util.Abort(_('destination %s exists, '
                                        'use -f to force') % newpath)
         else:
             newpath = savename(path)
         ui.warn(_("copy %s to %s\n") % (path, newpath))
         util.copyfiles(path, newpath)
     if opts.get('empty'):
         del q.applied[:]
         q.applieddirty = True
         q.savedirty()
     return 0
 
 
 @command("qselect",
          [('n', 'none', None, _('disable all guards')),
           ('s', 'series', None, _('list all guards in series file')),
           ('', 'pop', None, _('pop to before first guarded applied patch')),
           ('', 'reapply', None, _('pop, then reapply patches'))],
          _('hg qselect [OPTION]... [GUARD]...'))
 def select(ui, repo, *args, **opts):
     '''set or print guarded patches to push
 
     Use the :hg:`qguard` command to set or print guards on patch, then use
     qselect to tell mq which guards to use. A patch will be pushed if
     it has no guards or any positive guards match the currently
     selected guard, but will not be pushed if any negative guards
     match the current guard. For example::
 
         qguard foo.patch -- -stable    (negative guard)
         qguard bar.patch    +stable    (positive guard)
         qselect stable
 
     This activates the "stable" guard. mq will skip foo.patch (because
     it has a negative match) but push bar.patch (because it has a
     positive match).
 
     With no arguments, prints the currently active guards.
     With one argument, sets the active guard.
 
     Use -n/--none to deactivate guards (no other arguments needed).
     When no guards are active, patches with positive guards are
     skipped and patches with negative guards are pushed.
 
     qselect can change the guards on applied patches. It does not pop
     guarded patches by default. Use --pop to pop back to the last
     applied patch that is not guarded. Use --reapply (which implies
     --pop) to push back to the current patch afterwards, but skip
     guarded patches.
 
     Use -s/--series to print a list of all guards in the series file
     (no other arguments needed). Use -v for more information.
 
     Returns 0 on success.'''
 
     q = repo.mq
     guards = q.active()
     pushable = lambda i: q.pushable(q.applied[i].name)[0]
     if args or opts.get('none'):
         old_unapplied = q.unapplied(repo)
         old_guarded = [i for i in xrange(len(q.applied)) if not pushable(i)]
         q.setactive(args)
         q.savedirty()
         if not args:
             ui.status(_('guards deactivated\n'))
         if not opts.get('pop') and not opts.get('reapply'):
             unapplied = q.unapplied(repo)
             guarded = [i for i in xrange(len(q.applied)) if not pushable(i)]
             if len(unapplied) != len(old_unapplied):
                 ui.status(_('number of unguarded, unapplied patches has '
                             'changed from %d to %d\n') %
                           (len(old_unapplied), len(unapplied)))
             if len(guarded) != len(old_guarded):
                 ui.status(_('number of guarded, applied patches has changed '
                             'from %d to %d\n') %
                           (len(old_guarded), len(guarded)))
     elif opts.get('series'):
         guards = {}
         noguards = 0
         for gs in q.seriesguards:
             if not gs:
                 noguards += 1
             for g in gs:
                 guards.setdefault(g, 0)
                 guards[g] += 1
         if ui.verbose:
             guards['NONE'] = noguards
         guards = guards.items()
         guards.sort(key=lambda x: x[0][1:])
         if guards:
             ui.note(_('guards in series file:\n'))
             for guard, count in guards:
                 ui.note('%2d  ' % count)
                 ui.write(guard, '\n')
         else:
             ui.note(_('no guards in series file\n'))
     else:
         if guards:
             ui.note(_('active guards:\n'))
             for g in guards:
                 ui.write(g, '\n')
         else:
             ui.write(_('no active guards\n'))
     reapply = opts.get('reapply') and q.applied and q.applied[-1].name
     popped = False
     if opts.get('pop') or opts.get('reapply'):
         for i in xrange(len(q.applied)):
             if not pushable(i):
                 ui.status(_('popping guarded patches\n'))
                 popped = True
                 if i == 0:
                     q.pop(repo, all=True)
                 else:
                     q.pop(repo, q.applied[i - 1].name)
                 break
     if popped:
         try:
             if reapply:
                 ui.status(_('reapplying unguarded patches\n'))
                 q.push(repo, reapply)
         finally:
             q.savedirty()
 
 @command("qfinish",
          [('a', 'applied', None, _('finish all applied changesets'))],
          _('hg qfinish [-a] [REV]...'))
 def finish(ui, repo, *revrange, **opts):
     """move applied patches into repository history
 
     Finishes the specified revisions (corresponding to applied
     patches) by moving them out of mq control into regular repository
     history.
 
     Accepts a revision range or the -a/--applied option. If --applied
     is specified, all applied mq revisions are removed from mq
     control. Otherwise, the given revisions must be at the base of the
     stack of applied patches.
 
     This can be especially useful if your changes have been applied to
     an upstream repository, or if you are about to push your changes
     to upstream.
 
     Returns 0 on success.
     """
     if not opts.get('applied') and not revrange:
         raise util.Abort(_('no revisions specified'))
     elif opts.get('applied'):
         revrange = ('qbase::qtip',) + revrange
 
     q = repo.mq
     if not q.applied:
         ui.status(_('no patches applied\n'))
         return 0
 
     revs = scmutil.revrange(repo, revrange)
     if repo['.'].rev() in revs and repo[None].files():
         ui.warn(_('warning: uncommitted changes in the working directory\n'))
     # queue.finish may changes phases but leave the responsibility to lock the
     # repo to the caller to avoid deadlock with wlock. This command code is
     # responsibility for this locking.
     lock = repo.lock()
     try:
         q.finish(repo, revs)
         q.savedirty()
     finally:
         lock.release()
     return 0
 
 @command("qqueue",
          [('l', 'list', False, _('list all available queues')),
           ('', 'active', False, _('print name of active queue')),
           ('c', 'create', False, _('create new queue')),
           ('', 'rename', False, _('rename active queue')),
           ('', 'delete', False, _('delete reference to queue')),
           ('', 'purge', False, _('delete queue, and remove patch dir')),
          ],
          _('[OPTION] [QUEUE]'))
 def qqueue(ui, repo, name=None, **opts):
     '''manage multiple patch queues
 
     Supports switching between different patch queues, as well as creating
     new patch queues and deleting existing ones.
 
     Omitting a queue name or specifying -l/--list will show you the registered
     queues - by default the "normal" patches queue is registered. The currently
     active queue will be marked with "(active)". Specifying --active will print
     only the name of the active queue.
 
     To create a new queue, use -c/--create. The queue is automatically made
     active, except in the case where there are applied patches from the
     currently active queue in the repository. Then the queue will only be
     created and switching will fail.
 
     To delete an existing queue, use --delete. You cannot delete the currently
     active queue.
 
     Returns 0 on success.
     '''
     q = repo.mq
     _defaultqueue = 'patches'
     _allqueues = 'patches.queues'
     _activequeue = 'patches.queue'
 
     def _getcurrent():
         cur = os.path.basename(q.path)
         if cur.startswith('patches-'):
             cur = cur[8:]
         return cur
 
     def _noqueues():
         try:
             fh = repo.vfs(_allqueues, 'r')
             fh.close()
         except IOError:
             return True
 
         return False
 
     def _getqueues():
         current = _getcurrent()
 
         try:
             fh = repo.vfs(_allqueues, 'r')
             queues = [queue.strip() for queue in fh if queue.strip()]
             fh.close()
             if current not in queues:
                 queues.append(current)
         except IOError:
             queues = [_defaultqueue]
 
         return sorted(queues)
 
     def _setactive(name):
         if q.applied:
             raise util.Abort(_('new queue created, but cannot make active '
                                'as patches are applied'))
         _setactivenocheck(name)
 
     def _setactivenocheck(name):
         fh = repo.vfs(_activequeue, 'w')
         if name != 'patches':
             fh.write(name)
         fh.close()
 
     def _addqueue(name):
         fh = repo.vfs(_allqueues, 'a')
         fh.write('%s\n' % (name,))
         fh.close()
 
     def _queuedir(name):
         if name == 'patches':
             return repo.join('patches')
         else:
             return repo.join('patches-' + name)
 
     def _validname(name):
         for n in name:
             if n in ':\\/.':
                 return False
         return True
 
     def _delete(name):
         if name not in existing:
             raise util.Abort(_('cannot delete queue that does not exist'))
 
         current = _getcurrent()
 
         if name == current:
             raise util.Abort(_('cannot delete currently active queue'))
 
         fh = repo.vfs('patches.queues.new', 'w')
         for queue in existing:
             if queue == name:
                 continue
             fh.write('%s\n' % (queue,))
         fh.close()
         util.rename(repo.join('patches.queues.new'), repo.join(_allqueues))
 
     if not name or opts.get('list') or opts.get('active'):
         current = _getcurrent()
         if opts.get('active'):
             ui.write('%s\n' % (current,))
             return
         for queue in _getqueues():
             ui.write('%s' % (queue,))
             if queue == current and not ui.quiet:
                 ui.write(_(' (active)\n'))
             else:
                 ui.write('\n')
         return
 
     if not _validname(name):
         raise util.Abort(
                 _('invalid queue name, may not contain the characters ":\\/."'))
 
     existing = _getqueues()
 
     if opts.get('create'):
         if name in existing:
             raise util.Abort(_('queue "%s" already exists') % name)
         if _noqueues():
             _addqueue(_defaultqueue)
         _addqueue(name)
         _setactive(name)
     elif opts.get('rename'):
         current = _getcurrent()
         if name == current:
             raise util.Abort(_('can\'t rename "%s" to its current name') % name)
         if name in existing:
             raise util.Abort(_('queue "%s" already exists') % name)
 
         olddir = _queuedir(current)
         newdir = _queuedir(name)
 
         if os.path.exists(newdir):
             raise util.Abort(_('non-queue directory "%s" already exists') %
                     newdir)
 
         fh = repo.vfs('patches.queues.new', 'w')
         for queue in existing:
             if queue == current:
                 fh.write('%s\n' % (name,))
                 if os.path.exists(olddir):
                     util.rename(olddir, newdir)
             else:
                 fh.write('%s\n' % (queue,))
         fh.close()
         util.rename(repo.join('patches.queues.new'), repo.join(_allqueues))
         _setactivenocheck(name)
     elif opts.get('delete'):
         _delete(name)
     elif opts.get('purge'):
         if name in existing:
             _delete(name)
         qdir = _queuedir(name)
         if os.path.exists(qdir):
             shutil.rmtree(qdir)
     else:
         if name not in existing:
             raise util.Abort(_('use --create to create a new queue'))
         _setactive(name)
 
 def mqphasedefaults(repo, roots):
     """callback used to set mq changeset as secret when no phase data exists"""
     if repo.mq.applied:
         if repo.ui.configbool('mq', 'secret', False):
             mqphase = phases.secret
         else:
             mqphase = phases.draft
         qbase = repo[repo.mq.applied[0].node]
         roots[mqphase].add(qbase.node())
     return roots
 
 def reposetup(ui, repo):
     class mqrepo(repo.__class__):
         @localrepo.unfilteredpropertycache
         def mq(self):
             return queue(self.ui, self.baseui, self.path)
 
         def invalidateall(self):
             super(mqrepo, self).invalidateall()
             if localrepo.hasunfilteredcache(self, 'mq'):
                 # recreate mq in case queue path was changed
                 delattr(self.unfiltered(), 'mq')
 
         def abortifwdirpatched(self, errmsg, force=False):
             if self.mq.applied and self.mq.checkapplied and not force:
                 parents = self.dirstate.parents()
                 patches = [s.node for s in self.mq.applied]
                 if parents[0] in patches or parents[1] in patches:
                     raise util.Abort(errmsg)
 
         def commit(self, text="", user=None, date=None, match=None,
                    force=False, editor=False, extra={}):
             self.abortifwdirpatched(
                 _('cannot commit over an applied mq patch'),
                 force)
 
             return super(mqrepo, self).commit(text, user, date, match, force,
                                               editor, extra)
 
         def checkpush(self, pushop):
             if self.mq.applied and self.mq.checkapplied and not pushop.force:
                 outapplied = [e.node for e in self.mq.applied]
                 if pushop.revs:
                     # Assume applied patches have no non-patch descendants and
                     # are not on remote already. Filtering any changeset not
                     # pushed.
                     heads = set(pushop.revs)
                     for node in reversed(outapplied):
                         if node in heads:
                             break
                         else:
                             outapplied.pop()
                 # looking for pushed and shared changeset
                 for node in outapplied:
                     if self[node].phase() < phases.secret:
                         raise util.Abort(_('source has mq patches applied'))
                 # no non-secret patches pushed
             super(mqrepo, self).checkpush(pushop)
 
         def _findtags(self):
             '''augment tags from base class with patch tags'''
             result = super(mqrepo, self)._findtags()
 
             q = self.mq
             if not q.applied:
                 return result
 
             mqtags = [(patch.node, patch.name) for patch in q.applied]
 
             try:
                 # for now ignore filtering business
                 self.unfiltered().changelog.rev(mqtags[-1][0])
             except error.LookupError:
                 self.ui.warn(_('mq status file refers to unknown node %s\n')
                              % short(mqtags[-1][0]))
                 return result
 
             # do not add fake tags for filtered revisions
             included = self.changelog.hasnode
             mqtags = [mqt for mqt in mqtags if included(mqt[0])]
             if not mqtags:
                 return result
 
             mqtags.append((mqtags[-1][0], 'qtip'))
             mqtags.append((mqtags[0][0], 'qbase'))
             mqtags.append((self.changelog.parents(mqtags[0][0])[0], 'qparent'))
             tags = result[0]
             for patch in mqtags:
                 if patch[1] in tags:
                     self.ui.warn(_('tag %s overrides mq patch of the same '
                                    'name\n') % patch[1])
                 else:
                     tags[patch[1]] = patch[0]
 
             return result
 
     if repo.local():
         repo.__class__ = mqrepo
 
         repo._phasedefaults.append(mqphasedefaults)
 
 def mqimport(orig, ui, repo, *args, **kwargs):
     if (util.safehasattr(repo, 'abortifwdirpatched')
         and not kwargs.get('no_commit', False)):
         repo.abortifwdirpatched(_('cannot import over an applied patch'),
                                    kwargs.get('force'))
     return orig(ui, repo, *args, **kwargs)
 
 def mqinit(orig, ui, *args, **kwargs):
     mq = kwargs.pop('mq', None)
 
     if not mq:
         return orig(ui, *args, **kwargs)
 
     if args:
         repopath = args[0]
         if not hg.islocal(repopath):
             raise util.Abort(_('only a local queue repository '
                                'may be initialized'))
     else:
         repopath = cmdutil.findrepo(os.getcwd())
         if not repopath:
             raise util.Abort(_('there is no Mercurial repository here '
                                '(.hg not found)'))
     repo = hg.repository(ui, repopath)
     return qinit(ui, repo, True)
 
 def mqcommand(orig, ui, repo, *args, **kwargs):
     """Add --mq option to operate on patch repository instead of main"""
 
     # some commands do not like getting unknown options
     mq = kwargs.pop('mq', None)
 
     if not mq:
         return orig(ui, repo, *args, **kwargs)
 
     q = repo.mq
     r = q.qrepo()
     if not r:
         raise util.Abort(_('no queue repository'))
     return orig(r.ui, r, *args, **kwargs)
 
 def summaryhook(ui, repo):
     q = repo.mq
     m = []
     a, u = len(q.applied), len(q.unapplied(repo))
     if a:
         m.append(ui.label(_("%d applied"), 'qseries.applied') % a)
     if u:
         m.append(ui.label(_("%d unapplied"), 'qseries.unapplied') % u)
     if m:
         # i18n: column positioning for "hg summary"
         ui.write(_("mq:     %s\n") % ', '.join(m))
     else:
         # i18n: column positioning for "hg summary"
         ui.note(_("mq:     (empty queue)\n"))
 
 def revsetmq(repo, subset, x):
     """``mq()``
     Changesets managed by MQ.
     """
     revset.getargs(x, 0, 0, _("mq takes no arguments"))
     applied = set([repo[r.node].rev() for r in repo.mq.applied])
     return revset.baseset([r for r in subset if r in applied])
 
 # tell hggettext to extract docstrings from these functions:
 i18nfunctions = [revsetmq]
 
 def extsetup(ui):
     # Ensure mq wrappers are called first, regardless of extension load order by
     # NOT wrapping in uisetup() and instead deferring to init stage two here.
     mqopt = [('', 'mq', None, _("operate on patch repository"))]
 
     extensions.wrapcommand(commands.table, 'import', mqimport)
     cmdutil.summaryhooks.add('mq', summaryhook)
 
     entry = extensions.wrapcommand(commands.table, 'init', mqinit)
     entry[1].extend(mqopt)
 
     nowrap = set(commands.norepo.split(" "))
 
     def dotable(cmdtable):
         for cmd in cmdtable.keys():
             cmd = cmdutil.parsealiases(cmd)[0]
             if cmd in nowrap:
                 continue
             entry = extensions.wrapcommand(cmdtable, cmd, mqcommand)
             entry[1].extend(mqopt)
 
     dotable(commands.table)
 
     for extname, extmodule in extensions.extensions():
         if extmodule.__file__ != __file__:
             dotable(getattr(extmodule, 'cmdtable', {}))
 
     revset.symbols['mq'] = revsetmq
 
 colortable = {'qguard.negative': 'red',
               'qguard.positive': 'yellow',
               'qguard.unguarded': 'green',
               'qseries.applied': 'blue bold underline',
               'qseries.guarded': 'black bold',
               'qseries.missing': 'red bold',
               'qseries.unapplied': 'black bold'}

hgext/notify.py

@@ -1,415 +1,419 b''
 # notify.py - email notifications for mercurial
 #
 # Copyright 2006 Vadim Gelfer <[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.
 
 '''hooks for sending email push notifications
 
 This extension implements hooks to send email notifications when
 changesets are sent from or received by the local repository.
 
 First, enable the extension as explained in :hg:`help extensions`, and
 register the hook you want to run. ``incoming`` and ``changegroup`` hooks
 are run when changesets are received, while ``outgoing`` hooks are for
 changesets sent to another repository::
 
   [hooks]
   # one email for each incoming changeset
   incoming.notify = python:hgext.notify.hook
   # one email for all incoming changesets
   changegroup.notify = python:hgext.notify.hook
 
   # one email for all outgoing changesets
   outgoing.notify = python:hgext.notify.hook
 
 This registers the hooks. To enable notification, subscribers must
 be assigned to repositories. The ``[usersubs]`` section maps multiple
 repositories to a given recipient. The ``[reposubs]`` section maps
 multiple recipients to a single repository::
 
   [usersubs]
   # key is subscriber email, value is a comma-separated list of repo patterns
   user@host = pattern
 
   [reposubs]
   # key is repo pattern, value is a comma-separated list of subscriber emails
   pattern = user@host
 
 A ``pattern`` is a ``glob`` matching the absolute path to a repository,
 optionally combined with a revset expression. A revset expression, if
 present, is separated from the glob by a hash. Example::
 
   [reposubs]
   */widgets#branch(release) = [e-mail]
 
 This sends to ``[e-mail]`` whenever a changeset on the ``release``
 branch triggers a notification in any repository ending in ``widgets``.
 
 In order to place them under direct user management, ``[usersubs]`` and
 ``[reposubs]`` sections may be placed in a separate ``hgrc`` file and
 incorporated by reference::
 
   [notify]
   config = /path/to/subscriptionsfile
 
 Notifications will not be sent until the ``notify.test`` value is set
 to ``False``; see below.
 
 Notifications content can be tweaked with the following configuration entries:
 
 notify.test
   If ``True``, print messages to stdout instead of sending them. Default: True.
 
 notify.sources
   Space-separated list of change sources. Notifications are activated only
   when a changeset's source is in this list. Sources may be:
 
   :``serve``: changesets received via http or ssh
   :``pull``: changesets received via ``hg pull``
   :``unbundle``: changesets received via ``hg unbundle``
   :``push``: changesets sent or received via ``hg push``
   :``bundle``: changesets sent via ``hg unbundle``
 
   Default: serve.
 
 notify.strip
   Number of leading slashes to strip from url paths. By default, notifications
   reference repositories with their absolute path. ``notify.strip`` lets you
   turn them into relative paths. For example, ``notify.strip=3`` will change
   ``/long/path/repository`` into ``repository``. Default: 0.
 
 notify.domain
   Default email domain for sender or recipients with no explicit domain.
 
 notify.style
   Style file to use when formatting emails.
 
 notify.template
   Template to use when formatting emails.
 
 notify.incoming
   Template to use when run as an incoming hook, overriding ``notify.template``.
 
 notify.outgoing
   Template to use when run as an outgoing hook, overriding ``notify.template``.
 
 notify.changegroup
   Template to use when running as a changegroup hook, overriding
   ``notify.template``.
 
 notify.maxdiff
   Maximum number of diff lines to include in notification email. Set to 0
   to disable the diff, or -1 to include all of it. Default: 300.
 
 notify.maxsubject
   Maximum number of characters in email's subject line. Default: 67.
 
 notify.diffstat
   Set to True to include a diffstat before diff content. Default: True.
 
 notify.merge
   If True, send notifications for merge changesets. Default: True.
 
 notify.mbox
   If set, append mails to this mbox file instead of sending. Default: None.
 
 notify.fromauthor
   If set, use the committer of the first changeset in a changegroup for
   the "From" field of the notification mail. If not set, take the user
   from the pushing repo.  Default: False.
 
 If set, the following entries will also be used to customize the
 notifications:
 
 email.from
   Email ``From`` address to use if none can be found in the generated
   email content.
 
 web.baseurl
   Root repository URL to combine with repository paths when making
   references. See also ``notify.strip``.
 
 '''
 
 import email, socket, time
 # On python2.4 you have to import this by name or they fail to
 # load. This was not a problem on Python 2.7.
 import email.Parser
 from mercurial.i18n import _
 from mercurial import patch, cmdutil, util, mail
 import fnmatch
 
+# Note for extension authors: ONLY specify testedwith = 'internal' for
+# extensions which SHIP WITH MERCURIAL. Non-mainline extensions should
+# be specifying the version(s) of Mercurial they are tested with, or
+# leave the attribute unspecified.
 testedwith = 'internal'
 
 # template for single changeset can include email headers.
 single_template = '''
 Subject: changeset in {webroot}: {desc|firstline|strip}
 From: {author}
 
 changeset {node|short} in {root}
 details: {baseurl}{webroot}?cmd=changeset;node={node|short}
 description:
 \t{desc|tabindent|strip}
 '''.lstrip()
 
 # template for multiple changesets should not contain email headers,
 # because only first set of headers will be used and result will look
 # strange.
 multiple_template = '''
 changeset {node|short} in {root}
 details: {baseurl}{webroot}?cmd=changeset;node={node|short}
 summary: {desc|firstline}
 '''
 
 deftemplates = {
     'changegroup': multiple_template,
 }
 
 class notifier(object):
     '''email notification class.'''
 
     def __init__(self, ui, repo, hooktype):
         self.ui = ui
         cfg = self.ui.config('notify', 'config')
         if cfg:
             self.ui.readconfig(cfg, sections=['usersubs', 'reposubs'])
         self.repo = repo
         self.stripcount = int(self.ui.config('notify', 'strip', 0))
         self.root = self.strip(self.repo.root)
         self.domain = self.ui.config('notify', 'domain')
         self.mbox = self.ui.config('notify', 'mbox')
         self.test = self.ui.configbool('notify', 'test', True)
         self.charsets = mail._charsets(self.ui)
         self.subs = self.subscribers()
         self.merge = self.ui.configbool('notify', 'merge', True)
 
         mapfile = self.ui.config('notify', 'style')
         template = (self.ui.config('notify', hooktype) or
                     self.ui.config('notify', 'template'))
         if not mapfile and not template:
             template = deftemplates.get(hooktype) or single_template
         self.t = cmdutil.changeset_templater(self.ui, self.repo, False, None,
                                              template, mapfile, False)
 
     def strip(self, path):
         '''strip leading slashes from local path, turn into web-safe path.'''
 
         path = util.pconvert(path)
         count = self.stripcount
         while count > 0:
             c = path.find('/')
             if c == -1:
                 break
             path = path[c + 1:]
             count -= 1
         return path
 
     def fixmail(self, addr):
         '''try to clean up email addresses.'''
 
         addr = util.email(addr.strip())
         if self.domain:
             a = addr.find('@localhost')
             if a != -1:
                 addr = addr[:a]
             if '@' not in addr:
                 return addr + '@' + self.domain
         return addr
 
     def subscribers(self):
         '''return list of email addresses of subscribers to this repo.'''
         subs = set()
         for user, pats in self.ui.configitems('usersubs'):
             for pat in pats.split(','):
                 if '#' in pat:
                     pat, revs = pat.split('#', 1)
                 else:
                     revs = None
                 if fnmatch.fnmatch(self.repo.root, pat.strip()):
                     subs.add((self.fixmail(user), revs))
         for pat, users in self.ui.configitems('reposubs'):
             if '#' in pat:
                 pat, revs = pat.split('#', 1)
             else:
                 revs = None
             if fnmatch.fnmatch(self.repo.root, pat):
                 for user in users.split(','):
                     subs.add((self.fixmail(user), revs))
         return [(mail.addressencode(self.ui, s, self.charsets, self.test), r)
                 for s, r in sorted(subs)]
 
     def node(self, ctx, **props):
         '''format one changeset, unless it is a suppressed merge.'''
         if not self.merge and len(ctx.parents()) > 1:
             return False
         self.t.show(ctx, changes=ctx.changeset(),
                     baseurl=self.ui.config('web', 'baseurl'),
                     root=self.repo.root, webroot=self.root, **props)
         return True
 
     def skipsource(self, source):
         '''true if incoming changes from this source should be skipped.'''
         ok_sources = self.ui.config('notify', 'sources', 'serve').split()
         return source not in ok_sources
 
     def send(self, ctx, count, data):
         '''send message.'''
 
         # Select subscribers by revset
         subs = set()
         for sub, spec in self.subs:
             if spec is None:
                 subs.add(sub)
                 continue
             revs = self.repo.revs('%r and %d:', spec, ctx.rev())
             if len(revs):
                 subs.add(sub)
                 continue
         if len(subs) == 0:
             self.ui.debug('notify: no subscribers to selected repo '
                           'and revset\n')
             return
 
         p = email.Parser.Parser()
         try:
             msg = p.parsestr(data)
         except email.Errors.MessageParseError, inst:
             raise util.Abort(inst)
 
         # store sender and subject
         sender, subject = msg['From'], msg['Subject']
         del msg['From'], msg['Subject']
 
         if not msg.is_multipart():
             # create fresh mime message from scratch
             # (multipart templates must take care of this themselves)
             headers = msg.items()
             payload = msg.get_payload()
             # for notification prefer readability over data precision
             msg = mail.mimeencode(self.ui, payload, self.charsets, self.test)
             # reinstate custom headers
             for k, v in headers:
                 msg[k] = v
 
         msg['Date'] = util.datestr(format="%a, %d %b %Y %H:%M:%S %1%2")
 
         # try to make subject line exist and be useful
         if not subject:
             if count > 1:
                 subject = _('%s: %d new changesets') % (self.root, count)
             else:
                 s = ctx.description().lstrip().split('\n', 1)[0].rstrip()
                 subject = '%s: %s' % (self.root, s)
         maxsubject = int(self.ui.config('notify', 'maxsubject', 67))
         if maxsubject:
             subject = util.ellipsis(subject, maxsubject)
         msg['Subject'] = mail.headencode(self.ui, subject,
                                          self.charsets, self.test)
 
         # try to make message have proper sender
         if not sender:
             sender = self.ui.config('email', 'from') or self.ui.username()
         if '@' not in sender or '@localhost' in sender:
             sender = self.fixmail(sender)
         msg['From'] = mail.addressencode(self.ui, sender,
                                          self.charsets, self.test)
 
         msg['X-Hg-Notification'] = 'changeset %s' % ctx
         if not msg['Message-Id']:
             msg['Message-Id'] = ('<hg.%s.%s.%s@%s>' %
                                  (ctx, int(time.time()),
                                   hash(self.repo.root), socket.getfqdn()))
         msg['To'] = ', '.join(sorted(subs))
 
         msgtext = msg.as_string()
         if self.test:
             self.ui.write(msgtext)
             if not msgtext.endswith('\n'):
                 self.ui.write('\n')
         else:
             self.ui.status(_('notify: sending %d subscribers %d changes\n') %
                            (len(subs), count))
             mail.sendmail(self.ui, util.email(msg['From']),
                           subs, msgtext, mbox=self.mbox)
 
     def diff(self, ctx, ref=None):
 
         maxdiff = int(self.ui.config('notify', 'maxdiff', 300))
         prev = ctx.p1().node()
         if ref:
             ref = ref.node()
         else:
             ref = ctx.node()
         chunks = patch.diff(self.repo, prev, ref,
                             opts=patch.diffallopts(self.ui))
         difflines = ''.join(chunks).splitlines()
 
         if self.ui.configbool('notify', 'diffstat', True):
             s = patch.diffstat(difflines)
             # s may be nil, don't include the header if it is
             if s:
                 self.ui.write('\ndiffstat:\n\n%s' % s)
 
         if maxdiff == 0:
             return
         elif maxdiff > 0 and len(difflines) > maxdiff:
             msg = _('\ndiffs (truncated from %d to %d lines):\n\n')
             self.ui.write(msg % (len(difflines), maxdiff))
             difflines = difflines[:maxdiff]
         elif difflines:
             self.ui.write(_('\ndiffs (%d lines):\n\n') % len(difflines))
 
         self.ui.write("\n".join(difflines))
 
 def hook(ui, repo, hooktype, node=None, source=None, **kwargs):
     '''send email notifications to interested subscribers.
 
     if used as changegroup hook, send one email for all changesets in
     changegroup. else send one email per changeset.'''
 
     n = notifier(ui, repo, hooktype)
     ctx = repo[node]
 
     if not n.subs:
         ui.debug('notify: no subscribers to repository %s\n' % n.root)
         return
     if n.skipsource(source):
         ui.debug('notify: changes have source "%s" - skipping\n' % source)
         return
 
     ui.pushbuffer()
     data = ''
     count = 0
     author = ''
     if hooktype == 'changegroup' or hooktype == 'outgoing':
         start, end = ctx.rev(), len(repo)
         for rev in xrange(start, end):
             if n.node(repo[rev]):
                 count += 1
                 if not author:
                     author = repo[rev].user()
             else:
                 data += ui.popbuffer()
                 ui.note(_('notify: suppressing notification for merge %d:%s\n')
                         % (rev, repo[rev].hex()[:12]))
                 ui.pushbuffer()
         if count:
             n.diff(ctx, repo['tip'])
     else:
         if not n.node(ctx):
             ui.popbuffer()
             ui.note(_('notify: suppressing notification for merge %d:%s\n') %
                     (ctx.rev(), ctx.hex()[:12]))
             return
         count += 1
         n.diff(ctx)
 
     data += ui.popbuffer()
     fromauthor = ui.config('notify', 'fromauthor')
     if author and fromauthor:
         data = '\n'.join(['From: %s' % author, data])
 
     if count:
         n.send(ctx, count, data)

hgext/pager.py

@@ -1,175 +1,179 b''
 # pager.py - display output using a pager
 #
 # 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.
 #
 # To load the extension, add it to your configuration file:
 #
 #   [extension]
 #   pager =
 #
 # Run "hg help pager" to get info on configuration.
 
 '''browse command output with an external pager
 
 To set the pager that should be used, set the application variable::
 
   [pager]
   pager = less -FRX
 
 If no pager is set, the pager extensions uses the environment variable
 $PAGER. If neither pager.pager, nor $PAGER is set, no pager is used.
 
 You can disable the pager for certain commands by adding them to the
 pager.ignore list::
 
   [pager]
   ignore = version, help, update
 
 You can also enable the pager only for certain commands using
 pager.attend. Below is the default list of commands to be paged::
 
   [pager]
   attend = annotate, cat, diff, export, glog, log, qdiff
 
 Setting pager.attend to an empty value will cause all commands to be
 paged.
 
 If pager.attend is present, pager.ignore will be ignored.
 
 Lastly, you can enable and disable paging for individual commands with
 the attend-<command> option. This setting takes precedence over
 existing attend and ignore options and defaults::
 
   [pager]
   attend-cat = false
 
 To ignore global commands like :hg:`version` or :hg:`help`, you have
 to specify them in your user configuration file.
 
 The --pager=... option can also be used to control when the pager is
 used. Use a boolean value like yes, no, on, off, or use auto for
 normal behavior.
 
 '''
 
 import atexit, sys, os, signal, subprocess, errno, shlex
 from mercurial import commands, dispatch, util, extensions, cmdutil
 from mercurial.i18n import _
 
+# Note for extension authors: ONLY specify testedwith = 'internal' for
+# extensions which SHIP WITH MERCURIAL. Non-mainline extensions should
+# be specifying the version(s) of Mercurial they are tested with, or
+# leave the attribute unspecified.
 testedwith = 'internal'
 
 def _pagerfork(ui, p):
     if not util.safehasattr(os, 'fork'):
         sys.stdout = util.popen(p, 'wb')
         if ui._isatty(sys.stderr):
             sys.stderr = sys.stdout
         return
     fdin, fdout = os.pipe()
     pid = os.fork()
     if pid == 0:
         os.close(fdin)
         os.dup2(fdout, sys.stdout.fileno())
         if ui._isatty(sys.stderr):
             os.dup2(fdout, sys.stderr.fileno())
         os.close(fdout)
         return
     os.dup2(fdin, sys.stdin.fileno())
     os.close(fdin)
     os.close(fdout)
     try:
         os.execvp('/bin/sh', ['/bin/sh', '-c', p])
     except OSError, e:
         if e.errno == errno.ENOENT:
             # no /bin/sh, try executing the pager directly
             args = shlex.split(p)
             os.execvp(args[0], args)
         else:
             raise
 
 def _pagersubprocess(ui, p):
     pager = subprocess.Popen(p, shell=True, bufsize=-1,
                              close_fds=util.closefds, stdin=subprocess.PIPE,
                              stdout=sys.stdout, stderr=sys.stderr)
 
     stdout = os.dup(sys.stdout.fileno())
     stderr = os.dup(sys.stderr.fileno())
     os.dup2(pager.stdin.fileno(), sys.stdout.fileno())
     if ui._isatty(sys.stderr):
         os.dup2(pager.stdin.fileno(), sys.stderr.fileno())
 
     @atexit.register
     def killpager():
         if util.safehasattr(signal, "SIGINT"):
             signal.signal(signal.SIGINT, signal.SIG_IGN)
         pager.stdin.close()
         os.dup2(stdout, sys.stdout.fileno())
         os.dup2(stderr, sys.stderr.fileno())
         pager.wait()
 
 def _runpager(ui, p):
     # The subprocess module shipped with Python <= 2.4 is buggy (issue3533).
     # The compat version is buggy on Windows (issue3225), but has been shipping
     # with hg for a long time.  Preserve existing functionality.
     if sys.version_info >= (2, 5):
         _pagersubprocess(ui, p)
     else:
         _pagerfork(ui, p)
 
 def uisetup(ui):
     if '--debugger' in sys.argv or not ui.formatted():
         return
 
     def pagecmd(orig, ui, options, cmd, cmdfunc):
         p = ui.config("pager", "pager", os.environ.get("PAGER"))
         usepager = False
         always = util.parsebool(options['pager'])
         auto = options['pager'] == 'auto'
 
         if not p:
             pass
         elif always:
             usepager = True
         elif not auto:
             usepager = False
         else:
             attend = ui.configlist('pager', 'attend', attended)
             ignore = ui.configlist('pager', 'ignore')
             cmds, _ = cmdutil.findcmd(cmd, commands.table)
 
             for cmd in cmds:
                 var = 'attend-%s' % cmd
                 if ui.config('pager', var):
                     usepager = ui.configbool('pager', var)
                     break
                 if (cmd in attend or
                      (cmd not in ignore and not attend)):
                     usepager = True
                     break
 
         setattr(ui, 'pageractive', usepager)
 
         if usepager:
             ui.setconfig('ui', 'formatted', ui.formatted(), 'pager')
             ui.setconfig('ui', 'interactive', False, 'pager')
             if util.safehasattr(signal, "SIGPIPE"):
                 signal.signal(signal.SIGPIPE, signal.SIG_DFL)
             _runpager(ui, p)
         return orig(ui, options, cmd, cmdfunc)
 
     # Wrap dispatch._runcommand after color is loaded so color can see
     # ui.pageractive. Otherwise, if we loaded first, color's wrapped
     # dispatch._runcommand would run without having access to ui.pageractive.
     def afterloaded(loaded):
         extensions.wrapfunction(dispatch, '_runcommand', pagecmd)
     extensions.afterloaded('color', afterloaded)
 
 def extsetup(ui):
     commands.globalopts.append(
         ('', 'pager', 'auto',
          _("when to paginate (boolean, always, auto, or never)"),
          _('TYPE')))
 
 attended = ['annotate', 'cat', 'diff', 'export', 'glog', 'log', 'qdiff']

hgext/patchbomb.py

@@ -1,656 +1,660 b''
 # patchbomb.py - sending Mercurial changesets as patch emails
 #
 #  Copyright 2005-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.
 
 '''command to send changesets as (a series of) patch emails
 
 The series is started off with a "[PATCH 0 of N]" introduction, which
 describes the series as a whole.
 
 Each patch email has a Subject line of "[PATCH M of N] ...", using the
 first line of the changeset description as the subject text. The
 message contains two or three body parts:
 
 - The changeset description.
 - [Optional] The result of running diffstat on the patch.
 - The patch itself, as generated by :hg:`export`.
 
 Each message refers to the first in the series using the In-Reply-To
 and References headers, so they will show up as a sequence in threaded
 mail and news readers, and in mail archives.
 
 To configure other defaults, add a section like this to your
 configuration file::
 
   [email]
   from = My Name <my@email>
   to = recipient1, recipient2, ...
   cc = cc1, cc2, ...
   bcc = bcc1, bcc2, ...
   reply-to = address1, address2, ...
 
 Use ``[patchbomb]`` as configuration section name if you need to
 override global ``[email]`` address settings.
 
 Then you can use the :hg:`email` command to mail a series of
 changesets as a patchbomb.
 
 You can also either configure the method option in the email section
 to be a sendmail compatible mailer or fill out the [smtp] section so
 that the patchbomb extension can automatically send patchbombs
 directly from the commandline. See the [email] and [smtp] sections in
 hgrc(5) for details.
 
 You can control the default inclusion of an introduction message with the
 ``patchbomb.intro`` configuration option. The configuration is always
 overwritten by command line flags like --intro and --desc::
 
   [patchbomb]
   intro=auto   # include introduction message if more than 1 patch (default)
   intro=never  # never include an introduction message
   intro=always # always include an introduction message
 
 You can set patchbomb to always ask for confirmation by setting
 ``patchbomb.confirm`` to true.
 '''
 
 import os, errno, socket, tempfile, cStringIO
 import email
 # On python2.4 you have to import these by name or they fail to
 # load. This was not a problem on Python 2.7.
 import email.Generator
 import email.MIMEMultipart
 
 from mercurial import cmdutil, commands, hg, mail, patch, util
 from mercurial import scmutil
 from mercurial.i18n import _
 from mercurial.node import bin
 
 cmdtable = {}
 command = cmdutil.command(cmdtable)
+# Note for extension authors: ONLY specify testedwith = 'internal' for
+# extensions which SHIP WITH MERCURIAL. Non-mainline extensions should
+# be specifying the version(s) of Mercurial they are tested with, or
+# leave the attribute unspecified.
 testedwith = 'internal'
 
 def prompt(ui, prompt, default=None, rest=':'):
     if default:
         prompt += ' [%s]' % default
     return ui.prompt(prompt + rest, default)
 
 def introwanted(ui, opts, number):
     '''is an introductory message apparently wanted?'''
     introconfig = ui.config('patchbomb', 'intro', 'auto')
     if opts.get('intro') or opts.get('desc'):
         intro = True
     elif introconfig == 'always':
         intro = True
     elif introconfig == 'never':
         intro = False
     elif introconfig == 'auto':
         intro = 1 < number
     else:
         ui.write_err(_('warning: invalid patchbomb.intro value "%s"\n')
                      % introconfig)
         ui.write_err(_('(should be one of always, never, auto)\n'))
         intro = 1 < number
     return intro
 
 def makepatch(ui, repo, patchlines, opts, _charsets, idx, total, numbered,
               patchname=None):
 
     desc = []
     node = None
     body = ''
 
     for line in patchlines:
         if line.startswith('#'):
             if line.startswith('# Node ID'):
                 node = line.split()[-1]
             continue
         if line.startswith('diff -r') or line.startswith('diff --git'):
             break
         desc.append(line)
 
     if not patchname and not node:
         raise ValueError
 
     if opts.get('attach') and not opts.get('body'):
         body = ('\n'.join(desc[1:]).strip() or
                 'Patch subject is complete summary.')
         body += '\n\n\n'
 
     if opts.get('plain'):
         while patchlines and patchlines[0].startswith('# '):
             patchlines.pop(0)
         if patchlines:
             patchlines.pop(0)
         while patchlines and not patchlines[0].strip():
             patchlines.pop(0)
 
     ds = patch.diffstat(patchlines, git=opts.get('git'))
     if opts.get('diffstat'):
         body += ds + '\n\n'
 
     addattachment = opts.get('attach') or opts.get('inline')
     if not addattachment or opts.get('body'):
         body += '\n'.join(patchlines)
 
     if addattachment:
         msg = email.MIMEMultipart.MIMEMultipart()
         if body:
             msg.attach(mail.mimeencode(ui, body, _charsets, opts.get('test')))
         p = mail.mimetextpatch('\n'.join(patchlines), 'x-patch',
                                opts.get('test'))
         binnode = bin(node)
         # if node is mq patch, it will have the patch file's name as a tag
         if not patchname:
             patchtags = [t for t in repo.nodetags(binnode)
                          if t.endswith('.patch') or t.endswith('.diff')]
             if patchtags:
                 patchname = patchtags[0]
             elif total > 1:
                 patchname = cmdutil.makefilename(repo, '%b-%n.patch',
                                                  binnode, seqno=idx,
                                                  total=total)
             else:
                 patchname = cmdutil.makefilename(repo, '%b.patch', binnode)
         disposition = 'inline'
         if opts.get('attach'):
             disposition = 'attachment'
         p['Content-Disposition'] = disposition + '; filename=' + patchname
         msg.attach(p)
     else:
         msg = mail.mimetextpatch(body, display=opts.get('test'))
 
     flag = ' '.join(opts.get('flag'))
     if flag:
         flag = ' ' + flag
 
     subj = desc[0].strip().rstrip('. ')
     if not numbered:
         subj = '[PATCH%s] %s' % (flag, opts.get('subject') or subj)
     else:
         tlen = len(str(total))
         subj = '[PATCH %0*d of %d%s] %s' % (tlen, idx, total, flag, subj)
     msg['Subject'] = mail.headencode(ui, subj, _charsets, opts.get('test'))
     msg['X-Mercurial-Node'] = node
     msg['X-Mercurial-Series-Index'] = '%i' % idx
     msg['X-Mercurial-Series-Total'] = '%i' % total
     return msg, subj, ds
 
 def _getpatches(repo, revs, **opts):
     """return a list of patches for a list of revisions
 
     Each patch in the list is itself a list of lines.
     """
     ui = repo.ui
     prev = repo['.'].rev()
     for r in revs:
         if r == prev and (repo[None].files() or repo[None].deleted()):
             ui.warn(_('warning: working directory has '
                       'uncommitted changes\n'))
         output = cStringIO.StringIO()
         cmdutil.export(repo, [r], fp=output,
                      opts=patch.difffeatureopts(ui, opts, git=True))
         yield output.getvalue().split('\n')
 def _getbundle(repo, dest, **opts):
     """return a bundle containing changesets missing in "dest"
 
     The `opts` keyword-arguments are the same as the one accepted by the
     `bundle` command.
 
     The bundle is a returned as a single in-memory binary blob.
     """
     ui = repo.ui
     tmpdir = tempfile.mkdtemp(prefix='hg-email-bundle-')
     tmpfn = os.path.join(tmpdir, 'bundle')
     try:
         commands.bundle(ui, repo, tmpfn, dest, **opts)
         fp = open(tmpfn, 'rb')
         data = fp.read()
         fp.close()
         return data
     finally:
         try:
             os.unlink(tmpfn)
         except OSError:
             pass
         os.rmdir(tmpdir)
 
 def _getdescription(repo, defaultbody, sender, **opts):
     """obtain the body of the introduction message and return it
 
     This is also used for the body of email with an attached bundle.
 
     The body can be obtained either from the command line option or entered by
     the user through the editor.
     """
     ui = repo.ui
     if opts.get('desc'):
         body = open(opts.get('desc')).read()
     else:
         ui.write(_('\nWrite the introductory message for the '
                    'patch series.\n\n'))
         body = ui.edit(defaultbody, sender)
         # Save series description in case sendmail fails
         msgfile = repo.vfs('last-email.txt', 'wb')
         msgfile.write(body)
         msgfile.close()
     return body
 
 def _getbundlemsgs(repo, sender, bundle, **opts):
     """Get the full email for sending a given bundle
 
     This function returns a list of "email" tuples (subject, content, None).
     The list is always one message long in that case.
     """
     ui = repo.ui
     _charsets = mail._charsets(ui)
     subj = (opts.get('subject')
             or prompt(ui, 'Subject:', 'A bundle for your repository'))
 
     body = _getdescription(repo, '', sender, **opts)
     msg = email.MIMEMultipart.MIMEMultipart()
     if body:
         msg.attach(mail.mimeencode(ui, body, _charsets, opts.get('test')))
     datapart = email.MIMEBase.MIMEBase('application', 'x-mercurial-bundle')
     datapart.set_payload(bundle)
     bundlename = '%s.hg' % opts.get('bundlename', 'bundle')
     datapart.add_header('Content-Disposition', 'attachment',
                         filename=bundlename)
     email.Encoders.encode_base64(datapart)
     msg.attach(datapart)
     msg['Subject'] = mail.headencode(ui, subj, _charsets, opts.get('test'))
     return [(msg, subj, None)]
 
 def _makeintro(repo, sender, patches, **opts):
     """make an introduction email, asking the user for content if needed
 
     email is returned as (subject, body, cumulative-diffstat)"""
     ui = repo.ui
     _charsets = mail._charsets(ui)
     tlen = len(str(len(patches)))
 
     flag = opts.get('flag') or ''
     if flag:
         flag = ' ' + ' '.join(flag)
     prefix = '[PATCH %0*d of %d%s]' % (tlen, 0, len(patches), flag)
 
     subj = (opts.get('subject') or
             prompt(ui, '(optional) Subject: ', rest=prefix, default=''))
     if not subj:
         return None         # skip intro if the user doesn't bother
 
     subj = prefix + ' ' + subj
 
     body = ''
     if opts.get('diffstat'):
         # generate a cumulative diffstat of the whole patch series
         diffstat = patch.diffstat(sum(patches, []))
         body = '\n' + diffstat
     else:
         diffstat = None
 
     body = _getdescription(repo, body, sender, **opts)
     msg = mail.mimeencode(ui, body, _charsets, opts.get('test'))
     msg['Subject'] = mail.headencode(ui, subj, _charsets,
                                      opts.get('test'))
     return (msg, subj, diffstat)
 
 def _getpatchmsgs(repo, sender, patches, patchnames=None, **opts):
     """return a list of emails from a list of patches
 
     This involves introduction message creation if necessary.
 
     This function returns a list of "email" tuples (subject, content, None).
     """
     ui = repo.ui
     _charsets = mail._charsets(ui)
     msgs = []
 
     ui.write(_('this patch series consists of %d patches.\n\n')
              % len(patches))
 
     # build the intro message, or skip it if the user declines
     if introwanted(ui, opts, len(patches)):
         msg = _makeintro(repo, sender, patches, **opts)
         if msg:
             msgs.append(msg)
 
     # are we going to send more than one message?
     numbered = len(msgs) + len(patches) > 1
 
     # now generate the actual patch messages
     name = None
     for i, p in enumerate(patches):
         if patchnames:
             name = patchnames[i]
         msg = makepatch(ui, repo, p, opts, _charsets, i + 1,
                         len(patches), numbered, name)
         msgs.append(msg)
 
     return msgs
 
 def _getoutgoing(repo, dest, revs):
     '''Return the revisions present locally but not in dest'''
     ui = repo.ui
     url = ui.expandpath(dest or 'default-push', dest or 'default')
     url = hg.parseurl(url)[0]
     ui.status(_('comparing with %s\n') % util.hidepassword(url))
 
     revs = [r for r in revs if r >= 0]
     if not revs:
         revs = [len(repo) - 1]
     revs = repo.revs('outgoing(%s) and ::%ld', dest or '', revs)
     if not revs:
         ui.status(_("no changes found\n"))
     return revs
 
 emailopts = [
     ('', 'body', None, _('send patches as inline message text (default)')),
     ('a', 'attach', None, _('send patches as attachments')),
     ('i', 'inline', None, _('send patches as inline attachments')),
     ('', 'bcc', [], _('email addresses of blind carbon copy recipients')),
     ('c', 'cc', [], _('email addresses of copy recipients')),
     ('', 'confirm', None, _('ask for confirmation before sending')),
     ('d', 'diffstat', None, _('add diffstat output to messages')),
     ('', 'date', '', _('use the given date as the sending date')),
     ('', 'desc', '', _('use the given file as the series description')),
     ('f', 'from', '', _('email address of sender')),
     ('n', 'test', None, _('print messages that would be sent')),
     ('m', 'mbox', '', _('write messages to mbox file instead of sending them')),
     ('', 'reply-to', [], _('email addresses replies should be sent to')),
     ('s', 'subject', '', _('subject of first message (intro or single patch)')),
     ('', 'in-reply-to', '', _('message identifier to reply to')),
     ('', 'flag', [], _('flags to add in subject prefixes')),
     ('t', 'to', [], _('email addresses of recipients'))]
 
 @command('email',
     [('g', 'git', None, _('use git extended diff format')),
     ('', 'plain', None, _('omit hg patch header')),
     ('o', 'outgoing', None,
      _('send changes not found in the target repository')),
     ('b', 'bundle', None, _('send changes not in target as a binary bundle')),
     ('', 'bundlename', 'bundle',
      _('name of the bundle attachment file'), _('NAME')),
     ('r', 'rev', [], _('a revision to send'), _('REV')),
     ('', 'force', None, _('run even when remote repository is unrelated '
        '(with -b/--bundle)')),
     ('', 'base', [], _('a base changeset to specify instead of a destination '
        '(with -b/--bundle)'), _('REV')),
     ('', 'intro', None, _('send an introduction email for a single patch')),
     ] + emailopts + commands.remoteopts,
     _('hg email [OPTION]... [DEST]...'))
 def patchbomb(ui, repo, *revs, **opts):
     '''send changesets by email
 
     By default, diffs are sent in the format generated by
     :hg:`export`, one per message. The series starts with a "[PATCH 0
     of N]" introduction, which describes the series as a whole.
 
     Each patch email has a Subject line of "[PATCH M of N] ...", using
     the first line of the changeset description as the subject text.
     The message contains two or three parts. First, the changeset
     description.
 
     With the -d/--diffstat option, if the diffstat program is
     installed, the result of running diffstat on the patch is inserted.
 
     Finally, the patch itself, as generated by :hg:`export`.
 
     With the -d/--diffstat or --confirm options, you will be presented
     with a final summary of all messages and asked for confirmation before
     the messages are sent.
 
     By default the patch is included as text in the email body for
     easy reviewing. Using the -a/--attach option will instead create
     an attachment for the patch. With -i/--inline an inline attachment
     will be created. You can include a patch both as text in the email
     body and as a regular or an inline attachment by combining the
     -a/--attach or -i/--inline with the --body option.
 
     With -o/--outgoing, emails will be generated for patches not found
     in the destination repository (or only those which are ancestors
     of the specified revisions if any are provided)
 
     With -b/--bundle, changesets are selected as for --outgoing, but a
     single email containing a binary Mercurial bundle as an attachment
     will be sent.
 
     With -m/--mbox, instead of previewing each patchbomb message in a
     pager or sending the messages directly, it will create a UNIX
     mailbox file with the patch emails. This mailbox file can be
     previewed with any mail user agent which supports UNIX mbox
     files.
 
     With -n/--test, all steps will run, but mail will not be sent.
     You will be prompted for an email recipient address, a subject and
     an introductory message describing the patches of your patchbomb.
     Then when all is done, patchbomb messages are displayed. If the
     PAGER environment variable is set, your pager will be fired up once
     for each patchbomb message, so you can verify everything is alright.
 
     In case email sending fails, you will find a backup of your series
     introductory message in ``.hg/last-email.txt``.
 
     The default behavior of this command can be customized through
     configuration. (See :hg:`help patchbomb` for details)
 
     Examples::
 
       hg email -r 3000          # send patch 3000 only
       hg email -r 3000 -r 3001  # send patches 3000 and 3001
       hg email -r 3000:3005     # send patches 3000 through 3005
       hg email 3000             # send patch 3000 (deprecated)
 
       hg email -o               # send all patches not in default
       hg email -o DEST          # send all patches not in DEST
       hg email -o -r 3000       # send all ancestors of 3000 not in default
       hg email -o -r 3000 DEST  # send all ancestors of 3000 not in DEST
 
       hg email -b               # send bundle of all patches not in default
       hg email -b DEST          # send bundle of all patches not in DEST
       hg email -b -r 3000       # bundle of all ancestors of 3000 not in default
       hg email -b -r 3000 DEST  # bundle of all ancestors of 3000 not in DEST
 
       hg email -o -m mbox &&    # generate an mbox file...
         mutt -R -f mbox         # ... and view it with mutt
       hg email -o -m mbox &&    # generate an mbox file ...
         formail -s sendmail \\   # ... and use formail to send from the mbox
           -bm -t < mbox         # ... using sendmail
 
     Before using this command, you will need to enable email in your
     hgrc. See the [email] section in hgrc(5) for details.
     '''
 
     _charsets = mail._charsets(ui)
 
     bundle = opts.get('bundle')
     date = opts.get('date')
     mbox = opts.get('mbox')
     outgoing = opts.get('outgoing')
     rev = opts.get('rev')
     # internal option used by pbranches
     patches = opts.get('patches')
 
     if not (opts.get('test') or mbox):
         # really sending
         mail.validateconfig(ui)
 
     if not (revs or rev or outgoing or bundle or patches):
         raise util.Abort(_('specify at least one changeset with -r or -o'))
 
     if outgoing and bundle:
         raise util.Abort(_("--outgoing mode always on with --bundle;"
                            " do not re-specify --outgoing"))
 
     if outgoing or bundle:
         if len(revs) > 1:
             raise util.Abort(_("too many destinations"))
         if revs:
             dest = revs[0]
         else:
             dest = None
         revs = []
 
     if rev:
         if revs:
             raise util.Abort(_('use only one form to specify the revision'))
         revs = rev
 
     revs = scmutil.revrange(repo, revs)
     if outgoing:
         revs = _getoutgoing(repo, dest, revs)
     if bundle:
         opts['revs'] = [str(r) for r in revs]
 
     # start
     if date:
         start_time = util.parsedate(date)
     else:
         start_time = util.makedate()
 
     def genmsgid(id):
         return '<%s.%s@%s>' % (id[:20], int(start_time[0]), socket.getfqdn())
 
     sender = (opts.get('from') or ui.config('email', 'from') or
               ui.config('patchbomb', 'from') or
               prompt(ui, 'From', ui.username()))
 
     if patches:
         msgs = _getpatchmsgs(repo, sender, patches, opts.get('patchnames'),
                              **opts)
     elif bundle:
         bundledata = _getbundle(repo, dest, **opts)
         bundleopts = opts.copy()
         bundleopts.pop('bundle', None)  # already processed
         msgs = _getbundlemsgs(repo, sender, bundledata, **bundleopts)
     else:
         _patches = list(_getpatches(repo, revs, **opts))
         msgs = _getpatchmsgs(repo, sender, _patches, **opts)
 
     showaddrs = []
 
     def getaddrs(header, ask=False, default=None):
         configkey = header.lower()
         opt = header.replace('-', '_').lower()
         addrs = opts.get(opt)
         if addrs:
             showaddrs.append('%s: %s' % (header, ', '.join(addrs)))
             return mail.addrlistencode(ui, addrs, _charsets, opts.get('test'))
 
         # not on the command line: fallback to config and then maybe ask
         addr = (ui.config('email', configkey) or
                 ui.config('patchbomb', configkey) or
                 '')
         if not addr and ask:
             addr = prompt(ui, header, default=default)
         if addr:
             showaddrs.append('%s: %s' % (header, addr))
             return mail.addrlistencode(ui, [addr], _charsets, opts.get('test'))
         else:
             return default
 
     to = getaddrs('To', ask=True)
     if not to:
         # we can get here in non-interactive mode
         raise util.Abort(_('no recipient addresses provided'))
     cc = getaddrs('Cc', ask=True, default='') or []
     bcc = getaddrs('Bcc') or []
     replyto = getaddrs('Reply-To')
 
     confirm = ui.configbool('patchbomb', 'confirm')
     confirm |= bool(opts.get('diffstat') or opts.get('confirm'))
 
     if confirm:
         ui.write(_('\nFinal summary:\n\n'), label='patchbomb.finalsummary')
         ui.write(('From: %s\n' % sender), label='patchbomb.from')
         for addr in showaddrs:
             ui.write('%s\n' % addr, label='patchbomb.to')
         for m, subj, ds in msgs:
             ui.write(('Subject: %s\n' % subj), label='patchbomb.subject')
             if ds:
                 ui.write(ds, label='patchbomb.diffstats')
         ui.write('\n')
         if ui.promptchoice(_('are you sure you want to send (yn)?'
                              '$$ &Yes $$ &No')):
             raise util.Abort(_('patchbomb canceled'))
 
     ui.write('\n')
 
     parent = opts.get('in_reply_to') or None
     # angle brackets may be omitted, they're not semantically part of the msg-id
     if parent is not None:
         if not parent.startswith('<'):
             parent = '<' + parent
         if not parent.endswith('>'):
             parent += '>'
 
     sender_addr = email.Utils.parseaddr(sender)[1]
     sender = mail.addressencode(ui, sender, _charsets, opts.get('test'))
     sendmail = None
     firstpatch = None
     for i, (m, subj, ds) in enumerate(msgs):
         try:
             m['Message-Id'] = genmsgid(m['X-Mercurial-Node'])
             if not firstpatch:
                 firstpatch = m['Message-Id']
             m['X-Mercurial-Series-Id'] = firstpatch
         except TypeError:
             m['Message-Id'] = genmsgid('patchbomb')
         if parent:
             m['In-Reply-To'] = parent
             m['References'] = parent
         if not parent or 'X-Mercurial-Node' not in m:
             parent = m['Message-Id']
 
         m['User-Agent'] = 'Mercurial-patchbomb/%s' % util.version()
         m['Date'] = email.Utils.formatdate(start_time[0], localtime=True)
 
         start_time = (start_time[0] + 1, start_time[1])
         m['From'] = sender
         m['To'] = ', '.join(to)
         if cc:
             m['Cc']  = ', '.join(cc)
         if bcc:
             m['Bcc'] = ', '.join(bcc)
         if replyto:
             m['Reply-To'] = ', '.join(replyto)
         if opts.get('test'):
             ui.status(_('displaying '), subj, ' ...\n')
             ui.flush()
             if 'PAGER' in os.environ and not ui.plain():
                 fp = util.popen(os.environ['PAGER'], 'w')
             else:
                 fp = ui
             generator = email.Generator.Generator(fp, mangle_from_=False)
             try:
                 generator.flatten(m, 0)
                 fp.write('\n')
             except IOError, inst:
                 if inst.errno != errno.EPIPE:
                     raise
             if fp is not ui:
                 fp.close()
         else:
             if not sendmail:
                 verifycert = ui.config('smtp', 'verifycert')
                 if opts.get('insecure'):
                     ui.setconfig('smtp', 'verifycert', 'loose', 'patchbomb')
                 try:
                     sendmail = mail.connect(ui, mbox=mbox)
                 finally:
                     ui.setconfig('smtp', 'verifycert', verifycert, 'patchbomb')
             ui.status(_('sending '), subj, ' ...\n')
             ui.progress(_('sending'), i, item=subj, total=len(msgs))
             if not mbox:
                 # Exim does not remove the Bcc field
                 del m['Bcc']
             fp = cStringIO.StringIO()
             generator = email.Generator.Generator(fp, mangle_from_=False)
             generator.flatten(m, 0)
             sendmail(sender_addr, to + bcc + cc, fp.getvalue())
 
     ui.progress(_('writing'), None)
     ui.progress(_('sending'), None)

hgext/progress.py

@@ -1,320 +1,324 b''
 # progress.py show progress bars for some actions
 #
 # Copyright (C) 2010 Augie Fackler <[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.
 
 """show progress bars for some actions
 
 This extension uses the progress information logged by hg commands
 to draw progress bars that are as informative as possible. Some progress
 bars only offer indeterminate information, while others have a definite
 end point.
 
 The following settings are available::
 
   [progress]
   delay = 3 # number of seconds (float) before showing the progress bar
   changedelay = 1 # changedelay: minimum delay before showing a new topic.
                   # If set to less than 3 * refresh, that value will
                   # be used instead.
   refresh = 0.1 # time in seconds between refreshes of the progress bar
   format = topic bar number estimate # format of the progress bar
   width = <none> # if set, the maximum width of the progress information
                  # (that is, min(width, term width) will be used)
   clear-complete = True # clear the progress bar after it's done
   disable = False # if true, don't show a progress bar
   assume-tty = False # if true, ALWAYS show a progress bar, unless
                      # disable is given
 
 Valid entries for the format field are topic, bar, number, unit,
 estimate, speed, and item. item defaults to the last 20 characters of
 the item, but this can be changed by adding either ``-<num>`` which
 would take the last num characters, or ``+<num>`` for the first num
 characters.
 """
 
 import sys
 import time
 import threading
 
 from mercurial.i18n import _
+# Note for extension authors: ONLY specify testedwith = 'internal' for
+# extensions which SHIP WITH MERCURIAL. Non-mainline extensions should
+# be specifying the version(s) of Mercurial they are tested with, or
+# leave the attribute unspecified.
 testedwith = 'internal'
 
 from mercurial import encoding
 
 def spacejoin(*args):
     return ' '.join(s for s in args if s)
 
 def shouldprint(ui):
     return not ui.plain() and (ui._isatty(sys.stderr) or
                                ui.configbool('progress', 'assume-tty'))
 
 def fmtremaining(seconds):
     if seconds < 60:
         # i18n: format XX seconds as "XXs"
         return _("%02ds") % (seconds)
     minutes = seconds // 60
     if minutes < 60:
         seconds -= minutes * 60
         # i18n: format X minutes and YY seconds as "XmYYs"
         return _("%dm%02ds") % (minutes, seconds)
     # we're going to ignore seconds in this case
     minutes += 1
     hours = minutes // 60
     minutes -= hours * 60
     if hours < 30:
         # i18n: format X hours and YY minutes as "XhYYm"
         return _("%dh%02dm") % (hours, minutes)
     # we're going to ignore minutes in this case
     hours += 1
     days = hours // 24
     hours -= days * 24
     if days < 15:
         # i18n: format X days and YY hours as "XdYYh"
         return _("%dd%02dh") % (days, hours)
     # we're going to ignore hours in this case
     days += 1
     weeks = days // 7
     days -= weeks * 7
     if weeks < 55:
         # i18n: format X weeks and YY days as "XwYYd"
         return _("%dw%02dd") % (weeks, days)
     # we're going to ignore days and treat a year as 52 weeks
     weeks += 1
     years = weeks // 52
     weeks -= years * 52
     # i18n: format X years and YY weeks as "XyYYw"
     return _("%dy%02dw") % (years, weeks)
 
 class progbar(object):
     def __init__(self, ui):
         self.ui = ui
         self._refreshlock = threading.Lock()
         self.resetstate()
 
     def resetstate(self):
         self.topics = []
         self.topicstates = {}
         self.starttimes = {}
         self.startvals = {}
         self.printed = False
         self.lastprint = time.time() + float(self.ui.config(
             'progress', 'delay', default=3))
         self.curtopic = None
         self.lasttopic = None
         self.indetcount = 0
         self.refresh = float(self.ui.config(
             'progress', 'refresh', default=0.1))
         self.changedelay = max(3 * self.refresh,
                                float(self.ui.config(
                                    'progress', 'changedelay', default=1)))
         self.order = self.ui.configlist(
             'progress', 'format',
             default=['topic', 'bar', 'number', 'estimate'])
 
     def show(self, now, topic, pos, item, unit, total):
         if not shouldprint(self.ui):
             return
         termwidth = self.width()
         self.printed = True
         head = ''
         needprogress = False
         tail = ''
         for indicator in self.order:
             add = ''
             if indicator == 'topic':
                 add = topic
             elif indicator == 'number':
                 if total:
                     add = ('% ' + str(len(str(total))) +
                            's/%s') % (pos, total)
                 else:
                     add = str(pos)
             elif indicator.startswith('item') and item:
                 slice = 'end'
                 if '-' in indicator:
                     wid = int(indicator.split('-')[1])
                 elif '+' in indicator:
                     slice = 'beginning'
                     wid = int(indicator.split('+')[1])
                 else:
                     wid = 20
                 if slice == 'end':
                     add = encoding.trim(item, wid, leftside=True)
                 else:
                     add = encoding.trim(item, wid)
                 add += (wid - encoding.colwidth(add)) * ' '
             elif indicator == 'bar':
                 add = ''
                 needprogress = True
             elif indicator == 'unit' and unit:
                 add = unit
             elif indicator == 'estimate':
                 add = self.estimate(topic, pos, total, now)
             elif indicator == 'speed':
                 add = self.speed(topic, pos, unit, now)
             if not needprogress:
                 head = spacejoin(head, add)
             else:
                 tail = spacejoin(tail, add)
         if needprogress:
             used = 0
             if head:
                 used += encoding.colwidth(head) + 1
             if tail:
                 used += encoding.colwidth(tail) + 1
             progwidth = termwidth - used - 3
             if total and pos <= total:
                 amt = pos * progwidth // total
                 bar = '=' * (amt - 1)
                 if amt > 0:
                     bar += '>'
                 bar += ' ' * (progwidth - amt)
             else:
                 progwidth -= 3
                 self.indetcount += 1
                 # mod the count by twice the width so we can make the
                 # cursor bounce between the right and left sides
                 amt = self.indetcount % (2 * progwidth)
                 amt -= progwidth
                 bar = (' ' * int(progwidth - abs(amt)) + '<=>' +
                        ' ' * int(abs(amt)))
             prog = ''.join(('[', bar , ']'))
             out = spacejoin(head, prog, tail)
         else:
             out = spacejoin(head, tail)
         sys.stderr.write('\r' + encoding.trim(out, termwidth))
         self.lasttopic = topic
         sys.stderr.flush()
 
     def clear(self):
         if not shouldprint(self.ui):
             return
         sys.stderr.write('\r%s\r' % (' ' * self.width()))
 
     def complete(self):
         if not shouldprint(self.ui):
             return
         if self.ui.configbool('progress', 'clear-complete', default=True):
             self.clear()
         else:
             sys.stderr.write('\n')
         sys.stderr.flush()
 
     def width(self):
         tw = self.ui.termwidth()
         return min(int(self.ui.config('progress', 'width', default=tw)), tw)
 
     def estimate(self, topic, pos, total, now):
         if total is None:
             return ''
         initialpos = self.startvals[topic]
         target = total - initialpos
         delta = pos - initialpos
         if delta > 0:
             elapsed = now - self.starttimes[topic]
             if elapsed > float(
                 self.ui.config('progress', 'estimate', default=2)):
                 seconds = (elapsed * (target - delta)) // delta + 1
                 return fmtremaining(seconds)
         return ''
 
     def speed(self, topic, pos, unit, now):
         initialpos = self.startvals[topic]
         delta = pos - initialpos
         elapsed = now - self.starttimes[topic]
         if elapsed > float(
             self.ui.config('progress', 'estimate', default=2)):
             return _('%d %s/sec') % (delta / elapsed, unit)
         return ''
 
     def _oktoprint(self, now):
         '''Check if conditions are met to print - e.g. changedelay elapsed'''
         if (self.lasttopic is None # first time we printed
             # not a topic change
             or self.curtopic == self.lasttopic
             # it's been long enough we should print anyway
             or now - self.lastprint >= self.changedelay):
             return True
         else:
             return False
 
     def progress(self, topic, pos, item='', unit='', total=None):
         now = time.time()
         self._refreshlock.acquire()
         try:
             if pos is None:
                 self.starttimes.pop(topic, None)
                 self.startvals.pop(topic, None)
                 self.topicstates.pop(topic, None)
                 # reset the progress bar if this is the outermost topic
                 if self.topics and self.topics[0] == topic and self.printed:
                     self.complete()
                     self.resetstate()
                 # truncate the list of topics assuming all topics within
                 # this one are also closed
                 if topic in self.topics:
                     self.topics = self.topics[:self.topics.index(topic)]
                     # reset the last topic to the one we just unwound to,
                     # so that higher-level topics will be stickier than
                     # lower-level topics
                     if self.topics:
                         self.lasttopic = self.topics[-1]
                     else:
                         self.lasttopic = None
             else:
                 if topic not in self.topics:
                     self.starttimes[topic] = now
                     self.startvals[topic] = pos
                     self.topics.append(topic)
                 self.topicstates[topic] = pos, item, unit, total
                 self.curtopic = topic
                 if now - self.lastprint >= self.refresh and self.topics:
                     if self._oktoprint(now):
                         self.lastprint = now
                         self.show(now, topic, *self.topicstates[topic])
         finally:
             self._refreshlock.release()
 
 _singleton = None
 
 def uisetup(ui):
     global _singleton
     class progressui(ui.__class__):
         _progbar = None
 
         def _quiet(self):
             return self.debugflag or self.quiet
 
         def progress(self, *args, **opts):
             if not self._quiet():
                 self._progbar.progress(*args, **opts)
             return super(progressui, self).progress(*args, **opts)
 
         def write(self, *args, **opts):
             if not self._quiet() and self._progbar.printed:
                 self._progbar.clear()
             return super(progressui, self).write(*args, **opts)
 
         def write_err(self, *args, **opts):
             if not self._quiet() and self._progbar.printed:
                 self._progbar.clear()
             return super(progressui, self).write_err(*args, **opts)
 
     # Apps that derive a class from ui.ui() can use
     # setconfig('progress', 'disable', 'True') to disable this extension
     if ui.configbool('progress', 'disable'):
         return
     if shouldprint(ui) and not ui.debugflag and not ui.quiet:
         ui.__class__ = progressui
         # we instantiate one globally shared progress bar to avoid
         # competing progress bars when multiple UI objects get created
         if not progressui._progbar:
             if _singleton is None:
                 _singleton = progbar(ui)
             progressui._progbar = _singleton
 
 def reposetup(ui, repo):
     uisetup(repo.ui)

hgext/purge.py

@@ -1,115 +1,119 b''
 # Copyright (C) 2006 - Marco Barisione <[e-mail]>
 #
 # This is a small extension for Mercurial (http://mercurial.selenic.com/)
 # that removes files not known to mercurial
 #
 # This program was inspired by the "cvspurge" script contained in CVS
 # utilities (http://www.red-bean.com/cvsutils/).
 #
 # For help on the usage of "hg purge" use:
 #  hg help purge
 #
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
 # the Free Software Foundation; either version 2 of the License, or
 # (at your option) any later version.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU General Public License
 # along with this program; if not, see <http://www.gnu.org/licenses/>.
 
 '''command to delete untracked files from the working directory'''
 
 from mercurial import util, commands, cmdutil, scmutil
 from mercurial.i18n import _
 import os
 
 cmdtable = {}
 command = cmdutil.command(cmdtable)
+# Note for extension authors: ONLY specify testedwith = 'internal' for
+# extensions which SHIP WITH MERCURIAL. Non-mainline extensions should
+# be specifying the version(s) of Mercurial they are tested with, or
+# leave the attribute unspecified.
 testedwith = 'internal'
 
 @command('purge|clean',
     [('a', 'abort-on-err', None, _('abort if an error occurs')),
     ('',  'all', None, _('purge ignored files too')),
     ('',  'dirs', None, _('purge empty directories')),
     ('',  'files', None, _('purge files')),
     ('p', 'print', None, _('print filenames instead of deleting them')),
     ('0', 'print0', None, _('end filenames with NUL, for use with xargs'
                             ' (implies -p/--print)')),
     ] + commands.walkopts,
     _('hg purge [OPTION]... [DIR]...'))
 def purge(ui, repo, *dirs, **opts):
     '''removes files not tracked by Mercurial
 
     Delete files not known to Mercurial. This is useful to test local
     and uncommitted changes in an otherwise-clean source tree.
 
     This means that purge will delete the following by default:
 
     - Unknown files: files marked with "?" by :hg:`status`
     - Empty directories: in fact Mercurial ignores directories unless
       they contain files under source control management
 
     But it will leave untouched:
 
     - Modified and unmodified tracked files
     - Ignored files (unless --all is specified)
     - New files added to the repository (with :hg:`add`)
 
     The --files and --dirs options can be used to direct purge to delete
     only files, only directories, or both. If neither option is given,
     both will be deleted.
 
     If directories are given on the command line, only files in these
     directories are considered.
 
     Be careful with purge, as you could irreversibly delete some files
     you forgot to add to the repository. If you only want to print the
     list of files that this program would delete, use the --print
     option.
     '''
     act = not opts['print']
     eol = '\n'
     if opts['print0']:
         eol = '\0'
         act = False # --print0 implies --print
     removefiles = opts['files']
     removedirs = opts['dirs']
     if not removefiles and not removedirs:
         removefiles = True
         removedirs = True
 
     def remove(remove_func, name):
         if act:
             try:
                 remove_func(repo.wjoin(name))
             except OSError:
                 m = _('%s cannot be removed') % name
                 if opts['abort_on_err']:
                     raise util.Abort(m)
                 ui.warn(_('warning: %s\n') % m)
         else:
             ui.write('%s%s' % (name, eol))
 
     match = scmutil.match(repo[None], dirs, opts)
     if removedirs:
         directories = []
         match.explicitdir = match.traversedir = directories.append
     status = repo.status(match=match, ignored=opts['all'], unknown=True)
 
     if removefiles:
         for f in sorted(status.unknown + status.ignored):
             if act:
                 ui.note(_('removing file %s\n') % f)
             remove(util.unlink, f)
 
     if removedirs:
         for f in sorted(directories, reverse=True):
             if match(f) and not os.listdir(repo.wjoin(f)):
                 if act:
                     ui.note(_('removing directory %s\n') % f)
                 remove(os.rmdir, f)