replace util.sort with sorted built-in

This is marginally faster for small and moderately-sized lists

hgext/bugzilla.py

@@ -1,417 +1,417 b''
 # bugzilla.py - bugzilla integration 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, incorporated herein by reference.
 
 '''Bugzilla integration
 
 This hook extension adds comments on bugs in Bugzilla when changesets
 that refer to bugs by Bugzilla ID are seen. The hook does not change
 bug status.
 
 The hook updates the Bugzilla database directly. Only Bugzilla
 installations using MySQL are supported.
 
 The hook relies on a Bugzilla script to send bug change notification
 emails. That script changes between Bugzilla versions; the
 'processmail' script used prior to 2.18 is replaced in 2.18 and
 subsequent versions by 'config/sendbugmail.pl'. Note that these will
 be run by Mercurial as the user pushing the change; you will need to
 ensure the Bugzilla install file permissions are set appropriately.
 
 Configuring the extension:
 
     [bugzilla]
 
     host       Hostname of the MySQL server holding the Bugzilla
                database.
     db         Name of the Bugzilla database in MySQL. Default 'bugs'.
     user       Username to use to access MySQL server. Default 'bugs'.
     password   Password to use to access MySQL server.
     timeout    Database connection timeout (seconds). Default 5.
     version    Bugzilla version. Specify '3.0' for Bugzilla versions
                3.0 and later, '2.18' for Bugzilla versions from 2.18
                and '2.16' for versions prior to 2.18.
     bzuser     Fallback Bugzilla user name to record comments with, if
                changeset committer cannot be found as a Bugzilla user.
     bzdir      Bugzilla install directory. Used by default notify.
                Default '/var/www/html/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".
     regexp     Regular expression to match bug IDs in changeset commit
                message. Must contain one "()" group. The default
                expression matches 'Bug 1234', 'Bug no. 1234', 'Bug
                number 1234', 'Bugs 1234,5678', 'Bug 1234 and 5678' and
                variations thereof. Matching is case insensitive.
     style      The style file to use when formatting comments.
     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}'
     strip      The number of slashes to strip from the front of {root}
                to produce {webroot}. Default 0.
     usermap    Path of file containing Mercurial committer ID to
                Bugzilla user ID mappings. If specified, the file
                should contain one mapping per line,
                "committer"="Bugzilla user". See also the [usermap]
                section.
 
     [usermap]
     Any entries in this section specify mappings of Mercurial
     committer ID to Bugzilla user ID. See also [bugzilla].usermap.
     "committer"="Bugzilla user"
 
     [web]
     baseurl    Base URL for browsing Mercurial repositories. Reference
                from templates as {hgweb}.
 
 Activating the extension:
 
     [extensions]
     hgext.bugzilla =
 
     [hooks]
     # run bugzilla hook on every change pulled or pushed in here
     incoming.bugzilla = python:hgext.bugzilla.hook
 
 Example configuration:
 
 This example configuration is for a collection of Mercurial
 repositories in /var/local/hg/repos/ used with a local Bugzilla 3.2
 installation in /opt/bugzilla-3.2.
 
     [bugzilla]
     host=localhost
     password=XYZZY
     version=3.0
     bzuser=[e-mail]
     bzdir=/opt/bugzilla-3.2
     template=Changeset {node|short} in {root|basename}.\\n{hgweb}/{webroot}/rev/{node|short}\\n\\n{desc}\\n
     strip=5
 
     [web]
     baseurl=http://dev.domain.com/hg
 
     [usermap]
     [e-mail]=[e-mail]
 
 Commits add a comment to the Bugzilla bug record of the form:
 
     Changeset 3b16791d6642 in repository-name.
     http://dev.domain.com/hg/repository-name/rev/3b16791d6642
 
     Changeset commit comment. Bug 1234.
 '''
 
 from mercurial.i18n import _
 from mercurial.node import short
 from mercurial import cmdutil, templater, util
 import re, time
 
 MySQLdb = None
 
 def buglist(ids):
     return '(' + ','.join(map(str, ids)) + ')'
 
 class bugzilla_2_16(object):
     '''support for bugzilla version 2.16.'''
 
     def __init__(self, ui):
         self.ui = 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))
         usermap = self.ui.config('bugzilla', 'usermap')
         if usermap:
             self.ui.readconfig(usermap, sections=['usermap'])
         self.ui.note(_('connecting to %s:%s as %s, password %s\n') %
                      (host, db, user, '*' * len(passwd)))
         self.conn = 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 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, ids):
         '''filter not-existing bug ids from list.'''
         self.run('select bug_id from bugs where bug_id in %s' % buglist(ids))
-        return util.sort([c[0] for c in self.cursor.fetchall()])
+        return sorted([c[0] for c in self.cursor.fetchall()])
 
     def filter_unknown_bug_ids(self, node, ids):
         '''filter bug ids from list that already refer to this changeset.'''
 
         self.run('''select bug_id from longdescs where
                     bug_id in %s and thetext like "%%%s%%"''' %
                  (buglist(ids), short(node)))
         unknown = set(ids)
         for (id,) in self.cursor.fetchall():
             self.ui.status(_('bug %d already knows about changeset %s\n') %
                            (id, short(node)))
             unknown.discard(id)
-        return util.sort(unknown)
+        return sorted(unknown)
 
     def notify(self, ids, 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 ids:
             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.explain_exit(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 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
 
     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 add_comment(self, bugid, text, committer):
         '''add comment to bug. try adding comment as committer of
         changeset, otherwise as default bugzilla user.'''
         (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 bugzilla_2_18(bugzilla_2_16):
     '''support for bugzilla 2.18 series.'''
 
     def __init__(self, ui):
         bugzilla_2_16.__init__(self, ui)
         self.default_notify = "cd %(bzdir)s && perl -T contrib/sendbugmail.pl %(id)s %(user)s"
 
 class bugzilla_3_0(bugzilla_2_18):
     '''support for bugzilla 3.0 series.'''
 
     def __init__(self, ui):
         bugzilla_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]
 
 class bugzilla(object):
     # supported versions of bugzilla. different versions have
     # different schemas.
     _versions = {
         '2.16': bugzilla_2_16,
         '2.18': bugzilla_2_18,
         '3.0':  bugzilla_3_0
         }
 
     _default_bug_re = (r'bugs?\s*,?\s*(?:#|nos?\.?|num(?:ber)?s?)?\s*'
                        r'((?:\d+\s*(?:,?\s*(?:and)?)?\s*)+)')
 
     _bz = None
 
     def __init__(self, ui, repo):
         self.ui = ui
         self.repo = repo
 
     def bz(self):
         '''return object that knows how to talk to bugzilla version in
         use.'''
 
         if bugzilla._bz is None:
             bzversion = self.ui.config('bugzilla', 'version')
             try:
                 bzclass = bugzilla._versions[bzversion]
             except KeyError:
                 raise util.Abort(_('bugzilla version %s not supported') %
                                  bzversion)
             bugzilla._bz = bzclass(self.ui)
         return bugzilla._bz
 
     def __getattr__(self, key):
         return getattr(self.bz(), key)
 
     _bug_re = None
     _split_re = None
 
     def find_bug_ids(self, ctx):
         '''find valid bug ids that are referred to in changeset
         comments and that do not already have references to this
         changeset.'''
 
         if bugzilla._bug_re is None:
             bugzilla._bug_re = re.compile(
                 self.ui.config('bugzilla', 'regexp', bugzilla._default_bug_re),
                 re.IGNORECASE)
             bugzilla._split_re = re.compile(r'\D+')
         start = 0
         ids = {}
         while True:
             m = bugzilla._bug_re.search(ctx.description(), start)
             if not m:
                 break
             start = m.end()
             for id in bugzilla._split_re.split(m.group(1)):
                 if not id: continue
                 ids[int(id)] = 1
         ids = ids.keys()
         if ids:
             ids = self.filter_real_bug_ids(ids)
         if ids:
             ids = self.filter_unknown_bug_ids(ctx.node(), ids)
         return ids
 
     def update(self, bugid, 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')
         t = cmdutil.changeset_templater(self.ui, self.repo,
                                         False, None, mapfile, False)
         if not mapfile and not tmpl:
             tmpl = _('changeset {node|short} in repo {root} refers '
                      'to bug {bug}.\ndetails:\n\t{desc|tabindent}')
         if tmpl:
             tmpl = templater.parsestring(tmpl, quoted=False)
             t.use_template(tmpl)
         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.add_comment(bugid, data, util.email(ctx.user()))
 
 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.'''
     try:
         import MySQLdb as mysql
         global MySQLdb
         MySQLdb = mysql
     except ImportError, err:
         raise util.Abort(_('python mysql support not available: %s') % err)
 
     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]
         ids = bz.find_bug_ids(ctx)
         if ids:
             for id in ids:
                 bz.update(id, ctx)
             bz.notify(ids, util.email(ctx.user()))
     except MySQLdb.MySQLError, err:
         raise util.Abort(_('database error: %s') % err[1])
 

hgext/convert/cvs.py

@@ -1,362 +1,362 b''
 # CVS conversion code inspired by hg-cvs-import and git-cvsimport
 
 import os, locale, re, socket, errno
 from cStringIO import StringIO
 from mercurial import util
 from mercurial.i18n import _
 
 from common import NoRepo, commit, converter_source, checktool
 import cvsps
 
 class convert_cvs(converter_source):
     def __init__(self, ui, path, rev=None):
         super(convert_cvs, self).__init__(ui, path, rev=rev)
 
         cvs = os.path.join(path, "CVS")
         if not os.path.exists(cvs):
             raise NoRepo("%s does not look like a CVS checkout" % path)
 
         checktool('cvs')
         self.cmd = ui.config('convert', 'cvsps', 'builtin')
         cvspsexe = self.cmd.split(None, 1)[0]
         self.builtin = cvspsexe == 'builtin'
 
         if not self.builtin:
             checktool(cvspsexe)
 
         self.changeset = None
         self.files = {}
         self.tags = {}
         self.lastbranch = {}
         self.parent = {}
         self.socket = None
         self.cvsroot = file(os.path.join(cvs, "Root")).read()[:-1]
         self.cvsrepo = file(os.path.join(cvs, "Repository")).read()[:-1]
         self.encoding = locale.getpreferredencoding()
 
         self._connect()
 
     def _parse(self):
         if self.changeset is not None:
             return
         self.changeset = {}
 
         maxrev = 0
         cmd = self.cmd
         if self.rev:
             # TODO: handle tags
             try:
                 # patchset number?
                 maxrev = int(self.rev)
             except ValueError:
                 try:
                     # date
                     util.parsedate(self.rev, ['%Y/%m/%d %H:%M:%S'])
                     cmd = '%s -d "1970/01/01 00:00:01" -d "%s"' % (cmd, self.rev)
                 except util.Abort:
                     raise util.Abort(_('revision %s is not a patchset number or date') % self.rev)
 
         d = os.getcwd()
         try:
             os.chdir(self.path)
             id = None
             state = 0
             filerevids = {}
 
             if self.builtin:
                 # builtin cvsps code
                 self.ui.status(_('using builtin cvsps\n'))
 
                 cache = 'update'
                 if not self.ui.configbool('convert', 'cvsps.cache', True):
                     cache = None
                 db = cvsps.createlog(self.ui, cache=cache)
                 db = cvsps.createchangeset(self.ui, db,
                       fuzz=int(self.ui.config('convert', 'cvsps.fuzz', 60)),
                       mergeto=self.ui.config('convert', 'cvsps.mergeto', None),
                       mergefrom=self.ui.config('convert', 'cvsps.mergefrom', None))
 
                 for cs in db:
                     if maxrev and cs.id>maxrev:
                         break
                     id = str(cs.id)
                     cs.author = self.recode(cs.author)
                     self.lastbranch[cs.branch] = id
                     cs.comment = self.recode(cs.comment)
                     date = util.datestr(cs.date)
                     self.tags.update(dict.fromkeys(cs.tags, id))
 
                     files = {}
                     for f in cs.entries:
                         files[f.file] = "%s%s" % ('.'.join([str(x) for x in f.revision]),
                                                   ['', '(DEAD)'][f.dead])
 
                     # add current commit to set
                     c = commit(author=cs.author, date=date,
                              parents=[str(p.id) for p in cs.parents],
                              desc=cs.comment, branch=cs.branch or '')
                     self.changeset[id] = c
                     self.files[id] = files
             else:
                 # external cvsps
                 for l in util.popen(cmd):
                     if state == 0: # header
                         if l.startswith("PatchSet"):
                             id = l[9:-2]
                             if maxrev and int(id) > maxrev:
                                 # ignore everything
                                 state = 3
                         elif l.startswith("Date:"):
                             date = util.parsedate(l[6:-1], ["%Y/%m/%d %H:%M:%S"])
                             date = util.datestr(date)
                         elif l.startswith("Branch:"):
                             branch = l[8:-1]
                             self.parent[id] = self.lastbranch.get(branch, 'bad')
                             self.lastbranch[branch] = id
                         elif l.startswith("Ancestor branch:"):
                             ancestor = l[17:-1]
                             # figure out the parent later
                             self.parent[id] = self.lastbranch[ancestor]
                         elif l.startswith("Author:"):
                             author = self.recode(l[8:-1])
                         elif l.startswith("Tag:") or l.startswith("Tags:"):
                             t = l[l.index(':')+1:]
                             t = [ut.strip() for ut in t.split(',')]
                             if (len(t) > 1) or (t[0] and (t[0] != "(none)")):
                                 self.tags.update(dict.fromkeys(t, id))
                         elif l.startswith("Log:"):
                             # switch to gathering log
                             state = 1
                             log = ""
                     elif state == 1: # log
                         if l == "Members: \n":
                             # switch to gathering members
                             files = {}
                             oldrevs = []
                             log = self.recode(log[:-1])
                             state = 2
                         else:
                             # gather log
                             log += l
                     elif state == 2: # members
                         if l == "\n": # start of next entry
                             state = 0
                             p = [self.parent[id]]
                             if id == "1":
                                 p = []
                             if branch == "HEAD":
                                 branch = ""
                             if branch:
                                 latest = 0
                                 # the last changeset that contains a base
                                 # file is our parent
                                 for r in oldrevs:
                                     latest = max(filerevids.get(r, 0), latest)
                                 if latest:
                                     p = [latest]
 
                             # add current commit to set
                             c = commit(author=author, date=date, parents=p,
                                        desc=log, branch=branch)
                             self.changeset[id] = c
                             self.files[id] = files
                         else:
                             colon = l.rfind(':')
                             file = l[1:colon]
                             rev = l[colon+1:-2]
                             oldrev, rev = rev.split("->")
                             files[file] = rev
 
                             # save some information for identifying branch points
                             oldrevs.append("%s:%s" % (oldrev, file))
                             filerevids["%s:%s" % (rev, file)] = id
                     elif state == 3:
                         # swallow all input
                         continue
 
             self.heads = self.lastbranch.values()
         finally:
             os.chdir(d)
 
     def _connect(self):
         root = self.cvsroot
         conntype = None
         user, host = None, None
         cmd = ['cvs', 'server']
 
         self.ui.status(_("connecting to %s\n") % root)
 
         if root.startswith(":pserver:"):
             root = root[9:]
             m = re.match(r'(?:(.*?)(?::(.*?))?@)?([^:\/]*)(?::(\d*))?(.*)',
                          root)
             if m:
                 conntype = "pserver"
                 user, passw, serv, port, root = m.groups()
                 if not user:
                     user = "anonymous"
                 if not port:
                     port = 2401
                 else:
                     port = int(port)
                 format0 = ":pserver:%s@%s:%s" % (user, serv, root)
                 format1 = ":pserver:%s@%s:%d%s" % (user, serv, port, root)
 
                 if not passw:
                     passw = "A"
                     cvspass = os.path.expanduser("~/.cvspass")
                     try:
                         pf = open(cvspass)
                         for line in pf.read().splitlines():
                             part1, part2 = line.split(' ', 1)
                             if part1 == '/1':
                                 # /1 :pserver:[e-mail]:2401/cvsroot/foo Ah<Z
                                 part1, part2 = part2.split(' ', 1)
                                 format = format1
                             else:
                                 # :pserver:[e-mail]:/cvsroot/foo Ah<Z
                                 format = format0
                             if part1 == format:
                                 passw = part2
                                 break
                         pf.close()
                     except IOError, inst:
                         if inst.errno != errno.ENOENT:
                             if not getattr(inst, 'filename', None):
                                 inst.filename = cvspass
                             raise
 
                 sck = socket.socket()
                 sck.connect((serv, port))
                 sck.send("\n".join(["BEGIN AUTH REQUEST", root, user, passw,
                                     "END AUTH REQUEST", ""]))
                 if sck.recv(128) != "I LOVE YOU\n":
                     raise util.Abort(_("CVS pserver authentication failed"))
 
                 self.writep = self.readp = sck.makefile('r+')
 
         if not conntype and root.startswith(":local:"):
             conntype = "local"
             root = root[7:]
 
         if not conntype:
             # :ext:user@host/home/user/path/to/cvsroot
             if root.startswith(":ext:"):
                 root = root[5:]
             m = re.match(r'(?:([^@:/]+)@)?([^:/]+):?(.*)', root)
             # Do not take Windows path "c:\foo\bar" for a connection strings
             if os.path.isdir(root) or not m:
                 conntype = "local"
             else:
                 conntype = "rsh"
                 user, host, root = m.group(1), m.group(2), m.group(3)
 
         if conntype != "pserver":
             if conntype == "rsh":
                 rsh = os.environ.get("CVS_RSH") or "ssh"
                 if user:
                     cmd = [rsh, '-l', user, host] + cmd
                 else:
                     cmd = [rsh, host] + cmd
 
             # popen2 does not support argument lists under Windows
             cmd = [util.shellquote(arg) for arg in cmd]
             cmd = util.quotecommand(' '.join(cmd))
             self.writep, self.readp = util.popen2(cmd, 'b')
 
         self.realroot = root
 
         self.writep.write("Root %s\n" % root)
         self.writep.write("Valid-responses ok error Valid-requests Mode"
                           " M Mbinary E Checked-in Created Updated"
                           " Merged Removed\n")
         self.writep.write("valid-requests\n")
         self.writep.flush()
         r = self.readp.readline()
         if not r.startswith("Valid-requests"):
             raise util.Abort(_("server sucks"))
         if "UseUnchanged" in r:
             self.writep.write("UseUnchanged\n")
             self.writep.flush()
             r = self.readp.readline()
 
     def getheads(self):
         self._parse()
         return self.heads
 
     def _getfile(self, name, rev):
 
         def chunkedread(fp, count):
             # file-objects returned by socked.makefile() do not handle
             # large read() requests very well.
             chunksize = 65536
             output = StringIO()
             while count > 0:
                 data = fp.read(min(count, chunksize))
                 if not data:
                     raise util.Abort(_("%d bytes missing from remote file") % count)
                 count -= len(data)
                 output.write(data)
             return output.getvalue()
 
         if rev.endswith("(DEAD)"):
             raise IOError
 
         args = ("-N -P -kk -r %s --" % rev).split()
         args.append(self.cvsrepo + '/' + name)
         for x in args:
             self.writep.write("Argument %s\n" % x)
         self.writep.write("Directory .\n%s\nco\n" % self.realroot)
         self.writep.flush()
 
         data = ""
         while 1:
             line = self.readp.readline()
             if line.startswith("Created ") or line.startswith("Updated "):
                 self.readp.readline() # path
                 self.readp.readline() # entries
                 mode = self.readp.readline()[:-1]
                 count = int(self.readp.readline()[:-1])
                 data = chunkedread(self.readp, count)
             elif line.startswith(" "):
                 data += line[1:]
             elif line.startswith("M "):
                 pass
             elif line.startswith("Mbinary "):
                 count = int(self.readp.readline()[:-1])
                 data = chunkedread(self.readp, count)
             else:
                 if line == "ok\n":
                     return (data, "x" in mode and "x" or "")
                 elif line.startswith("E "):
                     self.ui.warn(_("cvs server: %s\n") % line[2:])
                 elif line.startswith("Remove"):
                     self.readp.readline()
                 else:
                     raise util.Abort(_("unknown CVS response: %s") % line)
 
     def getfile(self, file, rev):
         self._parse()
         data, mode = self._getfile(file, rev)
         self.modecache[(file, rev)] = mode
         return data
 
     def getmode(self, file, rev):
         return self.modecache[(file, rev)]
 
     def getchanges(self, rev):
         self._parse()
         self.modecache = {}
-        return util.sort(self.files[rev].items()), {}
+        return sorted(self.files[rev].iteritems()), {}
 
     def getcommit(self, rev):
         self._parse()
         return self.changeset[rev]
 
     def gettags(self):
         self._parse()
         return self.tags
 
     def getchangedfiles(self, rev, i):
         self._parse()
-        return util.sort(self.files[rev].keys())
+        return sorted(self.files[rev])

hgext/convert/cvsps.py

@@ -1,782 +1,782 b''
 #
 # Mercurial built-in replacement for cvsps.
 #
 # Copyright 2008, Frank Kingswood <[e-mail]>
 #
 # This software may be used and distributed according to the terms
 # of the GNU General Public License, incorporated herein by reference.
 
 import os
 import re
 import cPickle as pickle
 from mercurial import util
 from mercurial.i18n import _
 
 def listsort(list, key):
     "helper to sort by key in Python 2.3"
     try:
         list.sort(key=key)
     except TypeError:
         list.sort(lambda l, r: cmp(key(l), key(r)))
 
 class logentry(object):
     '''Class logentry has the following attributes:
         .author    - author name as CVS knows it
         .branch    - name of branch this revision is on
         .branches  - revision tuple of branches starting at this revision
         .comment   - commit message
         .date      - the commit date as a (time, tz) tuple
         .dead      - true if file revision is dead
         .file      - Name of file
         .lines     - a tuple (+lines, -lines) or None
         .parent    - Previous revision of this entry
         .rcs       - name of file as returned from CVS
         .revision  - revision number as tuple
         .tags      - list of tags on the file
         .synthetic - is this a synthetic "file ... added on ..." revision?
         .mergepoint- the branch that has been merged from (if present in rlog output)
     '''
     def __init__(self, **entries):
         self.__dict__.update(entries)
 
     def __repr__(self):
         return "<%s at 0x%x: %s %s>" % (self.__class__.__name__,
                                         id(self),
                                         self.file,
                                         ".".join(map(str, self.revision)))
 
 class logerror(Exception):
     pass
 
 def getrepopath(cvspath):
     """Return the repository path from a CVS path.
 
     >>> getrepopath('/foo/bar')
     '/foo/bar'
     >>> getrepopath('c:/foo/bar')
     'c:/foo/bar'
     >>> getrepopath(':pserver:10/foo/bar')
     '/foo/bar'
     >>> getrepopath(':pserver:10c:/foo/bar')
     '/foo/bar'
     >>> getrepopath(':pserver:/foo/bar')
     '/foo/bar'
     >>> getrepopath(':pserver:c:/foo/bar')
     'c:/foo/bar'
     >>> getrepopath(':pserver:[e-mail]:/foo/bar')
     '/foo/bar'
     >>> getrepopath(':pserver:[e-mail]:c:/foo/bar')
     'c:/foo/bar'
     """
     # According to CVS manual, CVS paths are expressed like:
     # [:method:][[user][:password]@]hostname[:[port]]/path/to/repository
     #
     # Unfortunately, Windows absolute paths start with a drive letter
     # like 'c:' making it harder to parse. Here we assume that drive
     # letters are only one character long and any CVS component before
     # the repository path is at least 2 characters long, and use this
     # to disambiguate.
     parts = cvspath.split(':')
     if len(parts) == 1:
         return parts[0]
     # Here there is an ambiguous case if we have a port number
     # immediately followed by a Windows driver letter. We assume this
     # never happens and decide it must be CVS path component,
     # therefore ignoring it.
     if len(parts[-2]) > 1:
         return parts[-1].lstrip('0123456789')
     return parts[-2] + ':' + parts[-1]
 
 def createlog(ui, directory=None, root="", rlog=True, cache=None):
     '''Collect the CVS rlog'''
 
     # Because we store many duplicate commit log messages, reusing strings
     # saves a lot of memory and pickle storage space.
     _scache = {}
     def scache(s):
         "return a shared version of a string"
         return _scache.setdefault(s, s)
 
     ui.status(_('collecting CVS rlog\n'))
 
     log = []      # list of logentry objects containing the CVS state
 
     # patterns to match in CVS (r)log output, by state of use
     re_00 = re.compile('RCS file: (.+)$')
     re_01 = re.compile('cvs \\[r?log aborted\\]: (.+)$')
     re_02 = re.compile('cvs (r?log|server): (.+)\n$')
     re_03 = re.compile("(Cannot access.+CVSROOT)|(can't create temporary directory.+)$")
     re_10 = re.compile('Working file: (.+)$')
     re_20 = re.compile('symbolic names:')
     re_30 = re.compile('\t(.+): ([\\d.]+)$')
     re_31 = re.compile('----------------------------$')
     re_32 = re.compile('=============================================================================$')
     re_50 = re.compile('revision ([\\d.]+)(\s+locked by:\s+.+;)?$')
     re_60 = re.compile(r'date:\s+(.+);\s+author:\s+(.+);\s+state:\s+(.+?);(\s+lines:\s+(\+\d+)?\s+(-\d+)?;)?(.*mergepoint:\s+([^;]+);)?')
     re_70 = re.compile('branches: (.+);$')
 
     file_added_re = re.compile(r'file [^/]+ was (initially )?added on branch')
 
     prefix = ''   # leading path to strip of what we get from CVS
 
     if directory is None:
         # Current working directory
 
         # Get the real directory in the repository
         try:
             prefix = file(os.path.join('CVS','Repository')).read().strip()
             if prefix == ".":
                 prefix = ""
             directory = prefix
         except IOError:
             raise logerror('Not a CVS sandbox')
 
         if prefix and not prefix.endswith(os.sep):
             prefix += os.sep
 
         # Use the Root file in the sandbox, if it exists
         try:
             root = file(os.path.join('CVS','Root')).read().strip()
         except IOError:
             pass
 
     if not root:
         root = os.environ.get('CVSROOT', '')
 
     # read log cache if one exists
     oldlog = []
     date = None
 
     if cache:
         cachedir = os.path.expanduser('~/.hg.cvsps')
         if not os.path.exists(cachedir):
             os.mkdir(cachedir)
 
         # The cvsps cache pickle needs a uniquified name, based on the
         # repository location. The address may have all sort of nasties
         # in it, slashes, colons and such. So here we take just the
         # alphanumerics, concatenated in a way that does not mix up the
         # various components, so that
         #    :pserver:user@server:/path
         # and
         #    /pserver/user/server/path
         # are mapped to different cache file names.
         cachefile = root.split(":") + [directory, "cache"]
         cachefile = ['-'.join(re.findall(r'\w+', s)) for s in cachefile if s]
         cachefile = os.path.join(cachedir,
                                  '.'.join([s for s in cachefile if s]))
 
     if cache == 'update':
         try:
             ui.note(_('reading cvs log cache %s\n') % cachefile)
             oldlog = pickle.load(file(cachefile))
             ui.note(_('cache has %d log entries\n') % len(oldlog))
         except Exception, e:
             ui.note(_('error reading cache: %r\n') % e)
 
         if oldlog:
             date = oldlog[-1].date    # last commit date as a (time,tz) tuple
             date = util.datestr(date, '%Y/%m/%d %H:%M:%S %1%2')
 
     # build the CVS commandline
     cmd = ['cvs', '-q']
     if root:
         cmd.append('-d%s' % root)
         p = util.normpath(getrepopath(root))
         if not p.endswith('/'):
             p += '/'
         prefix = p + util.normpath(prefix)
     cmd.append(['log', 'rlog'][rlog])
     if date:
         # no space between option and date string
         cmd.append('-d>%s' % date)
     cmd.append(directory)
 
     # state machine begins here
     tags = {}     # dictionary of revisions on current file with their tags
     branchmap = {} # mapping between branch names and revision numbers
     state = 0
     store = False # set when a new record can be appended
 
     cmd = [util.shellquote(arg) for arg in cmd]
     ui.note(_("running %s\n") % (' '.join(cmd)))
     ui.debug(_("prefix=%r directory=%r root=%r\n") % (prefix, directory, root))
 
     pfp = util.popen(' '.join(cmd))
     peek = pfp.readline()
     while True:
         line = peek
         if line == '':
             break
         peek = pfp.readline()
         if line.endswith('\n'):
             line = line[:-1]
         #ui.debug('state=%d line=%r\n' % (state, line))
 
         if state == 0:
             # initial state, consume input until we see 'RCS file'
             match = re_00.match(line)
             if match:
                 rcs = match.group(1)
                 tags = {}
                 if rlog:
                     filename = util.normpath(rcs[:-2])
                     if filename.startswith(prefix):
                         filename = filename[len(prefix):]
                     if filename.startswith('/'):
                         filename = filename[1:]
                     if filename.startswith('Attic/'):
                         filename = filename[6:]
                     else:
                         filename = filename.replace('/Attic/', '/')
                     state = 2
                     continue
                 state = 1
                 continue
             match = re_01.match(line)
             if match:
                 raise Exception(match.group(1))
             match = re_02.match(line)
             if match:
                 raise Exception(match.group(2))
             if re_03.match(line):
                 raise Exception(line)
 
         elif state == 1:
             # expect 'Working file' (only when using log instead of rlog)
             match = re_10.match(line)
             assert match, _('RCS file must be followed by working file')
             filename = util.normpath(match.group(1))
             state = 2
 
         elif state == 2:
             # expect 'symbolic names'
             if re_20.match(line):
                 branchmap = {}
                 state = 3
 
         elif state == 3:
             # read the symbolic names and store as tags
             match = re_30.match(line)
             if match:
                 rev = [int(x) for x in match.group(2).split('.')]
 
                 # Convert magic branch number to an odd-numbered one
                 revn = len(rev)
                 if revn > 3 and (revn % 2) == 0 and rev[-2] == 0:
                     rev = rev[:-2] + rev[-1:]
                 rev = tuple(rev)
 
                 if rev not in tags:
                     tags[rev] = []
                 tags[rev].append(match.group(1))
                 branchmap[match.group(1)] = match.group(2)
 
             elif re_31.match(line):
                 state = 5
             elif re_32.match(line):
                 state = 0
 
         elif state == 4:
             # expecting '------' separator before first revision
             if re_31.match(line):
                 state = 5
             else:
                 assert not re_32.match(line), _('must have at least some revisions')
 
         elif state == 5:
             # expecting revision number and possibly (ignored) lock indication
             # we create the logentry here from values stored in states 0 to 4,
             # as this state is re-entered for subsequent revisions of a file.
             match = re_50.match(line)
             assert match, _('expected revision number')
             e = logentry(rcs=scache(rcs), file=scache(filename),
                     revision=tuple([int(x) for x in match.group(1).split('.')]),
                     branches=[], parent=None,
                     synthetic=False)
             state = 6
 
         elif state == 6:
             # expecting date, author, state, lines changed
             match = re_60.match(line)
             assert match, _('revision must be followed by date line')
             d = match.group(1)
             if d[2] == '/':
                 # Y2K
                 d = '19' + d
 
             if len(d.split()) != 3:
                 # cvs log dates always in GMT
                 d = d + ' UTC'
             e.date = util.parsedate(d, ['%y/%m/%d %H:%M:%S', '%Y/%m/%d %H:%M:%S', '%Y-%m-%d %H:%M:%S'])
             e.author = scache(match.group(2))
             e.dead = match.group(3).lower() == 'dead'
 
             if match.group(5):
                 if match.group(6):
                     e.lines = (int(match.group(5)), int(match.group(6)))
                 else:
                     e.lines = (int(match.group(5)), 0)
             elif match.group(6):
                 e.lines = (0, int(match.group(6)))
             else:
                 e.lines = None
 
             if match.group(7): # cvsnt mergepoint
                 myrev = match.group(8).split('.')
                 if len(myrev) == 2: # head
                     e.mergepoint = 'HEAD'
                 else:
                     myrev = '.'.join(myrev[:-2] + ['0', myrev[-2]])
                     branches = [b for b in branchmap if branchmap[b] == myrev]
                     assert len(branches) == 1, 'unknown branch: %s' % e.mergepoint
                     e.mergepoint = branches[0]
             else:
                 e.mergepoint = None
             e.comment = []
             state = 7
 
         elif state == 7:
             # read the revision numbers of branches that start at this revision
             # or store the commit log message otherwise
             m = re_70.match(line)
             if m:
                 e.branches = [tuple([int(y) for y in x.strip().split('.')])
                                 for x in m.group(1).split(';')]
                 state = 8
             elif re_31.match(line) and re_50.match(peek):
                 state = 5
                 store = True
             elif re_32.match(line):
                 state = 0
                 store = True
             else:
                 e.comment.append(line)
 
         elif state == 8:
             # store commit log message
             if re_31.match(line):
                 state = 5
                 store = True
             elif re_32.match(line):
                 state = 0
                 store = True
             else:
                 e.comment.append(line)
 
         # When a file is added on a branch B1, CVS creates a synthetic
         # dead trunk revision 1.1 so that the branch has a root.
         # Likewise, if you merge such a file to a later branch B2 (one
         # that already existed when the file was added on B1), CVS
         # creates a synthetic dead revision 1.1.x.1 on B2.  Don't drop
         # these revisions now, but mark them synthetic so
         # createchangeset() can take care of them.
         if (store and
               e.dead and
               e.revision[-1] == 1 and      # 1.1 or 1.1.x.1
               len(e.comment) == 1 and
               file_added_re.match(e.comment[0])):
             ui.debug(_('found synthetic revision in %s: %r\n')
                      % (e.rcs, e.comment[0]))
             e.synthetic = True
 
         if store:
             # clean up the results and save in the log.
             store = False
-            e.tags = util.sort([scache(x) for x in tags.get(e.revision, [])])
+            e.tags = sorted([scache(x) for x in tags.get(e.revision, [])])
             e.comment = scache('\n'.join(e.comment))
 
             revn = len(e.revision)
             if revn > 3 and (revn % 2) == 0:
                 e.branch = tags.get(e.revision[:-1], [None])[0]
             else:
                 e.branch = None
 
             log.append(e)
 
             if len(log) % 100 == 0:
                 ui.status(util.ellipsis('%d %s' % (len(log), e.file), 80)+'\n')
 
     listsort(log, key=lambda x:(x.rcs, x.revision))
 
     # find parent revisions of individual files
     versions = {}
     for e in log:
         branch = e.revision[:-1]
         p = versions.get((e.rcs, branch), None)
         if p is None:
             p = e.revision[:-2]
         e.parent = p
         versions[(e.rcs, branch)] = e.revision
 
     # update the log cache
     if cache:
         if log:
             # join up the old and new logs
             listsort(log, key=lambda x:x.date)
 
             if oldlog and oldlog[-1].date >= log[0].date:
                 raise logerror('Log cache overlaps with new log entries,'
                                ' re-run without cache.')
 
             log = oldlog + log
 
             # write the new cachefile
             ui.note(_('writing cvs log cache %s\n') % cachefile)
             pickle.dump(log, file(cachefile, 'w'))
         else:
             log = oldlog
 
     ui.status(_('%d log entries\n') % len(log))
 
     return log
 
 
 class changeset(object):
     '''Class changeset has the following attributes:
         .id        - integer identifying this changeset (list index)
         .author    - author name as CVS knows it
         .branch    - name of branch this changeset is on, or None
         .comment   - commit message
         .date      - the commit date as a (time,tz) tuple
         .entries   - list of logentry objects in this changeset
         .parents   - list of one or two parent changesets
         .tags      - list of tags on this changeset
         .synthetic - from synthetic revision "file ... added on branch ..."
         .mergepoint- the branch that has been merged from (if present in rlog output)
     '''
     def __init__(self, **entries):
         self.__dict__.update(entries)
 
     def __repr__(self):
         return "<%s at 0x%x: %s>" % (self.__class__.__name__,
                                      id(self),
                                      getattr(self, 'id', "(no id)"))
 
 def createchangeset(ui, log, fuzz=60, mergefrom=None, mergeto=None):
     '''Convert log into changesets.'''
 
     ui.status(_('creating changesets\n'))
 
     # Merge changesets
 
     listsort(log, key=lambda x:(x.comment, x.author, x.branch, x.date))
 
     changesets = []
     files = {}
     c = None
     for i, e in enumerate(log):
 
         # Check if log entry belongs to the current changeset or not.
         if not (c and
                   e.comment == c.comment and
                   e.author == c.author and
                   e.branch == c.branch and
                   ((c.date[0] + c.date[1]) <=
                    (e.date[0] + e.date[1]) <=
                    (c.date[0] + c.date[1]) + fuzz) and
                   e.file not in files):
             c = changeset(comment=e.comment, author=e.author,
                           branch=e.branch, date=e.date, entries=[],
                           mergepoint=getattr(e, 'mergepoint', None))
             changesets.append(c)
             files = {}
             if len(changesets) % 100 == 0:
                 t = '%d %s' % (len(changesets), repr(e.comment)[1:-1])
                 ui.status(util.ellipsis(t, 80) + '\n')
 
         c.entries.append(e)
         files[e.file] = True
         c.date = e.date       # changeset date is date of latest commit in it
 
     # Mark synthetic changesets
 
     for c in changesets:
         # Synthetic revisions always get their own changeset, because
         # the log message includes the filename.  E.g. if you add file3
         # and file4 on a branch, you get four log entries and three
         # changesets:
         #   "File file3 was added on branch ..." (synthetic, 1 entry)
         #   "File file4 was added on branch ..." (synthetic, 1 entry)
         #   "Add file3 and file4 to fix ..."     (real, 2 entries)
         # Hence the check for 1 entry here.
         synth = getattr(c.entries[0], 'synthetic', None)
         c.synthetic = (len(c.entries) == 1 and synth)
 
     # Sort files in each changeset
 
     for c in changesets:
         def pathcompare(l, r):
             'Mimic cvsps sorting order'
             l = l.split('/')
             r = r.split('/')
             nl = len(l)
             nr = len(r)
             n = min(nl, nr)
             for i in range(n):
                 if i + 1 == nl and nl < nr:
                     return -1
                 elif i + 1 == nr and nl > nr:
                     return +1
                 elif l[i] < r[i]:
                     return -1
                 elif l[i] > r[i]:
                     return +1
             return 0
         def entitycompare(l, r):
             return pathcompare(l.file, r.file)
 
         c.entries.sort(entitycompare)
 
     # Sort changesets by date
 
     def cscmp(l, r):
         d = sum(l.date) - sum(r.date)
         if d:
             return d
 
         # detect vendor branches and initial commits on a branch
         le = {}
         for e in l.entries:
             le[e.rcs] = e.revision
         re = {}
         for e in r.entries:
             re[e.rcs] = e.revision
 
         d = 0
         for e in l.entries:
             if re.get(e.rcs, None) == e.parent:
                 assert not d
                 d = 1
                 break
 
         for e in r.entries:
             if le.get(e.rcs, None) == e.parent:
                 assert not d
                 d = -1
                 break
 
         return d
 
     changesets.sort(cscmp)
 
     # Collect tags
 
     globaltags = {}
     for c in changesets:
         tags = {}
         for e in c.entries:
             for tag in e.tags:
                 # remember which is the latest changeset to have this tag
                 globaltags[tag] = c
 
     for c in changesets:
         tags = {}
         for e in c.entries:
             for tag in e.tags:
                 tags[tag] = True
         # remember tags only if this is the latest changeset to have it
-        c.tags = util.sort([tag for tag in tags if globaltags[tag] is c])
+        c.tags = sorted([tag for tag in tags if globaltags[tag] is c])
 
     # Find parent changesets, handle {{mergetobranch BRANCHNAME}}
     # by inserting dummy changesets with two parents, and handle
     # {{mergefrombranch BRANCHNAME}} by setting two parents.
 
     if mergeto is None:
         mergeto = r'{{mergetobranch ([-\w]+)}}'
     if mergeto:
         mergeto = re.compile(mergeto)
 
     if mergefrom is None:
         mergefrom = r'{{mergefrombranch ([-\w]+)}}'
     if mergefrom:
         mergefrom = re.compile(mergefrom)
 
     versions = {}    # changeset index where we saw any particular file version
     branches = {}    # changeset index where we saw a branch
     n = len(changesets)
     i = 0
     while i<n:
         c = changesets[i]
 
         for f in c.entries:
             versions[(f.rcs, f.revision)] = i
 
         p = None
         if c.branch in branches:
             p = branches[c.branch]
         else:
             for f in c.entries:
                 p = max(p, versions.get((f.rcs, f.parent), None))
 
         c.parents = []
         if p is not None:
             p = changesets[p]
 
             # Ensure no changeset has a synthetic changeset as a parent.
             while p.synthetic:
                 assert len(p.parents) <= 1, \
                        _('synthetic changeset cannot have multiple parents')
                 if p.parents:
                     p = p.parents[0]
                 else:
                     p = None
                     break
 
             if p is not None:
                 c.parents.append(p)
 
         if c.mergepoint:
             if c.mergepoint == 'HEAD':
                 c.mergepoint = None
             c.parents.append(changesets[branches[c.mergepoint]])
 
         if mergefrom:
             m = mergefrom.search(c.comment)
             if m:
                 m = m.group(1)
                 if m == 'HEAD':
                     m = None
                 try:
                     candidate = changesets[branches[m]]
                 except KeyError:
                     ui.warn(_("warning: CVS commit message references "
                               "non-existent branch %r:\n%s\n")
                             % (m, c.comment))
                 if m in branches and c.branch != m and not candidate.synthetic:
                     c.parents.append(candidate)
 
         if mergeto:
             m = mergeto.search(c.comment)
             if m:
                 try:
                     m = m.group(1)
                     if m == 'HEAD':
                         m = None
                 except:
                     m = None   # if no group found then merge to HEAD
                 if m in branches and c.branch != m:
                     # insert empty changeset for merge
                     cc = changeset(author=c.author, branch=m, date=c.date,
                             comment='convert-repo: CVS merge from branch %s' % c.branch,
                             entries=[], tags=[], parents=[changesets[branches[m]], c])
                     changesets.insert(i + 1, cc)
                     branches[m] = i + 1
 
                     # adjust our loop counters now we have inserted a new entry
                     n += 1
                     i += 2
                     continue
 
         branches[c.branch] = i
         i += 1
 
     # Drop synthetic changesets (safe now that we have ensured no other
     # changesets can have them as parents).
     i = 0
     while i < len(changesets):
         if changesets[i].synthetic:
             del changesets[i]
         else:
             i += 1
 
     # Number changesets
 
     for i, c in enumerate(changesets):
         c.id = i + 1
 
     ui.status(_('%d changeset entries\n') % len(changesets))
 
     return changesets
 
 
 def debugcvsps(ui, *args, **opts):
     '''Read CVS rlog for current directory or named path in repository, and
     convert the log to changesets based on matching commit log entries and dates.'''
 
     if opts["new_cache"]:
         cache = "write"
     elif opts["update_cache"]:
         cache = "update"
     else:
         cache = None
 
     revisions = opts["revisions"]
 
     try:
         if args:
             log = []
             for d in args:
                 log += createlog(ui, d, root=opts["root"], cache=cache)
         else:
             log = createlog(ui, root=opts["root"], cache=cache)
     except logerror, e:
         ui.write("%r\n"%e)
         return
 
     changesets = createchangeset(ui, log, opts["fuzz"])
     del log
 
     # Print changesets (optionally filtered)
 
     off = len(revisions)
     branches = {}    # latest version number in each branch
     ancestors = {}   # parent branch
     for cs in changesets:
 
         if opts["ancestors"]:
             if cs.branch not in branches and cs.parents and cs.parents[0].id:
                 ancestors[cs.branch] = changesets[cs.parents[0].id-1].branch, cs.parents[0].id
             branches[cs.branch] = cs.id
 
         # limit by branches
         if opts["branches"] and (cs.branch or 'HEAD') not in opts["branches"]:
             continue
 
         if not off:
             # Note: trailing spaces on several lines here are needed to have
             #       bug-for-bug compatibility with cvsps.
             ui.write('---------------------\n')
             ui.write('PatchSet %d \n' % cs.id)
             ui.write('Date: %s\n' % util.datestr(cs.date, '%Y/%m/%d %H:%M:%S %1%2'))
             ui.write('Author: %s\n' % cs.author)
             ui.write('Branch: %s\n' % (cs.branch or 'HEAD'))
             ui.write('Tag%s: %s \n' % (['', 's'][len(cs.tags)>1],
                                   ','.join(cs.tags) or '(none)'))
             if opts["parents"] and cs.parents:
                 if len(cs.parents)>1:
                     ui.write('Parents: %s\n' % (','.join([str(p.id) for p in cs.parents])))
                 else:
                     ui.write('Parent: %d\n' % cs.parents[0].id)
 
             if opts["ancestors"]:
                 b = cs.branch
                 r = []
                 while b:
                     b, c = ancestors[b]
                     r.append('%s:%d:%d' % (b or "HEAD", c, branches[b]))
                 if r:
                     ui.write('Ancestors: %s\n' % (','.join(r)))
 
             ui.write('Log:\n')
             ui.write('%s\n\n' % cs.comment)
             ui.write('Members: \n')
             for f in cs.entries:
                 fn = f.file
                 if fn.startswith(opts["prefix"]):
                     fn = fn[len(opts["prefix"]):]
                 ui.write('\t%s:%s->%s%s \n' % (fn, '.'.join([str(x) for x in f.parent]) or 'INITIAL',
                                           '.'.join([str(x) for x in f.revision]), ['', '(DEAD)'][f.dead]))
             ui.write('\n')
 
         # have we seen the start tag?
         if revisions and off:
             if revisions[0] == str(cs.id) or \
                 revisions[0] in cs.tags:
                 off = False
 
         # see if we reached the end tag
         if len(revisions)>1 and not off:
             if revisions[1] == str(cs.id) or \
                 revisions[1] in cs.tags:
                 break

hgext/convert/darcs.py

@@ -1,126 +1,126 b''
 # darcs support for the convert extension
 
 from common import NoRepo, checktool, commandline, commit, converter_source
 from mercurial.i18n import _
 from mercurial import util
 import os, shutil, tempfile
 
 # The naming drift of ElementTree is fun!
 
 try: from xml.etree.cElementTree import ElementTree
 except ImportError:
     try: from xml.etree.ElementTree import ElementTree
     except ImportError:
         try: from elementtree.cElementTree import ElementTree
         except ImportError:
             try: from elementtree.ElementTree import ElementTree
             except ImportError: ElementTree = None
 
 
 class darcs_source(converter_source, commandline):
     def __init__(self, ui, path, rev=None):
         converter_source.__init__(self, ui, path, rev=rev)
         commandline.__init__(self, ui, 'darcs')
 
         # check for _darcs, ElementTree, _darcs/inventory so that we can
         # easily skip test-convert-darcs if ElementTree is not around
         if not os.path.exists(os.path.join(path, '_darcs', 'inventories')):
             raise NoRepo("%s does not look like a darcs repo" % path)
 
         if not os.path.exists(os.path.join(path, '_darcs')):
             raise NoRepo("%s does not look like a darcs repo" % path)
 
         checktool('darcs')
 
         if ElementTree is None:
             raise util.Abort(_("Python ElementTree module is not available"))
 
         self.path = os.path.realpath(path)
 
         self.lastrev = None
         self.changes = {}
         self.parents = {}
         self.tags = {}
 
     def before(self):
         self.tmppath = tempfile.mkdtemp(
             prefix='convert-' + os.path.basename(self.path) + '-')
         output, status = self.run('init', repodir=self.tmppath)
         self.checkexit(status)
 
         tree = self.xml('changes', xml_output=True, summary=True,
                         repodir=self.path)
         tagname = None
         child = None
         for elt in tree.findall('patch'):
             node = elt.get('hash')
             name = elt.findtext('name', '')
             if name.startswith('TAG '):
                 tagname = name[4:].strip()
             elif tagname is not None:
                 self.tags[tagname] = node
                 tagname = None
             self.changes[node] = elt
             self.parents[child] = [node]
             child = node
         self.parents[child] = []
 
     def after(self):
         self.ui.debug(_('cleaning up %s\n') % self.tmppath)
         shutil.rmtree(self.tmppath, ignore_errors=True)
 
     def xml(self, cmd, **kwargs):
         etree = ElementTree()
         fp = self._run(cmd, **kwargs)
         etree.parse(fp)
         self.checkexit(fp.close())
         return etree.getroot()
 
     def getheads(self):
         return self.parents[None]
 
     def getcommit(self, rev):
         elt = self.changes[rev]
         date = util.strdate(elt.get('local_date'), '%a %b %d %H:%M:%S %Z %Y')
         desc = elt.findtext('name') + '\n' + elt.findtext('comment', '')
         return commit(author=elt.get('author'), date=util.datestr(date),
                       desc=desc.strip(), parents=self.parents[rev])
 
     def pull(self, rev):
         output, status = self.run('pull', self.path, all=True,
                                   match='hash %s' % rev,
                                   no_test=True, no_posthook=True,
                                   external_merge='/bin/false',
                                   repodir=self.tmppath)
         if status:
             if output.find('We have conflicts in') == -1:
                 self.checkexit(status, output)
             output, status = self.run('revert', all=True, repodir=self.tmppath)
             self.checkexit(status, output)
 
     def getchanges(self, rev):
         self.pull(rev)
         copies = {}
         changes = []
         for elt in self.changes[rev].find('summary').getchildren():
             if elt.tag in ('add_directory', 'remove_directory'):
                 continue
             if elt.tag == 'move':
                 changes.append((elt.get('from'), rev))
                 copies[elt.get('from')] = elt.get('to')
             else:
                 changes.append((elt.text.strip(), rev))
         self.lastrev = rev
-        return util.sort(changes), copies
+        return sorted(changes), copies
 
     def getfile(self, name, rev):
         if rev != self.lastrev:
             raise util.Abort(_('internal calling inconsistency'))
         return open(os.path.join(self.tmppath, name), 'rb').read()
 
     def getmode(self, name, rev):
         mode = os.lstat(os.path.join(self.tmppath, name)).st_mode
         return (mode & 0111) and 'x' or ''
 
     def gettags(self):
         return self.tags

hgext/convert/gnuarch.py

@@ -1,335 +1,335 b''
 # GNU Arch support for the convert extension
 
 from common import NoRepo, commandline, commit, converter_source
 from mercurial.i18n import _
 from mercurial import util
 import os, shutil, tempfile, stat, locale
 from email.Parser import Parser
 
 class gnuarch_source(converter_source, commandline):
 
     class gnuarch_rev:
         def __init__(self, rev):
             self.rev = rev
             self.summary = ''
             self.date = None
             self.author = ''
             self.continuationof = None
             self.add_files = []
             self.mod_files = []
             self.del_files = []
             self.ren_files = {}
             self.ren_dirs = {}
 
     def __init__(self, ui, path, rev=None):
         super(gnuarch_source, self).__init__(ui, path, rev=rev)
 
         if not os.path.exists(os.path.join(path, '{arch}')):
             raise NoRepo(_("%s does not look like a GNU Arch repo") % path)
 
         # Could use checktool, but we want to check for baz or tla.
         self.execmd = None
         if util.find_exe('baz'):
             self.execmd = 'baz'
         else:
             if util.find_exe('tla'):
                 self.execmd = 'tla'
             else:
                 raise util.Abort(_('cannot find a GNU Arch tool'))
 
         commandline.__init__(self, ui, self.execmd)
 
         self.path = os.path.realpath(path)
         self.tmppath = None
 
         self.treeversion = None
         self.lastrev = None
         self.changes = {}
         self.parents = {}
         self.tags = {}
         self.modecache = {}
         self.catlogparser = Parser()
         self.locale = locale.getpreferredencoding()
         self.archives = []
 
     def before(self):
         # Get registered archives
         self.archives = [i.rstrip('\n')
                          for i in self.runlines0('archives', '-n')]
 
         if self.execmd == 'tla':
             output = self.run0('tree-version', self.path)
         else:
             output = self.run0('tree-version', '-d', self.path)
         self.treeversion = output.strip()
 
         # Get name of temporary directory
         version = self.treeversion.split('/')
         self.tmppath = os.path.join(tempfile.gettempdir(),
                                     'hg-%s' % version[1])
 
         # Generate parents dictionary
         self.parents[None] = []
         treeversion = self.treeversion
         child = None
         while treeversion:
             self.ui.status(_('analyzing tree version %s...\n') % treeversion)
 
             archive = treeversion.split('/')[0]
             if archive not in self.archives:
                 self.ui.status(_('tree analysis stopped because it points to an unregistered archive %s...\n') % archive)
                 break
 
             # Get the complete list of revisions for that tree version
             output, status = self.runlines('revisions', '-r', '-f', treeversion)
             self.checkexit(status, 'failed retrieveing revisions for %s' % treeversion)
 
             # No new iteration unless a revision has a continuation-of header
             treeversion = None
 
             for l in output:
                 rev = l.strip()
                 self.changes[rev] = self.gnuarch_rev(rev)
                 self.parents[rev] = []
 
                 # Read author, date and summary
                 catlog, status = self.run('cat-log', '-d', self.path, rev)
                 if status:
                     catlog  = self.run0('cat-archive-log', rev)
                 self._parsecatlog(catlog, rev)
 
                 # Populate the parents map
                 self.parents[child].append(rev)
 
                 # Keep track of the current revision as the child of the next
                 # revision scanned
                 child = rev
 
                 # Check if we have to follow the usual incremental history
                 # or if we have to 'jump' to a different treeversion given
                 # by the continuation-of header.
                 if self.changes[rev].continuationof:
                     treeversion = '--'.join(self.changes[rev].continuationof.split('--')[:-1])
                     break
 
                 # If we reached a base-0 revision w/o any continuation-of
                 # header, it means the tree history ends here.
                 if rev[-6:] == 'base-0':
                     break
 
     def after(self):
         self.ui.debug(_('cleaning up %s\n') % self.tmppath)
         shutil.rmtree(self.tmppath, ignore_errors=True)
 
     def getheads(self):
         return self.parents[None]
 
     def getfile(self, name, rev):
         if rev != self.lastrev:
             raise util.Abort(_('internal calling inconsistency'))
 
         # Raise IOError if necessary (i.e. deleted files).
         if not os.path.exists(os.path.join(self.tmppath, name)):
             raise IOError
 
         data, mode = self._getfile(name, rev)
         self.modecache[(name, rev)] = mode
 
         return data
 
     def getmode(self, name, rev):
         return self.modecache[(name, rev)]
 
     def getchanges(self, rev):
         self.modecache = {}
         self._update(rev)
         changes = []
         copies = {}
 
         for f in self.changes[rev].add_files:
             changes.append((f, rev))
 
         for f in self.changes[rev].mod_files:
             changes.append((f, rev))
 
         for f in self.changes[rev].del_files:
             changes.append((f, rev))
 
         for src in self.changes[rev].ren_files:
             to = self.changes[rev].ren_files[src]
             changes.append((src, rev))
             changes.append((to, rev))
             copies[to] = src
 
         for src in self.changes[rev].ren_dirs:
             to = self.changes[rev].ren_dirs[src]
             chgs, cps = self._rendirchanges(src, to);
             changes += [(f, rev) for f in chgs]
             copies.update(cps)
 
         self.lastrev = rev
-        return util.sort(set(changes)), copies
+        return sorted(set(changes)), copies
 
     def getcommit(self, rev):
         changes = self.changes[rev]
         return commit(author = changes.author, date = changes.date,
                       desc = changes.summary, parents = self.parents[rev], rev=rev)
 
     def gettags(self):
         return self.tags
 
     def _execute(self, cmd, *args, **kwargs):
         cmdline = [self.execmd, cmd]
         cmdline += args
         cmdline = [util.shellquote(arg) for arg in cmdline]
         cmdline += ['>', util.nulldev, '2>', util.nulldev]
         cmdline = util.quotecommand(' '.join(cmdline))
         self.ui.debug(cmdline, '\n')
         return os.system(cmdline)
 
     def _update(self, rev):
         self.ui.debug(_('applying revision %s...\n') % rev)
         changeset, status = self.runlines('replay', '-d', self.tmppath,
                                               rev)
         if status:
             # Something went wrong while merging (baz or tla
             # issue?), get latest revision and try from there
             shutil.rmtree(self.tmppath, ignore_errors=True)
             self._obtainrevision(rev)
         else:
             old_rev = self.parents[rev][0]
             self.ui.debug(_('computing changeset between %s and %s...\n')
                           % (old_rev, rev))
             self._parsechangeset(changeset, rev)
 
     def _getfile(self, name, rev):
         mode = os.lstat(os.path.join(self.tmppath, name)).st_mode
         if stat.S_ISLNK(mode):
             data = os.readlink(os.path.join(self.tmppath, name))
             mode = mode and 'l' or ''
         else:
             data = open(os.path.join(self.tmppath, name), 'rb').read()
             mode = (mode & 0111) and 'x' or ''
         return data, mode
 
     def _exclude(self, name):
         exclude = [ '{arch}', '.arch-ids', '.arch-inventory' ]
         for exc in exclude:
             if name.find(exc) != -1:
                 return True
         return False
 
     def _readcontents(self, path):
         files = []
         contents = os.listdir(path)
         while len(contents) > 0:
             c = contents.pop()
             p = os.path.join(path, c)
             # os.walk could be used, but here we avoid internal GNU
             # Arch files and directories, thus saving a lot time.
             if not self._exclude(p):
                 if os.path.isdir(p):
                     contents += [os.path.join(c, f) for f in os.listdir(p)]
                 else:
                     files.append(c)
         return files
 
     def _rendirchanges(self, src, dest):
         changes = []
         copies = {}
         files = self._readcontents(os.path.join(self.tmppath, dest))
         for f in files:
             s = os.path.join(src, f)
             d = os.path.join(dest, f)
             changes.append(s)
             changes.append(d)
             copies[d] = s
         return changes, copies
 
     def _obtainrevision(self, rev):
         self.ui.debug(_('obtaining revision %s...\n') % rev)
         output = self._execute('get', rev, self.tmppath)
         self.checkexit(output)
         self.ui.debug(_('analysing revision %s...\n') % rev)
         files = self._readcontents(self.tmppath)
         self.changes[rev].add_files += files
 
     def _stripbasepath(self, path):
         if path.startswith('./'):
             return path[2:]
         return path
 
     def _parsecatlog(self, data, rev):
         try:
             catlog = self.catlogparser.parsestr(data)
 
             # Commit date
             self.changes[rev].date = util.datestr(
                 util.strdate(catlog['Standard-date'],
                              '%Y-%m-%d %H:%M:%S'))
 
             # Commit author
             self.changes[rev].author = self.recode(catlog['Creator'])
 
             # Commit description
             self.changes[rev].summary = '\n\n'.join((catlog['Summary'],
                                                     catlog.get_payload()))
             self.changes[rev].summary = self.recode(self.changes[rev].summary)
 
             # Commit revision origin when dealing with a branch or tag
             if catlog.has_key('Continuation-of'):
                 self.changes[rev].continuationof = self.recode(catlog['Continuation-of'])
         except Exception:
             raise util.Abort(_('could not parse cat-log of %s') % rev)
 
     def _parsechangeset(self, data, rev):
         for l in data:
             l = l.strip()
             # Added file (ignore added directory)
             if l.startswith('A') and not l.startswith('A/'):
                 file = self._stripbasepath(l[1:].strip())
                 if not self._exclude(file):
                     self.changes[rev].add_files.append(file)
             # Deleted file (ignore deleted directory)
             elif l.startswith('D') and not l.startswith('D/'):
                 file = self._stripbasepath(l[1:].strip())
                 if not self._exclude(file):
                     self.changes[rev].del_files.append(file)
             # Modified binary file
             elif l.startswith('Mb'):
                 file = self._stripbasepath(l[2:].strip())
                 if not self._exclude(file):
                     self.changes[rev].mod_files.append(file)
             # Modified link
             elif l.startswith('M->'):
                 file = self._stripbasepath(l[3:].strip())
                 if not self._exclude(file):
                     self.changes[rev].mod_files.append(file)
             # Modified file
             elif l.startswith('M'):
                 file = self._stripbasepath(l[1:].strip())
                 if not self._exclude(file):
                     self.changes[rev].mod_files.append(file)
             # Renamed file (or link)
             elif l.startswith('=>'):
                 files = l[2:].strip().split(' ')
                 if len(files) == 1:
                     files = l[2:].strip().split('\t')
                 src = self._stripbasepath(files[0])
                 dst = self._stripbasepath(files[1])
                 if not self._exclude(src) and not self._exclude(dst):
                     self.changes[rev].ren_files[src] = dst
             # Conversion from file to link or from link to file (modified)
             elif l.startswith('ch'):
                 file = self._stripbasepath(l[2:].strip())
                 if not self._exclude(file):
                     self.changes[rev].mod_files.append(file)
             # Renamed directory
             elif l.startswith('/>'):
                 dirs = l[2:].strip().split(' ')
                 if len(dirs) == 1:
                     dirs = l[2:].strip().split('\t')
                 src = self._stripbasepath(dirs[0])
                 dst = self._stripbasepath(dirs[1])
                 if not self._exclude(src) and not self._exclude(dst):
                     self.changes[rev].ren_dirs[src] = dst

hgext/convert/hg.py

@@ -1,333 +1,333 b''
 # hg backend for convert extension
 
 # Notes for hg->hg conversion:
 #
 # * Old versions of Mercurial didn't trim the whitespace from the ends
 #   of commit messages, but new versions do.  Changesets created by
 #   those older versions, then converted, may thus have different
 #   hashes for changesets that are otherwise identical.
 #
 # * By default, the source revision is stored in the converted
 #   revision.  This will cause the converted revision to have a
 #   different identity than the source.  To avoid this, use the
 #   following option: "--config convert.hg.saverev=false"
 
 
 import os, time
 from mercurial.i18n import _
 from mercurial.node import bin, hex, nullid
 from mercurial import hg, util, context, error
 
 from common import NoRepo, commit, converter_source, converter_sink
 
 class mercurial_sink(converter_sink):
     def __init__(self, ui, path):
         converter_sink.__init__(self, ui, path)
         self.branchnames = ui.configbool('convert', 'hg.usebranchnames', True)
         self.clonebranches = ui.configbool('convert', 'hg.clonebranches', False)
         self.tagsbranch = ui.config('convert', 'hg.tagsbranch', 'default')
         self.lastbranch = None
         if os.path.isdir(path) and len(os.listdir(path)) > 0:
             try:
                 self.repo = hg.repository(self.ui, path)
                 if not self.repo.local():
                     raise NoRepo(_('%s is not a local Mercurial repo') % path)
             except error.RepoError, err:
                 ui.traceback()
                 raise NoRepo(err.args[0])
         else:
             try:
                 ui.status(_('initializing destination %s repository\n') % path)
                 self.repo = hg.repository(self.ui, path, create=True)
                 if not self.repo.local():
                     raise NoRepo(_('%s is not a local Mercurial repo') % path)
                 self.created.append(path)
             except error.RepoError:
                 ui.traceback()
                 raise NoRepo("could not create hg repo %s as sink" % path)
         self.lock = None
         self.wlock = None
         self.filemapmode = False
 
     def before(self):
         self.ui.debug(_('run hg sink pre-conversion action\n'))
         self.wlock = self.repo.wlock()
         self.lock = self.repo.lock()
 
     def after(self):
         self.ui.debug(_('run hg sink post-conversion action\n'))
         self.lock.release()
         self.wlock.release()
 
     def revmapfile(self):
         return os.path.join(self.path, ".hg", "shamap")
 
     def authorfile(self):
         return os.path.join(self.path, ".hg", "authormap")
 
     def getheads(self):
         h = self.repo.changelog.heads()
         return [ hex(x) for x in h ]
 
     def setbranch(self, branch, pbranches):
         if not self.clonebranches:
             return
 
         setbranch = (branch != self.lastbranch)
         self.lastbranch = branch
         if not branch:
             branch = 'default'
         pbranches = [(b[0], b[1] and b[1] or 'default') for b in pbranches]
         pbranch = pbranches and pbranches[0][1] or 'default'
 
         branchpath = os.path.join(self.path, branch)
         if setbranch:
             self.after()
             try:
                 self.repo = hg.repository(self.ui, branchpath)
             except:
                 self.repo = hg.repository(self.ui, branchpath, create=True)
             self.before()
 
         # pbranches may bring revisions from other branches (merge parents)
         # Make sure we have them, or pull them.
         missings = {}
         for b in pbranches:
             try:
                 self.repo.lookup(b[0])
             except:
                 missings.setdefault(b[1], []).append(b[0])
 
         if missings:
             self.after()
             for pbranch, heads in missings.iteritems():
                 pbranchpath = os.path.join(self.path, pbranch)
                 prepo = hg.repository(self.ui, pbranchpath)
                 self.ui.note(_('pulling from %s into %s\n') % (pbranch, branch))
                 self.repo.pull(prepo, [prepo.lookup(h) for h in heads])
             self.before()
 
     def putcommit(self, files, copies, parents, commit, source):
 
         files = dict(files)
         def getfilectx(repo, memctx, f):
             v = files[f]
             data = source.getfile(f, v)
             e = source.getmode(f, v)
             return context.memfilectx(f, data, 'l' in e, 'x' in e, copies.get(f))
 
         pl = []
         for p in parents:
             if p not in pl:
                 pl.append(p)
         parents = pl
         nparents = len(parents)
         if self.filemapmode and nparents == 1:
             m1node = self.repo.changelog.read(bin(parents[0]))[0]
             parent = parents[0]
 
         if len(parents) < 2: parents.append("0" * 40)
         if len(parents) < 2: parents.append("0" * 40)
         p2 = parents.pop(0)
 
         text = commit.desc
         extra = commit.extra.copy()
         if self.branchnames and commit.branch:
             extra['branch'] = commit.branch
         if commit.rev:
             extra['convert_revision'] = commit.rev
 
         while parents:
             p1 = p2
             p2 = parents.pop(0)
             ctx = context.memctx(self.repo, (p1, p2), text, files.keys(), getfilectx,
                                  commit.author, commit.date, extra)
             self.repo.commitctx(ctx)
             text = "(octopus merge fixup)\n"
             p2 = hex(self.repo.changelog.tip())
 
         if self.filemapmode and nparents == 1:
             man = self.repo.manifest
             mnode = self.repo.changelog.read(bin(p2))[0]
             if not man.cmp(m1node, man.revision(mnode)):
                 self.repo.rollback()
                 return parent
         return p2
 
     def puttags(self, tags):
         try:
             parentctx = self.repo[self.tagsbranch]
             tagparent = parentctx.node()
         except error.RepoError:
             parentctx = None
             tagparent = nullid
 
         try:
-            oldlines = util.sort(parentctx['.hgtags'].data().splitlines(1))
+            oldlines = sorted(parentctx['.hgtags'].data().splitlines(1))
         except:
             oldlines = []
 
-        newlines = util.sort([("%s %s\n" % (tags[tag], tag)) for tag in tags])
+        newlines = sorted([("%s %s\n" % (tags[tag], tag)) for tag in tags])
         if newlines == oldlines:
             return None
         data = "".join(newlines)
         def getfilectx(repo, memctx, f):
             return context.memfilectx(f, data, False, False, None)
 
         self.ui.status(_("updating tags\n"))
         date = "%s 0" % int(time.mktime(time.gmtime()))
         extra = {'branch': self.tagsbranch}
         ctx = context.memctx(self.repo, (tagparent, None), "update tags",
                              [".hgtags"], getfilectx, "convert-repo", date,
                              extra)
         self.repo.commitctx(ctx)
         return hex(self.repo.changelog.tip())
 
     def setfilemapmode(self, active):
         self.filemapmode = active
 
 class mercurial_source(converter_source):
     def __init__(self, ui, path, rev=None):
         converter_source.__init__(self, ui, path, rev)
         self.ignoreerrors = ui.configbool('convert', 'hg.ignoreerrors', False)
         self.ignored = {}
         self.saverev = ui.configbool('convert', 'hg.saverev', False)
         try:
             self.repo = hg.repository(self.ui, path)
             # try to provoke an exception if this isn't really a hg
             # repo, but some other bogus compatible-looking url
             if not self.repo.local():
                 raise error.RepoError()
         except error.RepoError:
             ui.traceback()
             raise NoRepo("%s is not a local Mercurial repo" % path)
         self.lastrev = None
         self.lastctx = None
         self._changescache = None
         self.convertfp = None
         # Restrict converted revisions to startrev descendants
         startnode = ui.config('convert', 'hg.startrev')
         if startnode is not None:
             try:
                 startnode = self.repo.lookup(startnode)
             except error.RepoError:
                 raise util.Abort(_('%s is not a valid start revision')
                                  % startnode)
             startrev = self.repo.changelog.rev(startnode)
             children = {startnode: 1}
             for rev in self.repo.changelog.descendants(startrev):
                 children[self.repo.changelog.node(rev)] = 1
             self.keep = children.__contains__
         else:
             self.keep = util.always
 
     def changectx(self, rev):
         if self.lastrev != rev:
             self.lastctx = self.repo[rev]
             self.lastrev = rev
         return self.lastctx
 
     def parents(self, ctx):
         return [p.node() for p in ctx.parents()
                 if p and self.keep(p.node())]
 
     def getheads(self):
         if self.rev:
             heads = [self.repo[self.rev].node()]
         else:
             heads = self.repo.heads()
         return [hex(h) for h in heads if self.keep(h)]
 
     def getfile(self, name, rev):
         try:
             return self.changectx(rev)[name].data()
         except error.LookupError, err:
             raise IOError(err)
 
     def getmode(self, name, rev):
         return self.changectx(rev).manifest().flags(name)
 
     def getchanges(self, rev):
         ctx = self.changectx(rev)
         parents = self.parents(ctx)
         if not parents:
-            files = util.sort(ctx.manifest().keys())
+            files = sorted(ctx.manifest())
             if self.ignoreerrors:
                 # calling getcopies() is a simple way to detect missing
                 # revlogs and populate self.ignored
                 self.getcopies(ctx, files)
             return [(f, rev) for f in files if f not in self.ignored], {}
         if self._changescache and self._changescache[0] == rev:
             m, a, r = self._changescache[1]
         else:
             m, a, r = self.repo.status(parents[0], ctx.node())[:3]
         # getcopies() detects missing revlogs early, run it before
         # filtering the changes.
         copies = self.getcopies(ctx, m + a)
         changes = [(name, rev) for name in m + a + r
                    if name not in self.ignored]
-        return util.sort(changes), copies
+        return sorted(changes), copies
 
     def getcopies(self, ctx, files):
         copies = {}
         for name in files:
             if name in self.ignored:
                 continue
             try:
                 copysource, copynode = ctx.filectx(name).renamed()
                 if copysource in self.ignored or not self.keep(copynode):
                     continue
                 copies[name] = copysource
             except TypeError:
                 pass
             except error.LookupError, e:
                 if not self.ignoreerrors:
                     raise
                 self.ignored[name] = 1
                 self.ui.warn(_('ignoring: %s\n') % e)
         return copies
 
     def getcommit(self, rev):
         ctx = self.changectx(rev)
         parents = [hex(p) for p in self.parents(ctx)]
         if self.saverev:
             crev = rev
         else:
             crev = None
         return commit(author=ctx.user(), date=util.datestr(ctx.date()),
                       desc=ctx.description(), rev=crev, parents=parents,
                       branch=ctx.branch(), extra=ctx.extra())
 
     def gettags(self):
         tags = [t for t in self.repo.tagslist() if t[0] != 'tip']
         return dict([(name, hex(node)) for name, node in tags
                      if self.keep(node)])
 
     def getchangedfiles(self, rev, i):
         ctx = self.changectx(rev)
         parents = self.parents(ctx)
         if not parents and i is None:
             i = 0
             changes = [], ctx.manifest().keys(), []
         else:
             i = i or 0
             changes = self.repo.status(parents[i], ctx.node())[:3]
         changes = [[f for f in l if f not in self.ignored] for l in changes]
 
         if i == 0:
             self._changescache = (rev, changes)
 
         return changes[0] + changes[1] + changes[2]
 
     def converted(self, rev, destrev):
         if self.convertfp is None:
             self.convertfp = open(os.path.join(self.path, '.hg', 'shamap'),
                                   'a')
         self.convertfp.write('%s %s\n' % (destrev, rev))
         self.convertfp.flush()
 
     def before(self):
         self.ui.debug(_('run hg source pre-conversion action\n'))
 
     def after(self):
         self.ui.debug(_('run hg source post-conversion action\n'))

hgext/convert/p4.py

@@ -1,179 +1,179 b''
 #
 # Perforce source for convert extension.
 #
 # Copyright 2009, Frank Kingswood <[e-mail]>
 #
 # This software may be used and distributed according to the terms
 # of the GNU General Public License, incorporated herein by reference.
 #
 
 from mercurial import util
 from mercurial.i18n import _
 
 from common import commit, converter_source, checktool, NoRepo
 import marshal
 
 def loaditer(f):
     "Yield the dictionary objects generated by p4"
     try:
         while True:
             d = marshal.load(f)
             if not d:
                 break
             yield d
     except EOFError:
         pass
 
 class p4_source(converter_source):
     def __init__(self, ui, path, rev=None):
         super(p4_source, self).__init__(ui, path, rev=rev)
 
         if not path.startswith('//'):
             raise NoRepo('%s does not look like a P4 repo' % path)
 
         checktool('p4', abort=False)
 
         self.p4changes = {}
         self.heads = {}
         self.changeset = {}
         self.files = {}
         self.tags = {}
         self.lastbranch = {}
         self.parent = {}
         self.encoding = "latin_1"
         self.depotname = {}           # mapping from local name to depot name
         self.modecache = {}
 
         self._parse(ui, path)
 
     def _parse_view(self, path):
         "Read changes affecting the path"
         cmd = 'p4 -G changes -s submitted "%s"' % path
         stdout = util.popen(cmd)
         for d in loaditer(stdout):
             c = d.get("change", None)
             if c:
                 self.p4changes[c] = True
 
     def _parse(self, ui, path):
         "Prepare list of P4 filenames and revisions to import"
         ui.status(_('reading p4 views\n'))
 
         # read client spec or view
         if "/" in path:
             self._parse_view(path)
             if path.startswith("//") and path.endswith("/..."):
                 views = {path[:-3]:""}
             else:
                 views = {"//": ""}
         else:
             cmd = 'p4 -G client -o "%s"' % path
             clientspec = marshal.load(util.popen(cmd))
 
             views = {}
             for client in clientspec:
                 if client.startswith("View"):
                     sview, cview = clientspec[client].split()
                     self._parse_view(sview)
                     if sview.endswith("...") and cview.endswith("..."):
                         sview = sview[:-3]
                         cview = cview[:-3]
                     cview = cview[2:]
                     cview = cview[cview.find("/") + 1:]
                     views[sview] = cview
 
         # list of changes that affect our source files
         self.p4changes = self.p4changes.keys()
         self.p4changes.sort(key=int)
 
         # list with depot pathnames, longest first
         vieworder = views.keys()
         vieworder.sort(key=lambda x: -len(x))
 
         # handle revision limiting
         startrev = self.ui.config('convert', 'p4.startrev', default=0)
         self.p4changes = [x for x in self.p4changes
                           if ((not startrev or int(x) >= int(startrev)) and
                               (not self.rev or int(x) <= int(self.rev)))]
 
         # now read the full changelists to get the list of file revisions
         ui.status(_('collecting p4 changelists\n'))
         lastid = None
         for change in self.p4changes:
             cmd = "p4 -G describe %s" % change
             stdout = util.popen(cmd)
             d = marshal.load(stdout)
 
             desc = self.recode(d["desc"])
             shortdesc = desc.split("\n", 1)[0]
             t = '%s %s' % (d["change"], repr(shortdesc)[1:-1])
             ui.status(util.ellipsis(t, 80) + '\n')
 
             if lastid:
                 parents = [lastid]
             else:
                 parents = []
 
             date = (int(d["time"]), 0)     # timezone not set
             c = commit(author=self.recode(d["user"]), date=util.datestr(date),
                         parents=parents, desc=desc, branch='', extra={"p4": change})
 
             files = []
             i = 0
             while ("depotFile%d" % i) in d and ("rev%d" % i) in d:
                 oldname = d["depotFile%d" % i]
                 filename = None
                 for v in vieworder:
                     if oldname.startswith(v):
                         filename = views[v] + oldname[len(v):]
                         break
                 if filename:
                     files.append((filename, d["rev%d" % i]))
                     self.depotname[filename] = oldname
                 i += 1
             self.changeset[change] = c
             self.files[change] = files
             lastid = change
 
         if lastid:
             self.heads = [lastid]
 
     def getheads(self):
         return self.heads
 
     def getfile(self, name, rev):
         cmd = 'p4 -G print "%s#%s"' % (self.depotname[name], rev)
         stdout = util.popen(cmd)
 
         mode = None
         data = ""
 
         for d in loaditer(stdout):
             if d["code"] == "stat":
                 if "+x" in d["type"]:
                     mode = "x"
                 else:
                     mode = ""
             elif d["code"] == "text":
                 data += d["data"]
 
         if mode is None:
             raise IOError()
 
         self.modecache[(name, rev)] = mode
         return data
 
     def getmode(self, name, rev):
         return self.modecache[(name, rev)]
 
     def getchanges(self, rev):
         return self.files[rev], {}
 
     def getcommit(self, rev):
         return self.changeset[rev]
 
     def gettags(self):
         return self.tags
 
     def getchangedfiles(self, rev, i):
-        return util.sort([x[0] for x in self.files[rev]])
+        return sorted([x[0] for x in self.files[rev]])

hgext/convert/subversion.py

@@ -1,1205 +1,1203 b''
 # Subversion 1.4/1.5 Python API backend
 #
 # Copyright(C) 2007 Daniel Holth et al
 #
 # Configuration options:
 #
 # convert.svn.trunk
 #   Relative path to the trunk (default: "trunk")
 # convert.svn.branches
 #   Relative path to tree of branches (default: "branches")
 # convert.svn.tags
 #   Relative path to tree of tags (default: "tags")
 #
 # Set these in a hgrc, or on the command line as follows:
 #
 #   hg convert --config convert.svn.trunk=wackoname [...]
 
 import locale
 import os
 import re
 import sys
 import cPickle as pickle
 import tempfile
 import urllib
 
 from mercurial import strutil, util
 from mercurial.i18n import _
 
 # Subversion stuff. Works best with very recent Python SVN bindings
 # e.g. SVN 1.5 or backports. Thanks to the bzr folks for enhancing
 # these bindings.
 
 from cStringIO import StringIO
 
 from common import NoRepo, MissingTool, commit, encodeargs, decodeargs
 from common import commandline, converter_source, converter_sink, mapfile
 
 try:
     from svn.core import SubversionException, Pool
     import svn
     import svn.client
     import svn.core
     import svn.ra
     import svn.delta
     import transport
 except ImportError:
     pass
 
 class SvnPathNotFound(Exception):
     pass
 
 def geturl(path):
     try:
         return svn.client.url_from_path(svn.core.svn_path_canonicalize(path))
     except SubversionException:
         pass
     if os.path.isdir(path):
         path = os.path.normpath(os.path.abspath(path))
         if os.name == 'nt':
             path = '/' + util.normpath(path)
         return 'file://%s' % urllib.quote(path)
     return path
 
 def optrev(number):
     optrev = svn.core.svn_opt_revision_t()
     optrev.kind = svn.core.svn_opt_revision_number
     optrev.value.number = number
     return optrev
 
 class changedpath(object):
     def __init__(self, p):
         self.copyfrom_path = p.copyfrom_path
         self.copyfrom_rev = p.copyfrom_rev
         self.action = p.action
 
 def get_log_child(fp, url, paths, start, end, limit=0, discover_changed_paths=True,
                     strict_node_history=False):
     protocol = -1
     def receiver(orig_paths, revnum, author, date, message, pool):
         if orig_paths is not None:
             for k, v in orig_paths.iteritems():
                 orig_paths[k] = changedpath(v)
         pickle.dump((orig_paths, revnum, author, date, message),
                     fp, protocol)
 
     try:
         # Use an ra of our own so that our parent can consume
         # our results without confusing the server.
         t = transport.SvnRaTransport(url=url)
         svn.ra.get_log(t.ra, paths, start, end, limit,
                        discover_changed_paths,
                        strict_node_history,
                        receiver)
     except SubversionException, (inst, num):
         pickle.dump(num, fp, protocol)
     except IOError:
         # Caller may interrupt the iteration
         pickle.dump(None, fp, protocol)
     else:
         pickle.dump(None, fp, protocol)
     fp.close()
     # With large history, cleanup process goes crazy and suddenly
     # consumes *huge* amount of memory. The output file being closed,
     # there is no need for clean termination.
     os._exit(0)
 
 def debugsvnlog(ui, **opts):
     """Fetch SVN log in a subprocess and channel them back to parent to
     avoid memory collection issues.
     """
     util.set_binary(sys.stdin)
     util.set_binary(sys.stdout)
     args = decodeargs(sys.stdin.read())
     get_log_child(sys.stdout, *args)
 
 class logstream:
     """Interruptible revision log iterator."""
     def __init__(self, stdout):
         self._stdout = stdout
 
     def __iter__(self):
         while True:
             entry = pickle.load(self._stdout)
             try:
                 orig_paths, revnum, author, date, message = entry
             except:
                 if entry is None:
                     break
                 raise SubversionException("child raised exception", entry)
             yield entry
 
     def close(self):
         if self._stdout:
             self._stdout.close()
             self._stdout = None
 
 
 # Check to see if the given path is a local Subversion repo. Verify this by
 # looking for several svn-specific files and directories in the given
 # directory.
 def filecheck(path, proto):
     for x in ('locks', 'hooks', 'format', 'db', ):
         if not os.path.exists(os.path.join(path, x)):
             return False
     return True
 
 # Check to see if a given path is the root of an svn repo over http. We verify
 # this by requesting a version-controlled URL we know can't exist and looking
 # for the svn-specific "not found" XML.
 def httpcheck(path, proto):
    return ('<m:human-readable errcode="160013">' in
            urllib.urlopen('%s://%s/!svn/ver/0/.svn' % (proto, path)).read())
 
 protomap = {'http': httpcheck,
             'https': httpcheck,
             'file': filecheck,
             }
 def issvnurl(url):
     if not '://' in url:
         return False
     proto, path = url.split('://', 1)
     check = protomap.get(proto, lambda p, p2: False)
     while '/' in path:
         if check(path, proto):
             return True
         path = path.rsplit('/', 1)[0]
     return False
 
 # SVN conversion code stolen from bzr-svn and tailor
 #
 # Subversion looks like a versioned filesystem, branches structures
 # are defined by conventions and not enforced by the tool. First,
 # we define the potential branches (modules) as "trunk" and "branches"
 # children directories. Revisions are then identified by their
 # module and revision number (and a repository identifier).
 #
 # The revision graph is really a tree (or a forest). By default, a
 # revision parent is the previous revision in the same module. If the
 # module directory is copied/moved from another module then the
 # revision is the module root and its parent the source revision in
 # the parent module. A revision has at most one parent.
 #
 class svn_source(converter_source):
     def __init__(self, ui, url, rev=None):
         super(svn_source, self).__init__(ui, url, rev=rev)
 
         if not (url.startswith('svn://') or url.startswith('svn+ssh://') or
                 (os.path.exists(url) and
                  os.path.exists(os.path.join(url, '.svn'))) or
                 issvnurl(url)):
             raise NoRepo("%s does not look like a Subversion repo" % url)
 
         try:
             SubversionException
         except NameError:
             raise MissingTool(_('Subversion python bindings could not be loaded'))
 
         try:
             version = svn.core.SVN_VER_MAJOR, svn.core.SVN_VER_MINOR
             if version < (1, 4):
                 raise MissingTool(_('Subversion python bindings %d.%d found, '
                                     '1.4 or later required') % version)
         except AttributeError:
             raise MissingTool(_('Subversion python bindings are too old, 1.4 '
                                 'or later required'))
 
         self.encoding = locale.getpreferredencoding()
         self.lastrevs = {}
 
         latest = None
         try:
             # Support file://path@rev syntax. Useful e.g. to convert
             # deleted branches.
             at = url.rfind('@')
             if at >= 0:
                 latest = int(url[at+1:])
                 url = url[:at]
         except ValueError:
             pass
         self.url = geturl(url)
         self.encoding = 'UTF-8' # Subversion is always nominal UTF-8
         try:
             self.transport = transport.SvnRaTransport(url=self.url)
             self.ra = self.transport.ra
             self.ctx = self.transport.client
             self.baseurl = svn.ra.get_repos_root(self.ra)
             # Module is either empty or a repository path starting with
             # a slash and not ending with a slash.
             self.module = urllib.unquote(self.url[len(self.baseurl):])
             self.prevmodule = None
             self.rootmodule = self.module
             self.commits = {}
             self.paths = {}
             self.uuid = svn.ra.get_uuid(self.ra).decode(self.encoding)
         except SubversionException:
             ui.traceback()
             raise NoRepo("%s does not look like a Subversion repo" % self.url)
 
         if rev:
             try:
                 latest = int(rev)
             except ValueError:
                 raise util.Abort(_('svn: revision %s is not an integer') % rev)
 
         self.startrev = self.ui.config('convert', 'svn.startrev', default=0)
         try:
             self.startrev = int(self.startrev)
             if self.startrev < 0:
                 self.startrev = 0
         except ValueError:
             raise util.Abort(_('svn: start revision %s is not an integer')
                              % self.startrev)
 
         try:
             self.get_blacklist()
         except IOError:
             pass
 
         self.head = self.latest(self.module, latest)
         if not self.head:
             raise util.Abort(_('no revision found in module %s') %
                              self.module.encode(self.encoding))
         self.last_changed = self.revnum(self.head)
 
         self._changescache = None
 
         if os.path.exists(os.path.join(url, '.svn/entries')):
             self.wc = url
         else:
             self.wc = None
         self.convertfp = None
 
     def setrevmap(self, revmap):
         lastrevs = {}
         for revid in revmap.iterkeys():
             uuid, module, revnum = self.revsplit(revid)
             lastrevnum = lastrevs.setdefault(module, revnum)
             if revnum > lastrevnum:
                 lastrevs[module] = revnum
         self.lastrevs = lastrevs
 
     def exists(self, path, optrev):
         try:
             svn.client.ls(self.url.rstrip('/') + '/' + urllib.quote(path),
                                  optrev, False, self.ctx)
             return True
         except SubversionException:
             return False
 
     def getheads(self):
 
         def isdir(path, revnum):
             kind = self._checkpath(path, revnum)
             return kind == svn.core.svn_node_dir
 
         def getcfgpath(name, rev):
             cfgpath = self.ui.config('convert', 'svn.' + name)
             if cfgpath is not None and cfgpath.strip() == '':
                 return None
             path = (cfgpath or name).strip('/')
             if not self.exists(path, rev):
                 if cfgpath:
                     raise util.Abort(_('expected %s to be at %r, but not found')
                                  % (name, path))
                 return None
             self.ui.note(_('found %s at %r\n') % (name, path))
             return path
 
         rev = optrev(self.last_changed)
         oldmodule = ''
         trunk = getcfgpath('trunk', rev)
         self.tags = getcfgpath('tags', rev)
         branches = getcfgpath('branches', rev)
 
         # If the project has a trunk or branches, we will extract heads
         # from them. We keep the project root otherwise.
         if trunk:
             oldmodule = self.module or ''
             self.module += '/' + trunk
             self.head = self.latest(self.module, self.last_changed)
             if not self.head:
                 raise util.Abort(_('no revision found in module %s') %
                                  self.module.encode(self.encoding))
 
         # First head in the list is the module's head
         self.heads = [self.head]
         if self.tags is not None:
             self.tags = '%s/%s' % (oldmodule , (self.tags or 'tags'))
 
         # Check if branches bring a few more heads to the list
         if branches:
             rpath = self.url.strip('/')
             branchnames = svn.client.ls(rpath + '/' + urllib.quote(branches),
                                         rev, False, self.ctx)
             for branch in branchnames.keys():
                 module = '%s/%s/%s' % (oldmodule, branches, branch)
                 if not isdir(module, self.last_changed):
                     continue
                 brevid = self.latest(module, self.last_changed)
                 if not brevid:
                     self.ui.note(_('ignoring empty branch %s\n') %
                                    branch.encode(self.encoding))
                     continue
                 self.ui.note(_('found branch %s at %d\n') %
                              (branch, self.revnum(brevid)))
                 self.heads.append(brevid)
 
         if self.startrev and self.heads:
             if len(self.heads) > 1:
                 raise util.Abort(_('svn: start revision is not supported '
                                    'with more than one branch'))
             revnum = self.revnum(self.heads[0])
             if revnum < self.startrev:
                 raise util.Abort(_('svn: no revision found after start revision %d')
                                  % self.startrev)
 
         return self.heads
 
     def getfile(self, file, rev):
         data, mode = self._getfile(file, rev)
         self.modecache[(file, rev)] = mode
         return data
 
     def getmode(self, file, rev):
         return self.modecache[(file, rev)]
 
     def getchanges(self, rev):
         if self._changescache and self._changescache[0] == rev:
             return self._changescache[1]
         self._changescache = None
         self.modecache = {}
         (paths, parents) = self.paths[rev]
         if parents:
             files, copies = self.expandpaths(rev, paths, parents)
         else:
             # Perform a full checkout on roots
             uuid, module, revnum = self.revsplit(rev)
             entries = svn.client.ls(self.baseurl + urllib.quote(module),
                                     optrev(revnum), True, self.ctx)
             files = [n for n,e in entries.iteritems()
                      if e.kind == svn.core.svn_node_file]
             copies = {}
 
         files.sort()
         files = zip(files, [rev] * len(files))
 
         # caller caches the result, so free it here to release memory
         del self.paths[rev]
         return (files, copies)
 
     def getchangedfiles(self, rev, i):
         changes = self.getchanges(rev)
         self._changescache = (rev, changes)
         return [f[0] for f in changes[0]]
 
     def getcommit(self, rev):
         if rev not in self.commits:
             uuid, module, revnum = self.revsplit(rev)
             self.module = module
             self.reparent(module)
             # We assume that:
             # - requests for revisions after "stop" come from the
             # revision graph backward traversal. Cache all of them
             # down to stop, they will be used eventually.
             # - requests for revisions before "stop" come to get
             # isolated branches parents. Just fetch what is needed.
             stop = self.lastrevs.get(module, 0)
             if revnum < stop:
                 stop = revnum + 1
             self._fetch_revisions(revnum, stop)
         commit = self.commits[rev]
         # caller caches the result, so free it here to release memory
         del self.commits[rev]
         return commit
 
     def gettags(self):
         tags = {}
         if self.tags is None:
             return tags
 
         # svn tags are just a convention, project branches left in a
         # 'tags' directory. There is no other relationship than
         # ancestry, which is expensive to discover and makes them hard
         # to update incrementally.  Worse, past revisions may be
         # referenced by tags far away in the future, requiring a deep
         # history traversal on every calculation.  Current code
         # performs a single backward traversal, tracking moves within
         # the tags directory (tag renaming) and recording a new tag
         # everytime a project is copied from outside the tags
         # directory. It also lists deleted tags, this behaviour may
         # change in the future.
         pendings = []
         tagspath = self.tags
         start = svn.ra.get_latest_revnum(self.ra)
         try:
             for entry in self._getlog([self.tags], start, self.startrev):
                 origpaths, revnum, author, date, message = entry
                 copies = [(e.copyfrom_path, e.copyfrom_rev, p) for p, e
                           in origpaths.iteritems() if e.copyfrom_path]
                 copies.sort()
                 # Apply moves/copies from more specific to general
                 copies.reverse()
 
                 srctagspath = tagspath
                 if copies and copies[-1][2] == tagspath:
                     # Track tags directory moves
                     srctagspath = copies.pop()[0]
 
                 for source, sourcerev, dest in copies:
                     if not dest.startswith(tagspath + '/'):
                         continue
                     for tag in pendings:
                         if tag[0].startswith(dest):
                             tagpath = source + tag[0][len(dest):]
                             tag[:2] = [tagpath, sourcerev]
                             break
                     else:
                         pendings.append([source, sourcerev, dest.split('/')[-1]])
 
                 # Tell tag renamings from tag creations
                 remainings = []
                 for source, sourcerev, tagname in pendings:
                     if source.startswith(srctagspath):
                         remainings.append([source, sourcerev, tagname])
                         continue
                     # From revision may be fake, get one with changes
                     try:
                         tagid = self.latest(source, sourcerev)
                         if tagid:
                             tags[tagname] = tagid
                     except SvnPathNotFound:
                         # It happens when we are following directories we assumed
                         # were copied with their parents but were really created
                         # in the tag directory.
                         pass
                 pendings = remainings
                 tagspath = srctagspath
 
         except SubversionException:
             self.ui.note(_('no tags found at revision %d\n') % start)
         return tags
 
     def converted(self, rev, destrev):
         if not self.wc:
             return
         if self.convertfp is None:
             self.convertfp = open(os.path.join(self.wc, '.svn', 'hg-shamap'),
                                   'a')
         self.convertfp.write('%s %d\n' % (destrev, self.revnum(rev)))
         self.convertfp.flush()
 
     # -- helper functions --
 
     def revid(self, revnum, module=None):
         if not module:
             module = self.module
         return u"svn:%s%s@%s" % (self.uuid, module.decode(self.encoding),
                                  revnum)
 
     def revnum(self, rev):
         return int(rev.split('@')[-1])
 
     def revsplit(self, rev):
         url, revnum = rev.encode(self.encoding).rsplit('@', 1)
         revnum = int(revnum)
         parts = url.split('/', 1)
         uuid = parts.pop(0)[4:]
         mod = ''
         if parts:
             mod = '/' + parts[0]
         return uuid, mod, revnum
 
     def latest(self, path, stop=0):
         """Find the latest revid affecting path, up to stop. It may return
         a revision in a different module, since a branch may be moved without
         a change being reported. Return None if computed module does not
         belong to rootmodule subtree.
         """
         if not path.startswith(self.rootmodule):
             # Requests on foreign branches may be forbidden at server level
             self.ui.debug(_('ignoring foreign branch %r\n') % path)
             return None
 
         if not stop:
             stop = svn.ra.get_latest_revnum(self.ra)
         try:
             prevmodule = self.reparent('')
             dirent = svn.ra.stat(self.ra, path.strip('/'), stop)
             self.reparent(prevmodule)
         except SubversionException:
             dirent = None
         if not dirent:
             raise SvnPathNotFound(_('%s not found up to revision %d') % (path, stop))
 
         # stat() gives us the previous revision on this line of development, but
         # it might be in *another module*. Fetch the log and detect renames down
         # to the latest revision.
         stream = self._getlog([path], stop, dirent.created_rev)
         try:
             for entry in stream:
                 paths, revnum, author, date, message = entry
                 if revnum <= dirent.created_rev:
                     break
 
                 for p in paths:
                     if not path.startswith(p) or not paths[p].copyfrom_path:
                         continue
                     newpath = paths[p].copyfrom_path + path[len(p):]
                     self.ui.debug(_("branch renamed from %s to %s at %d\n") %
                                   (path, newpath, revnum))
                     path = newpath
                     break
         finally:
             stream.close()
 
         if not path.startswith(self.rootmodule):
             self.ui.debug(_('ignoring foreign branch %r\n') % path)
             return None
         return self.revid(dirent.created_rev, path)
 
     def get_blacklist(self):
         """Avoid certain revision numbers.
         It is not uncommon for two nearby revisions to cancel each other
         out, e.g. 'I copied trunk into a subdirectory of itself instead
         of making a branch'. The converted repository is significantly
         smaller if we ignore such revisions."""
         self.blacklist = set()
         blacklist = self.blacklist
         for line in file("blacklist.txt", "r"):
             if not line.startswith("#"):
                 try:
                     svn_rev = int(line.strip())
                     blacklist.add(svn_rev)
                 except ValueError:
                     pass # not an integer or a comment
 
     def is_blacklisted(self, svn_rev):
         return svn_rev in self.blacklist
 
     def reparent(self, module):
         """Reparent the svn transport and return the previous parent."""
         if self.prevmodule == module:
             return module
         svnurl = self.baseurl + urllib.quote(module)
         prevmodule = self.prevmodule
         if prevmodule is None:
             prevmodule = ''
         self.ui.debug(_("reparent to %s\n") % svnurl)
         svn.ra.reparent(self.ra, svnurl)
         self.prevmodule = module
         return prevmodule
 
     def expandpaths(self, rev, paths, parents):
         entries = []
         copyfrom = {} # Map of entrypath, revision for finding source of deleted revisions.
         copies = {}
 
         new_module, revnum = self.revsplit(rev)[1:]
         if new_module != self.module:
             self.module = new_module
             self.reparent(self.module)
 
         for path, ent in paths:
             entrypath = self.getrelpath(path)
             entry = entrypath.decode(self.encoding)
 
             kind = self._checkpath(entrypath, revnum)
             if kind == svn.core.svn_node_file:
                 entries.append(self.recode(entry))
                 if not ent.copyfrom_path or not parents:
                     continue
                 # Copy sources not in parent revisions cannot be represented,
                 # ignore their origin for now
                 pmodule, prevnum = self.revsplit(parents[0])[1:]
                 if ent.copyfrom_rev < prevnum:
                     continue
                 copyfrom_path = self.getrelpath(ent.copyfrom_path, pmodule)
                 if not copyfrom_path:
                     continue
                 self.ui.debug(_("copied to %s from %s@%s\n") %
                               (entrypath, copyfrom_path, ent.copyfrom_rev))
                 copies[self.recode(entry)] = self.recode(copyfrom_path)
             elif kind == 0: # gone, but had better be a deleted *file*
                 self.ui.debug(_("gone from %s\n") % ent.copyfrom_rev)
 
                 # if a branch is created but entries are removed in the same
                 # changeset, get the right fromrev
                 # parents cannot be empty here, you cannot remove things from
                 # a root revision.
                 uuid, old_module, fromrev = self.revsplit(parents[0])
 
                 basepath = old_module + "/" + self.getrelpath(path)
                 entrypath = basepath
 
                 def lookup_parts(p):
                     rc = None
                     parts = p.split("/")
                     for i in range(len(parts)):
                         part = "/".join(parts[:i])
                         info = part, copyfrom.get(part, None)
                         if info[1] is not None:
                             self.ui.debug(_("found parent directory %s\n") % info[1])
                             rc = info
                     return rc
 
                 self.ui.debug(_("base, entry %s %s\n") % (basepath, entrypath))
 
                 frompath, froment = lookup_parts(entrypath) or (None, revnum - 1)
 
                 # need to remove fragment from lookup_parts and replace with copyfrom_path
                 if frompath is not None:
                     self.ui.debug(_("munge-o-matic\n"))
                     self.ui.debug(entrypath + '\n')
                     self.ui.debug(entrypath[len(frompath):] + '\n')
                     entrypath = froment.copyfrom_path + entrypath[len(frompath):]
                     fromrev = froment.copyfrom_rev
                     self.ui.debug(_("info: %s %s %s %s\n") % (frompath, froment, ent, entrypath))
 
                 # We can avoid the reparent calls if the module has not changed
                 # but it probably does not worth the pain.
                 prevmodule = self.reparent('')
                 fromkind = svn.ra.check_path(self.ra, entrypath.strip('/'), fromrev)
                 self.reparent(prevmodule)
 
                 if fromkind == svn.core.svn_node_file:   # a deleted file
                     entries.append(self.recode(entry))
                 elif fromkind == svn.core.svn_node_dir:
                     # print "Deleted/moved non-file:", revnum, path, ent
                     # children = self._find_children(path, revnum - 1)
                     # print "find children %s@%d from %d action %s" % (path, revnum, ent.copyfrom_rev, ent.action)
                     # Sometimes this is tricky. For example: in
                     # The Subversion Repository revision 6940 a dir
                     # was copied and one of its files was deleted
                     # from the new location in the same commit. This
                     # code can't deal with that yet.
                     if ent.action == 'C':
                         children = self._find_children(path, fromrev)
                     else:
                         oroot = entrypath.strip('/')
                         nroot = path.strip('/')
                         children = self._find_children(oroot, fromrev)
                         children = [s.replace(oroot,nroot) for s in children]
                     # Mark all [files, not directories] as deleted.
                     for child in children:
                         # Can we move a child directory and its
                         # parent in the same commit? (probably can). Could
                         # cause problems if instead of revnum -1,
                         # we have to look in (copyfrom_path, revnum - 1)
                         entrypath = self.getrelpath("/" + child, module=old_module)
                         if entrypath:
                             entry = self.recode(entrypath.decode(self.encoding))
                             if entry in copies:
                                 # deleted file within a copy
                                 del copies[entry]
                             else:
                                 entries.append(entry)
                 else:
                     self.ui.debug(_('unknown path in revision %d: %s\n') % \
                                   (revnum, path))
             elif kind == svn.core.svn_node_dir:
                 # Should probably synthesize normal file entries
                 # and handle as above to clean up copy/rename handling.
 
                 # If the directory just had a prop change,
                 # then we shouldn't need to look for its children.
                 if ent.action == 'M':
                     continue
 
                 # Also this could create duplicate entries. Not sure
                 # whether this will matter. Maybe should make entries a set.
                 # print "Changed directory", revnum, path, ent.action, ent.copyfrom_path, ent.copyfrom_rev
                 # This will fail if a directory was copied
                 # from another branch and then some of its files
                 # were deleted in the same transaction.
-                children = util.sort(self._find_children(path, revnum))
+                children = sorted(self._find_children(path, revnum))
                 for child in children:
                     # Can we move a child directory and its
                     # parent in the same commit? (probably can). Could
                     # cause problems if instead of revnum -1,
                     # we have to look in (copyfrom_path, revnum - 1)
                     entrypath = self.getrelpath("/" + child)
                     # print child, self.module, entrypath
                     if entrypath:
                         # Need to filter out directories here...
                         kind = self._checkpath(entrypath, revnum)
                         if kind != svn.core.svn_node_dir:
                             entries.append(self.recode(entrypath))
 
                 # Copies here (must copy all from source)
                 # Probably not a real problem for us if
                 # source does not exist
                 if not ent.copyfrom_path or not parents:
                     continue
                 # Copy sources not in parent revisions cannot be represented,
                 # ignore their origin for now
                 pmodule, prevnum = self.revsplit(parents[0])[1:]
                 if ent.copyfrom_rev < prevnum:
                     continue
                 copyfrompath = ent.copyfrom_path.decode(self.encoding)
                 copyfrompath = self.getrelpath(copyfrompath, pmodule)
                 if not copyfrompath:
                     continue
                 copyfrom[path] = ent
                 self.ui.debug(_("mark %s came from %s:%d\n")
                               % (path, copyfrompath, ent.copyfrom_rev))
                 children = self._find_children(ent.copyfrom_path, ent.copyfrom_rev)
                 children.sort()
                 for child in children:
                     entrypath = self.getrelpath("/" + child, pmodule)
                     if not entrypath:
                         continue
                     entry = entrypath.decode(self.encoding)
                     copytopath = path + entry[len(copyfrompath):]
                     copytopath = self.getrelpath(copytopath)
                     copies[self.recode(copytopath)] = self.recode(entry, pmodule)
 
         return (list(set(entries)), copies)
 
     def _fetch_revisions(self, from_revnum, to_revnum):
         if from_revnum < to_revnum:
             from_revnum, to_revnum = to_revnum, from_revnum
 
         self.child_cset = None
 
         def parselogentry(orig_paths, revnum, author, date, message):
             """Return the parsed commit object or None, and True if
             the revision is a branch root.
             """
             self.ui.debug(_("parsing revision %d (%d changes)\n") %
                           (revnum, len(orig_paths)))
 
             branched = False
             rev = self.revid(revnum)
             # branch log might return entries for a parent we already have
 
             if rev in self.commits or revnum < to_revnum:
                 return None, branched
 
             parents = []
             # check whether this revision is the start of a branch or part
             # of a branch renaming
-            orig_paths = util.sort(orig_paths.items())
+            orig_paths = sorted(orig_paths.iteritems())
             root_paths = [(p,e) for p,e in orig_paths if self.module.startswith(p)]
             if root_paths:
                 path, ent = root_paths[-1]
                 if ent.copyfrom_path:
                     branched = True
                     newpath = ent.copyfrom_path + self.module[len(path):]
                     # ent.copyfrom_rev may not be the actual last revision
                     previd = self.latest(newpath, ent.copyfrom_rev)
                     if previd is not None:
                         prevmodule, prevnum = self.revsplit(previd)[1:]
                         if prevnum >= self.startrev:
                             parents = [previd]
                             self.ui.note(_('found parent of branch %s at %d: %s\n') %
                                          (self.module, prevnum, prevmodule))
                 else:
                     self.ui.debug(_("no copyfrom path, don't know what to do.\n"))
 
             paths = []
             # filter out unrelated paths
             for path, ent in orig_paths:
                 if self.getrelpath(path) is None:
                     continue
                 paths.append((path, ent))
 
             # Example SVN datetime. Includes microseconds.
             # ISO-8601 conformant
             # '2007-01-04T17:35:00.902377Z'
             date = util.parsedate(date[:19] + " UTC", ["%Y-%m-%dT%H:%M:%S"])
 
             log = message and self.recode(message) or ''
             author = author and self.recode(author) or ''
             try:
                 branch = self.module.split("/")[-1]
                 if branch == 'trunk':
                     branch = ''
             except IndexError:
                 branch = None
 
             cset = commit(author=author,
                           date=util.datestr(date),
                           desc=log,
                           parents=parents,
                           branch=branch,
                           rev=rev.encode('utf-8'))
 
             self.commits[rev] = cset
             # The parents list is *shared* among self.paths and the
             # commit object. Both will be updated below.
             self.paths[rev] = (paths, cset.parents)
             if self.child_cset and not self.child_cset.parents:
                 self.child_cset.parents[:] = [rev]
             self.child_cset = cset
             return cset, branched
 
         self.ui.note(_('fetching revision log for "%s" from %d to %d\n') %
                      (self.module, from_revnum, to_revnum))
 
         try:
             firstcset = None
             lastonbranch = False
             stream = self._getlog([self.module], from_revnum, to_revnum)
             try:
                 for entry in stream:
                     paths, revnum, author, date, message = entry
                     if revnum < self.startrev:
                         lastonbranch = True
                         break
                     if self.is_blacklisted(revnum):
                         self.ui.note(_('skipping blacklisted revision %d\n')
                                      % revnum)
                         continue
                     if not paths:
                         self.ui.debug(_('revision %d has no entries\n') % revnum)
                         continue
                     cset, lastonbranch = parselogentry(paths, revnum, author,
                                                        date, message)
                     if cset:
                         firstcset = cset
                     if lastonbranch:
                         break
             finally:
                 stream.close()
 
             if not lastonbranch and firstcset and not firstcset.parents:
                 # The first revision of the sequence (the last fetched one)
                 # has invalid parents if not a branch root. Find the parent
                 # revision now, if any.
                 try:
                     firstrevnum = self.revnum(firstcset.rev)
                     if firstrevnum > 1:
                         latest = self.latest(self.module, firstrevnum - 1)
                         if latest:
                             firstcset.parents.append(latest)
                 except SvnPathNotFound:
                     pass
         except SubversionException, (inst, num):
             if num == svn.core.SVN_ERR_FS_NO_SUCH_REVISION:
                 raise util.Abort(_('svn: branch has no revision %s') % to_revnum)
             raise
 
     def _getfile(self, file, rev):
         # TODO: ra.get_file transmits the whole file instead of diffs.
         mode = ''
         try:
             new_module, revnum = self.revsplit(rev)[1:]
             if self.module != new_module:
                 self.module = new_module
                 self.reparent(self.module)
             io = StringIO()
             info = svn.ra.get_file(self.ra, file, revnum, io)
             data = io.getvalue()
             # ra.get_files() seems to keep a reference on the input buffer
             # preventing collection. Release it explicitely.
             io.close()
             if isinstance(info, list):
                 info = info[-1]
             mode = ("svn:executable" in info) and 'x' or ''
             mode = ("svn:special" in info) and 'l' or mode
         except SubversionException, e:
             notfound = (svn.core.SVN_ERR_FS_NOT_FOUND,
                 svn.core.SVN_ERR_RA_DAV_PATH_NOT_FOUND)
             if e.apr_err in notfound: # File not found
                 raise IOError()
             raise
         if mode == 'l':
             link_prefix = "link "
             if data.startswith(link_prefix):
                 data = data[len(link_prefix):]
         return data, mode
 
     def _find_children(self, path, revnum):
         path = path.strip('/')
         pool = Pool()
         rpath = '/'.join([self.baseurl, urllib.quote(path)]).strip('/')
         return ['%s/%s' % (path, x) for x in
                 svn.client.ls(rpath, optrev(revnum), True, self.ctx, pool).keys()]
 
     def getrelpath(self, path, module=None):
         if module is None:
             module = self.module
         # Given the repository url of this wc, say
         #   "http://server/plone/CMFPlone/branches/Plone-2_0-branch"
         # extract the "entry" portion (a relative path) from what
         # svn log --xml says, ie
         #   "/CMFPlone/branches/Plone-2_0-branch/tests/PloneTestCase.py"
         # that is to say "tests/PloneTestCase.py"
         if path.startswith(module):
             relative = path.rstrip('/')[len(module):]
             if relative.startswith('/'):
                 return relative[1:]
             elif relative == '':
                 return relative
 
         # The path is outside our tracked tree...
         self.ui.debug(_('%r is not under %r, ignoring\n') % (path, module))
         return None
 
     def _checkpath(self, path, revnum):
         # ra.check_path does not like leading slashes very much, it leads
         # to PROPFIND subversion errors
         return svn.ra.check_path(self.ra, path.strip('/'), revnum)
 
     def _getlog(self, paths, start, end, limit=0, discover_changed_paths=True,
                 strict_node_history=False):
         # Normalize path names, svn >= 1.5 only wants paths relative to
         # supplied URL
         relpaths = []
         for p in paths:
             if not p.startswith('/'):
                 p = self.module + '/' + p
             relpaths.append(p.strip('/'))
         args = [self.baseurl, relpaths, start, end, limit, discover_changed_paths,
                 strict_node_history]
         arg = encodeargs(args)
         hgexe = util.hgexecutable()
         cmd = '%s debugsvnlog' % util.shellquote(hgexe)
         stdin, stdout = util.popen2(cmd, 'b')
         stdin.write(arg)
         stdin.close()
         return logstream(stdout)
 
 pre_revprop_change = '''#!/bin/sh
 
 REPOS="$1"
 REV="$2"
 USER="$3"
 PROPNAME="$4"
 ACTION="$5"
 
 if [ "$ACTION" = "M" -a "$PROPNAME" = "svn:log" ]; then exit 0; fi
 if [ "$ACTION" = "A" -a "$PROPNAME" = "hg:convert-branch" ]; then exit 0; fi
 if [ "$ACTION" = "A" -a "$PROPNAME" = "hg:convert-rev" ]; then exit 0; fi
 
 echo "Changing prohibited revision property" >&2
 exit 1
 '''
 
 class svn_sink(converter_sink, commandline):
     commit_re = re.compile(r'Committed revision (\d+).', re.M)
 
     def prerun(self):
         if self.wc:
             os.chdir(self.wc)
 
     def postrun(self):
         if self.wc:
             os.chdir(self.cwd)
 
     def join(self, name):
         return os.path.join(self.wc, '.svn', name)
 
     def revmapfile(self):
         return self.join('hg-shamap')
 
     def authorfile(self):
         return self.join('hg-authormap')
 
     def __init__(self, ui, path):
         converter_sink.__init__(self, ui, path)
         commandline.__init__(self, ui, 'svn')
         self.delete = []
         self.setexec = []
         self.delexec = []
         self.copies = []
         self.wc = None
         self.cwd = os.getcwd()
 
         path = os.path.realpath(path)
 
         created = False
         if os.path.isfile(os.path.join(path, '.svn', 'entries')):
             self.wc = path
             self.run0('update')
         else:
             wcpath = os.path.join(os.getcwd(), os.path.basename(path) + '-wc')
 
             if os.path.isdir(os.path.dirname(path)):
                 if not os.path.exists(os.path.join(path, 'db', 'fs-type')):
                     ui.status(_('initializing svn repo %r\n') %
                               os.path.basename(path))
                     commandline(ui, 'svnadmin').run0('create', path)
                     created = path
                 path = util.normpath(path)
                 if not path.startswith('/'):
                     path = '/' + path
                 path = 'file://' + path
 
             ui.status(_('initializing svn wc %r\n') % os.path.basename(wcpath))
             self.run0('checkout', path, wcpath)
 
             self.wc = wcpath
         self.opener = util.opener(self.wc)
         self.wopener = util.opener(self.wc)
         self.childmap = mapfile(ui, self.join('hg-childmap'))
         self.is_exec = util.checkexec(self.wc) and util.is_exec or None
 
         if created:
             hook = os.path.join(created, 'hooks', 'pre-revprop-change')
             fp = open(hook, 'w')
             fp.write(pre_revprop_change)
             fp.close()
             util.set_flags(hook, False, True)
 
         xport = transport.SvnRaTransport(url=geturl(path))
         self.uuid = svn.ra.get_uuid(xport.ra)
 
     def wjoin(self, *names):
         return os.path.join(self.wc, *names)
 
     def putfile(self, filename, flags, data):
         if 'l' in flags:
             self.wopener.symlink(data, filename)
         else:
             try:
                 if os.path.islink(self.wjoin(filename)):
                     os.unlink(filename)
             except OSError:
                 pass
             self.wopener(filename, 'w').write(data)
 
             if self.is_exec:
                 was_exec = self.is_exec(self.wjoin(filename))
             else:
                 # On filesystems not supporting execute-bit, there is no way
                 # to know if it is set but asking subversion. Setting it
                 # systematically is just as expensive and much simpler.
                 was_exec = 'x' not in flags
 
             util.set_flags(self.wjoin(filename), False, 'x' in flags)
             if was_exec:
                 if 'x' not in flags:
                     self.delexec.append(filename)
             else:
                 if 'x' in flags:
                     self.setexec.append(filename)
 
     def _copyfile(self, source, dest):
         # SVN's copy command pukes if the destination file exists, but
         # our copyfile method expects to record a copy that has
         # already occurred.  Cross the semantic gap.
         wdest = self.wjoin(dest)
         exists = os.path.exists(wdest)
         if exists:
             fd, tempname = tempfile.mkstemp(
                 prefix='hg-copy-', dir=os.path.dirname(wdest))
             os.close(fd)
             os.unlink(tempname)
             os.rename(wdest, tempname)
         try:
             self.run0('copy', source, dest)
         finally:
             if exists:
                 try:
                     os.unlink(wdest)
                 except OSError:
                     pass
                 os.rename(tempname, wdest)
 
     def dirs_of(self, files):
         dirs = set()
         for f in files:
             if os.path.isdir(self.wjoin(f)):
                 dirs.add(f)
             for i in strutil.rfindall(f, '/'):
                 dirs.add(f[:i])
         return dirs
 
     def add_dirs(self, files):
-        add_dirs = [d for d in util.sort(self.dirs_of(files))
+        add_dirs = [d for d in sorted(self.dirs_of(files))
                     if not os.path.exists(self.wjoin(d, '.svn', 'entries'))]
         if add_dirs:
             self.xargs(add_dirs, 'add', non_recursive=True, quiet=True)
         return add_dirs
 
     def add_files(self, files):
         if files:
             self.xargs(files, 'add', quiet=True)
         return files
 
     def tidy_dirs(self, names):
-        dirs = util.sort(self.dirs_of(names))
-        dirs.reverse()
         deleted = []
-        for d in dirs:
+        for d in sorted(self.dirs_of(names), reverse=True):
             wd = self.wjoin(d)
             if os.listdir(wd) == '.svn':
                 self.run0('delete', d)
                 deleted.append(d)
         return deleted
 
     def addchild(self, parent, child):
         self.childmap[parent] = child
 
     def revid(self, rev):
         return u"svn:%s@%s" % (self.uuid, rev)
 
     def putcommit(self, files, copies, parents, commit, source):
         # Apply changes to working copy
         for f, v in files:
             try:
                 data = source.getfile(f, v)
             except IOError:
                 self.delete.append(f)
             else:
                 e = source.getmode(f, v)
                 self.putfile(f, e, data)
                 if f in copies:
                     self.copies.append([copies[f], f])
         files = [f[0] for f in files]
 
         for parent in parents:
             try:
                 return self.revid(self.childmap[parent])
             except KeyError:
                 pass
         entries = set(self.delete)
         files = frozenset(files)
         entries.update(self.add_dirs(files.difference(entries)))
         if self.copies:
             for s, d in self.copies:
                 self._copyfile(s, d)
             self.copies = []
         if self.delete:
             self.xargs(self.delete, 'delete')
             self.delete = []
         entries.update(self.add_files(files.difference(entries)))
         entries.update(self.tidy_dirs(entries))
         if self.delexec:
             self.xargs(self.delexec, 'propdel', 'svn:executable')
             self.delexec = []
         if self.setexec:
             self.xargs(self.setexec, 'propset', 'svn:executable', '*')
             self.setexec = []
 
         fd, messagefile = tempfile.mkstemp(prefix='hg-convert-')
         fp = os.fdopen(fd, 'w')
         fp.write(commit.desc)
         fp.close()
         try:
             output = self.run0('commit',
                                username=util.shortuser(commit.author),
                                file=messagefile,
                                encoding='utf-8')
             try:
                 rev = self.commit_re.search(output).group(1)
             except AttributeError:
                 self.ui.warn(_('unexpected svn output:\n'))
                 self.ui.warn(output)
                 raise util.Abort(_('unable to cope with svn output'))
             if commit.rev:
                 self.run('propset', 'hg:convert-rev', commit.rev,
                          revprop=True, revision=rev)
             if commit.branch and commit.branch != 'default':
                 self.run('propset', 'hg:convert-branch', commit.branch,
                          revprop=True, revision=rev)
             for parent in parents:
                 self.addchild(parent, rev)
             return self.revid(rev)
         finally:
             os.unlink(messagefile)
 
     def puttags(self, tags):
         self.ui.warn(_('XXX TAGS NOT IMPLEMENTED YET\n'))

hgext/inotify/server.py

@@ -1,762 +1,762 b''
 # server.py - inotify status server
 #
 # Copyright 2006, 2007, 2008 Bryan O'Sullivan <[e-mail]>
 # Copyright 2007, 2008 Brendan Cully <[e-mail]>
 #
 # This software may be used and distributed according to the terms
 # of the GNU General Public License, incorporated herein by reference.
 
 from mercurial.i18n import _
 from mercurial import osutil, util
 import common
 import errno, os, select, socket, stat, struct, sys, tempfile, time
 
 try:
     import linux as inotify
     from linux import watcher
 except ImportError:
     raise
 
 class AlreadyStartedException(Exception): pass
 
 def join(a, b):
     if a:
         if a[-1] == '/':
             return a + b
         return a + '/' + b
     return b
 
 walk_ignored_errors = (errno.ENOENT, errno.ENAMETOOLONG)
 
 def walkrepodirs(repo):
     '''Iterate over all subdirectories of this repo.
     Exclude the .hg directory, any nested repos, and ignored dirs.'''
     rootslash = repo.root + os.sep
     def walkit(dirname, top):
         hginside = False
         try:
             for name, kind in osutil.listdir(rootslash + dirname):
                 if kind == stat.S_IFDIR:
                     if name == '.hg':
                         hginside = True
                         if not top: break
                     else:
                         d = join(dirname, name)
                         if repo.dirstate._ignore(d):
                             continue
                         for subdir, hginsub in walkit(d, False):
                             if not hginsub:
                                 yield subdir, False
         except OSError, err:
             if err.errno not in walk_ignored_errors:
                 raise
         yield rootslash + dirname, hginside
     for dirname, hginside in walkit('', True):
         yield dirname
 
 def walk(repo, root):
     '''Like os.walk, but only yields regular files.'''
 
     # This function is critical to performance during startup.
 
     reporoot = root == ''
     rootslash = repo.root + os.sep
 
     def walkit(root, reporoot):
         files, dirs = [], []
         hginside = False
 
         try:
             fullpath = rootslash + root
             for name, kind in osutil.listdir(fullpath):
                 if kind == stat.S_IFDIR:
                     if name == '.hg':
                         hginside = True
                         if reporoot:
                             continue
                         else:
                             break
                     dirs.append(name)
                 elif kind in (stat.S_IFREG, stat.S_IFLNK):
                     path = join(root, name)
                     files.append((name, kind))
 
             yield hginside, fullpath, dirs, files
 
             for subdir in dirs:
                 path = join(root, subdir)
                 if repo.dirstate._ignore(path):
                     continue
                 for result in walkit(path, False):
                     if not result[0]:
                         yield result
         except OSError, err:
             if err.errno not in walk_ignored_errors:
                 raise
     for result in walkit(root, reporoot):
         yield result[1:]
 
 def _explain_watch_limit(ui, repo, count):
     path = '/proc/sys/fs/inotify/max_user_watches'
     try:
         limit = int(file(path).read())
     except IOError, err:
         if err.errno != errno.ENOENT:
             raise
         raise util.Abort(_('this system does not seem to '
                            'support inotify'))
     ui.warn(_('*** the current per-user limit on the number '
               'of inotify watches is %s\n') % limit)
     ui.warn(_('*** this limit is too low to watch every '
               'directory in this repository\n'))
     ui.warn(_('*** counting directories: '))
     ndirs = len(list(walkrepodirs(repo)))
     ui.warn(_('found %d\n') % ndirs)
     newlimit = min(limit, 1024)
     while newlimit < ((limit + ndirs) * 1.1):
         newlimit *= 2
     ui.warn(_('*** to raise the limit from %d to %d (run as root):\n') %
             (limit, newlimit))
     ui.warn(_('***  echo %d > %s\n') % (newlimit, path))
     raise util.Abort(_('cannot watch %s until inotify watch limit is raised')
                      % repo.root)
 
 class Watcher(object):
     poll_events = select.POLLIN
     statuskeys = 'almr!?'
 
     def __init__(self, ui, repo, master):
         self.ui = ui
         self.repo = repo
         self.wprefix = self.repo.wjoin('')
         self.timeout = None
         self.master = master
         self.mask = (
             inotify.IN_ATTRIB |
             inotify.IN_CREATE |
             inotify.IN_DELETE |
             inotify.IN_DELETE_SELF |
             inotify.IN_MODIFY |
             inotify.IN_MOVED_FROM |
             inotify.IN_MOVED_TO |
             inotify.IN_MOVE_SELF |
             inotify.IN_ONLYDIR |
             inotify.IN_UNMOUNT |
             0)
         try:
             self.watcher = watcher.Watcher()
         except OSError, err:
             raise util.Abort(_('inotify service not available: %s') %
                              err.strerror)
         self.threshold = watcher.Threshold(self.watcher)
         self.registered = True
         self.fileno = self.watcher.fileno
 
         self.repo.dirstate.__class__.inotifyserver = True
 
         self.tree = {}
         self.statcache = {}
         self.statustrees = dict([(s, {}) for s in self.statuskeys])
 
         self.watches = 0
         self.last_event = None
 
         self.eventq = {}
         self.deferred = 0
 
         self.ds_info = self.dirstate_info()
         self.scan()
 
     def event_time(self):
         last = self.last_event
         now = time.time()
         self.last_event = now
 
         if last is None:
             return 'start'
         delta = now - last
         if delta < 5:
             return '+%.3f' % delta
         if delta < 50:
             return '+%.2f' % delta
         return '+%.1f' % delta
 
     def dirstate_info(self):
         try:
             st = os.lstat(self.repo.join('dirstate'))
             return st.st_mtime, st.st_ino
         except OSError, err:
             if err.errno != errno.ENOENT:
                 raise
             return 0, 0
 
     def add_watch(self, path, mask):
         if not path:
             return
         if self.watcher.path(path) is None:
             if self.ui.debugflag:
                 self.ui.note(_('watching %r\n') % path[len(self.wprefix):])
             try:
                 self.watcher.add(path, mask)
                 self.watches += 1
             except OSError, err:
                 if err.errno in (errno.ENOENT, errno.ENOTDIR):
                     return
                 if err.errno != errno.ENOSPC:
                     raise
                 _explain_watch_limit(self.ui, self.repo, self.watches)
 
     def setup(self):
         self.ui.note(_('watching directories under %r\n') % self.repo.root)
         self.add_watch(self.repo.path, inotify.IN_DELETE)
         self.check_dirstate()
 
     def wpath(self, evt):
         path = evt.fullpath
         if path == self.repo.root:
             return ''
         if path.startswith(self.wprefix):
             return path[len(self.wprefix):]
         raise 'wtf? ' + path
 
     def dir(self, tree, path):
         if path:
             for name in path.split('/'):
                 tree.setdefault(name, {})
                 tree = tree[name]
         return tree
 
     def lookup(self, path, tree):
         if path:
             try:
                 for name in path.split('/'):
                     tree = tree[name]
             except KeyError:
                 return 'x'
             except TypeError:
                 return 'd'
         return tree
 
     def split(self, path):
         c = path.rfind('/')
         if c == -1:
             return '', path
         return path[:c], path[c+1:]
 
     def filestatus(self, fn, st):
         try:
             type_, mode, size, time = self.repo.dirstate._map[fn][:4]
         except KeyError:
             type_ = '?'
         if type_ == 'n':
             if not st:
                 return '!'
             st_mode, st_size, st_mtime = st
             if size == -1:
                 return 'l'
             if size and (size != st_size or (mode ^ st_mode) & 0100):
                 return 'm'
             if time != int(st_mtime):
                 return 'l'
             return 'n'
         if type_ in 'ma' and not st:
             return '!'
         if type_ == '?' and self.repo.dirstate._ignore(fn):
             return 'i'
         return type_
 
     def updatestatus(self, wfn, st=None, status=None):
         if st:
             status = self.filestatus(wfn, st)
         else:
             self.statcache.pop(wfn, None)
         root, fn = self.split(wfn)
         d = self.dir(self.tree, root)
         oldstatus = d.get(fn)
         isdir = False
         if oldstatus:
             try:
                 if not status:
                     if oldstatus in 'almn':
                         status = '!'
                     elif oldstatus == 'r':
                         status = 'r'
             except TypeError:
                 # oldstatus may be a dict left behind by a deleted
                 # directory
                 isdir = True
             else:
                 if oldstatus in self.statuskeys and oldstatus != status:
                     del self.dir(self.statustrees[oldstatus], root)[fn]
         if self.ui.debugflag and oldstatus != status:
             if isdir:
                 self.ui.note(_('status: %r dir(%d) -> %s\n') %
                              (wfn, len(oldstatus), status))
             else:
                 self.ui.note(_('status: %r %s -> %s\n') %
                              (wfn, oldstatus, status))
         if not isdir:
             if status and status != 'i':
                 d[fn] = status
                 if status in self.statuskeys:
                     dd = self.dir(self.statustrees[status], root)
                     if oldstatus != status or fn not in dd:
                         dd[fn] = status
             else:
                 d.pop(fn, None)
         elif not status:
             # a directory is being removed, check its contents
             for subfile, b in oldstatus.copy().iteritems():
                 self.updatestatus(wfn + '/' + subfile, None)
 
 
     def check_deleted(self, key):
         # Files that had been deleted but were present in the dirstate
         # may have vanished from the dirstate; we must clean them up.
         nuke = []
         for wfn, ignore in self.walk(key, self.statustrees[key]):
             if wfn not in self.repo.dirstate:
                 nuke.append(wfn)
         for wfn in nuke:
             root, fn = self.split(wfn)
             del self.dir(self.statustrees[key], root)[fn]
             del self.dir(self.tree, root)[fn]
 
     def scan(self, topdir=''):
         self.handle_timeout()
         ds = self.repo.dirstate._map.copy()
         self.add_watch(join(self.repo.root, topdir), self.mask)
         for root, dirs, entries in walk(self.repo, topdir):
             for d in dirs:
                 self.add_watch(join(root, d), self.mask)
             wroot = root[len(self.wprefix):]
             d = self.dir(self.tree, wroot)
             for fn, kind in entries:
                 wfn = join(wroot, fn)
                 self.updatestatus(wfn, self.getstat(wfn))
                 ds.pop(wfn, None)
         wtopdir = topdir
         if wtopdir and wtopdir[-1] != '/':
             wtopdir += '/'
         for wfn, state in ds.iteritems():
             if not wfn.startswith(wtopdir):
                 continue
             try:
                 st = self.stat(wfn)
             except OSError:
                 status = state[0]
                 self.updatestatus(wfn, None, status=status)
             else:
                 self.updatestatus(wfn, st)
         self.check_deleted('!')
         self.check_deleted('r')
 
     def check_dirstate(self):
         ds_info = self.dirstate_info()
         if ds_info == self.ds_info:
             return
         self.ds_info = ds_info
         if not self.ui.debugflag:
             self.last_event = None
         self.ui.note(_('%s dirstate reload\n') % self.event_time())
         self.repo.dirstate.invalidate()
         self.scan()
         self.ui.note(_('%s end dirstate reload\n') % self.event_time())
 
     def walk(self, states, tree, prefix=''):
         # This is the "inner loop" when talking to the client.
 
         for name, val in tree.iteritems():
             path = join(prefix, name)
             try:
                 if val in states:
                     yield path, val
             except TypeError:
                 for p in self.walk(states, val, path):
                     yield p
 
     def update_hgignore(self):
         # An update of the ignore file can potentially change the
         # states of all unknown and ignored files.
 
         # XXX If the user has other ignore files outside the repo, or
         # changes their list of ignore files at run time, we'll
         # potentially never see changes to them.  We could get the
         # client to report to us what ignore data they're using.
         # But it's easier to do nothing than to open that can of
         # worms.
 
         if '_ignore' in self.repo.dirstate.__dict__:
             delattr(self.repo.dirstate, '_ignore')
             self.ui.note(_('rescanning due to .hgignore change\n'))
             self.scan()
 
     def getstat(self, wpath):
         try:
             return self.statcache[wpath]
         except KeyError:
             try:
                 return self.stat(wpath)
             except OSError, err:
                 if err.errno != errno.ENOENT:
                     raise
 
     def stat(self, wpath):
         try:
             st = os.lstat(join(self.wprefix, wpath))
             ret = st.st_mode, st.st_size, st.st_mtime
             self.statcache[wpath] = ret
             return ret
         except OSError:
             self.statcache.pop(wpath, None)
             raise
 
     def created(self, wpath):
         if wpath == '.hgignore':
             self.update_hgignore()
         try:
             st = self.stat(wpath)
             if stat.S_ISREG(st[0]):
                 self.updatestatus(wpath, st)
         except OSError:
             pass
 
     def modified(self, wpath):
         if wpath == '.hgignore':
             self.update_hgignore()
         try:
             st = self.stat(wpath)
             if stat.S_ISREG(st[0]):
                 if self.repo.dirstate[wpath] in 'lmn':
                     self.updatestatus(wpath, st)
         except OSError:
             pass
 
     def deleted(self, wpath):
         if wpath == '.hgignore':
             self.update_hgignore()
         elif wpath.startswith('.hg/'):
             if wpath == '.hg/wlock':
                 self.check_dirstate()
             return
 
         self.updatestatus(wpath, None)
 
     def schedule_work(self, wpath, evt):
         self.eventq.setdefault(wpath, [])
         prev = self.eventq[wpath]
         try:
             if prev and evt == 'm' and prev[-1] in 'cm':
                 return
             self.eventq[wpath].append(evt)
         finally:
             self.deferred += 1
             self.timeout = 250
 
     def deferred_event(self, wpath, evt):
         if evt == 'c':
             self.created(wpath)
         elif evt == 'm':
             self.modified(wpath)
         elif evt == 'd':
             self.deleted(wpath)
 
     def process_create(self, wpath, evt):
         if self.ui.debugflag:
             self.ui.note(_('%s event: created %s\n') %
                          (self.event_time(), wpath))
 
         if evt.mask & inotify.IN_ISDIR:
             self.scan(wpath)
         else:
             self.schedule_work(wpath, 'c')
 
     def process_delete(self, wpath, evt):
         if self.ui.debugflag:
             self.ui.note(_('%s event: deleted %s\n') %
                          (self.event_time(), wpath))
 
         if evt.mask & inotify.IN_ISDIR:
             self.scan(wpath)
         self.schedule_work(wpath, 'd')
 
     def process_modify(self, wpath, evt):
         if self.ui.debugflag:
             self.ui.note(_('%s event: modified %s\n') %
                          (self.event_time(), wpath))
 
         if not (evt.mask & inotify.IN_ISDIR):
             self.schedule_work(wpath, 'm')
 
     def process_unmount(self, evt):
         self.ui.warn(_('filesystem containing %s was unmounted\n') %
                      evt.fullpath)
         sys.exit(0)
 
     def handle_event(self, fd, event):
         if self.ui.debugflag:
             self.ui.note(_('%s readable: %d bytes\n') %
                          (self.event_time(), self.threshold.readable()))
         if not self.threshold():
             if self.registered:
                 if self.ui.debugflag:
                     self.ui.note(_('%s below threshold - unhooking\n') %
                                  (self.event_time()))
                 self.master.poll.unregister(fd)
                 self.registered = False
                 self.timeout = 250
         else:
             self.read_events()
 
     def read_events(self, bufsize=None):
         events = self.watcher.read(bufsize)
         if self.ui.debugflag:
             self.ui.note(_('%s reading %d events\n') %
                          (self.event_time(), len(events)))
         for evt in events:
             wpath = self.wpath(evt)
             if evt.mask & inotify.IN_UNMOUNT:
                 self.process_unmount(wpath, evt)
             elif evt.mask & (inotify.IN_MODIFY | inotify.IN_ATTRIB):
                 self.process_modify(wpath, evt)
             elif evt.mask & (inotify.IN_DELETE | inotify.IN_DELETE_SELF |
                              inotify.IN_MOVED_FROM):
                 self.process_delete(wpath, evt)
             elif evt.mask & (inotify.IN_CREATE | inotify.IN_MOVED_TO):
                 self.process_create(wpath, evt)
 
     def handle_timeout(self):
         if not self.registered:
             if self.ui.debugflag:
                 self.ui.note(_('%s hooking back up with %d bytes readable\n') %
                              (self.event_time(), self.threshold.readable()))
             self.read_events(0)
             self.master.poll.register(self, select.POLLIN)
             self.registered = True
 
         if self.eventq:
             if self.ui.debugflag:
                 self.ui.note(_('%s processing %d deferred events as %d\n') %
                              (self.event_time(), self.deferred,
                               len(self.eventq)))
-            for wpath, evts in util.sort(self.eventq.items()):
+            for wpath, evts in sorted(self.eventq.iteritems()):
                 for evt in evts:
                     self.deferred_event(wpath, evt)
             self.eventq.clear()
             self.deferred = 0
         self.timeout = None
 
     def shutdown(self):
         self.watcher.close()
 
 class Server(object):
     poll_events = select.POLLIN
 
     def __init__(self, ui, repo, watcher, timeout):
         self.ui = ui
         self.repo = repo
         self.watcher = watcher
         self.timeout = timeout
         self.sock = socket.socket(socket.AF_UNIX)
         self.sockpath = self.repo.join('inotify.sock')
         self.realsockpath = None
         try:
             self.sock.bind(self.sockpath)
         except socket.error, err:
             if err[0] == errno.EADDRINUSE:
                 raise AlreadyStartedException(_('could not start server: %s')
                                               % err[1])
             if err[0] == "AF_UNIX path too long":
                 tempdir = tempfile.mkdtemp(prefix="hg-inotify-")
                 self.realsockpath = os.path.join(tempdir, "inotify.sock")
                 try:
                     self.sock.bind(self.realsockpath)
                     os.symlink(self.realsockpath, self.sockpath)
                 except (OSError, socket.error), inst:
                     try:
                         os.unlink(self.realsockpath)
                     except:
                         pass
                     os.rmdir(tempdir)
                     if inst.errno == errno.EEXIST:
                         raise AlreadyStartedException(_('could not start server: %s')
                                                       % inst.strerror)
                     raise
             else:
                 raise
         self.sock.listen(5)
         self.fileno = self.sock.fileno
 
     def handle_timeout(self):
         pass
 
     def handle_event(self, fd, event):
         sock, addr = self.sock.accept()
 
         cs = common.recvcs(sock)
         version = ord(cs.read(1))
 
         sock.sendall(chr(common.version))
 
         if version != common.version:
             self.ui.warn(_('received query from incompatible client '
                            'version %d\n') % version)
             return
 
         names = cs.read().split('\0')
 
         states = names.pop()
 
         self.ui.note(_('answering query for %r\n') % states)
 
         if self.watcher.timeout:
             # We got a query while a rescan is pending.  Make sure we
             # rescan before responding, or we could give back a wrong
             # answer.
             self.watcher.handle_timeout()
 
         if not names:
             def genresult(states, tree):
                 for fn, state in self.watcher.walk(states, tree):
                     yield fn
         else:
             def genresult(states, tree):
                 for fn in names:
                     l = self.watcher.lookup(fn, tree)
                     try:
                         if l in states:
                             yield fn
                     except TypeError:
                         for f, s in self.watcher.walk(states, l, fn):
                             yield f
 
         results = ['\0'.join(r) for r in [
             genresult('l', self.watcher.statustrees['l']),
             genresult('m', self.watcher.statustrees['m']),
             genresult('a', self.watcher.statustrees['a']),
             genresult('r', self.watcher.statustrees['r']),
             genresult('!', self.watcher.statustrees['!']),
             '?' in states and genresult('?', self.watcher.statustrees['?']) or [],
             [],
             'c' in states and genresult('n', self.watcher.tree) or [],
             ]]
 
         try:
             try:
                 sock.sendall(struct.pack(common.resphdrfmt,
                                          *map(len, results)))
                 sock.sendall(''.join(results))
             finally:
                 sock.shutdown(socket.SHUT_WR)
         except socket.error, err:
             if err[0] != errno.EPIPE:
                 raise
 
     def shutdown(self):
         self.sock.close()
         try:
             os.unlink(self.sockpath)
             if self.realsockpath:
                 os.unlink(self.realsockpath)
                 os.rmdir(os.path.dirname(self.realsockpath))
         except OSError, err:
             if err.errno != errno.ENOENT:
                 raise
 
 class Master(object):
     def __init__(self, ui, repo, timeout=None):
         self.ui = ui
         self.repo = repo
         self.poll = select.poll()
         self.watcher = Watcher(ui, repo, self)
         self.server = Server(ui, repo, self.watcher, timeout)
         self.table = {}
         for obj in (self.watcher, self.server):
             fd = obj.fileno()
             self.table[fd] = obj
             self.poll.register(fd, obj.poll_events)
 
     def register(self, fd, mask):
         self.poll.register(fd, mask)
 
     def shutdown(self):
         for obj in self.table.itervalues():
             obj.shutdown()
 
     def run(self):
         self.watcher.setup()
         self.ui.note(_('finished setup\n'))
         if os.getenv('TIME_STARTUP'):
             sys.exit(0)
         while True:
             timeout = None
             timeobj = None
             for obj in self.table.itervalues():
                 if obj.timeout is not None and (timeout is None or obj.timeout < timeout):
                     timeout, timeobj = obj.timeout, obj
             try:
                 if self.ui.debugflag:
                     if timeout is None:
                         self.ui.note(_('polling: no timeout\n'))
                     else:
                         self.ui.note(_('polling: %sms timeout\n') % timeout)
                 events = self.poll.poll(timeout)
             except select.error, err:
                 if err[0] == errno.EINTR:
                     continue
                 raise
             if events:
                 for fd, event in events:
                     self.table[fd].handle_event(fd, event)
             elif timeobj:
                 timeobj.handle_timeout()
 
 def start(ui, repo):
     def closefds(ignore):
         # (from python bug #1177468)
         # close all inherited file descriptors
         # Python 2.4.1 and later use /dev/urandom to seed the random module's RNG
         # a file descriptor is kept internally as os._urandomfd (created on demand
         # the first time os.urandom() is called), and should not be closed
         try:
             os.urandom(4)
             urandom_fd = getattr(os, '_urandomfd', None)
         except AttributeError:
             urandom_fd = None
         ignore.append(urandom_fd)
         for fd in range(3, 256):
             if fd in ignore:
                 continue
             try:
                 os.close(fd)
             except OSError:
                 pass
 
     m = Master(ui, repo)
     sys.stdout.flush()
     sys.stderr.flush()
 
     pid = os.fork()
     if pid:
         return pid
 
     closefds([m.server.fileno(), m.watcher.fileno()])
     os.setsid()
 
     fd = os.open('/dev/null', os.O_RDONLY)
     os.dup2(fd, 0)
     if fd > 0:
         os.close(fd)
 
     fd = os.open(ui.config('inotify', 'log', '/dev/null'),
                  os.O_RDWR | os.O_CREAT | os.O_TRUNC)
     os.dup2(fd, 1)
     os.dup2(fd, 2)
     if fd > 2:
         os.close(fd)
 
     try:
         m.run()
     finally:
         m.shutdown()
         os._exit(0)

hgext/keyword.py

@@ -1,539 +1,539 b''
 # keyword.py - $Keyword$ expansion for Mercurial
 #
 # Copyright 2007, 2008 Christian Ebert <[e-mail]>
 #
 # This software may be used and distributed according to the terms
 # of the GNU General Public License, incorporated herein by reference.
 #
 # $Id$
 #
 # Keyword expansion hack against the grain of a DSCM
 #
 # 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://www.selenic.com/mercurial/wiki/index.cgi/KeywordPlan>.
 #
 # Keyword expansion is based on Mercurial's changeset template mappings.
 #
 # Binary files are not touched.
 #
 # Setup in hgrc:
 #
 #   [extensions]
 #   # enable extension
 #   hgext.keyword =
 #
 # 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.
 
 '''keyword expansion in local repositories
 
 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.
 
 Configuration is done in the [keyword] and [keywordmaps] sections of
 hgrc files.
 
 Example:
 
     [keyword]
     # expand keywords in every python file except those matching "x*"
     **.py =
     x*    = ignore
 
 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".
 
 An additional date template filter {date|utcdate} is provided.
 
 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 config changes.
 
 Before changing/disabling active keywords, run "hg kwshrink" to avoid
 the risk of inadvertedly storing expanded keywords in the change
 history.
 
 To force expansion after enabling it, or a configuration change, run
 "hg kwexpand".
 
 Also, when committing with the record extension or using mq's qrecord,
 be aware that keywords cannot be updated. Again, run "hg kwexpand" on
 the files in question to update keyword expansions after all changes
 have been checked in.
 
 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, cmdutil, dispatch, filelog, revlog, extensions
 from mercurial import patch, localrepo, templater, templatefilters, util
 from mercurial.hgweb import webcommands
 from mercurial.lock import release
 from mercurial.node import nullid, hex
 from mercurial.i18n import _
 import re, shutil, tempfile, time
 
 commands.optionalrepo += ' kwdemo'
 
 # hg commands that do not act on keywords
 nokwcommands = ('add addremove annotate bundle copy export grep incoming init'
                 ' log outgoing push rename rollback 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 record resolve qfold qimport qnew qpush qrefresh qrecord'
 
 def utcdate(date):
     '''Returns hgdate in cvs-like UTC format.'''
     return time.strftime('%Y/%m/%d %H:%M:%S', time.gmtime(date[0]))
 
 # make keyword tools accessible
 kwtools = {'templater': None, 'hgcmd': '', 'inc': [], 'exc': ['.hg*']}
 
 
 class kwtemplater(object):
     '''
     Sets up keyword templates, corresponding keyword regex, and
     provides keyword substitution functions.
     '''
     templates = {
         'Revision': '{node|short}',
         'Author': '{author|user}',
         'Date': '{date|utcdate}',
         'RCSFile': '{file|basename},v',
         'Source': '{root}/{file},v',
         'Id': '{file|basename},v {node|short} {date|utcdate} {author|user}',
         'Header': '{root}/{file},v {node|short} {date|utcdate} {author|user}',
     }
 
     def __init__(self, ui, repo):
         self.ui = ui
         self.repo = repo
         self.matcher = util.matcher(repo.root,
                                     inc=kwtools['inc'], exc=kwtools['exc'])[1]
         self.restrict = kwtools['hgcmd'] in restricted.split()
 
         kwmaps = self.ui.configitems('keywordmaps')
         if kwmaps: # override default templates
             kwmaps = [(k, templater.parsestring(v, False))
                       for (k, v) in kwmaps]
             self.templates = dict(kwmaps)
         escaped = map(re.escape, self.templates.keys())
         kwpat = r'\$(%s)(: [^$\n\r]*? )??\$' % '|'.join(escaped)
         self.re_kw = re.compile(kwpat)
 
         templatefilters.filters['utcdate'] = utcdate
         self.ct = cmdutil.changeset_templater(self.ui, self.repo,
                                               False, None, '', False)
 
     def substitute(self, data, path, ctx, subfunc):
         '''Replaces keywords in data with expanded template.'''
         def kwsub(mobj):
             kw = mobj.group(1)
             self.ct.use_template(self.templates[kw])
             self.ui.pushbuffer()
             self.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 expand(self, path, node, data):
         '''Returns data with keywords expanded.'''
         if not self.restrict and self.matcher(path) and not util.binary(data):
             ctx = self.repo.filectx(path, fileid=node).changectx()
             return self.substitute(data, path, ctx, self.re_kw.sub)
         return data
 
     def iskwfile(self, path, flagfunc):
         '''Returns true if path matches [keyword] pattern
         and is not a symbolic link.
         Caveat: localrepository._link fails on Windows.'''
         return self.matcher(path) and not 'l' in flagfunc(path)
 
     def overwrite(self, node, expand, files):
         '''Overwrites selected files expanding/shrinking keywords.'''
         ctx = self.repo[node]
         mf = ctx.manifest()
         if node is not None:     # commit
             files = [f for f in ctx.files() if f in mf]
             notify = self.ui.debug
         else:                    # kwexpand/kwshrink
             notify = self.ui.note
         candidates = [f for f in files if self.iskwfile(f, ctx.flags)]
         if candidates:
             self.restrict = True # do not expand when reading
             msg = (expand and _('overwriting %s expanding keywords\n')
                    or _('overwriting %s shrinking keywords\n'))
             for f in candidates:
                 fp = self.repo.file(f)
                 data = fp.read(mf[f])
                 if util.binary(data):
                     continue
                 if expand:
                     if node is None:
                         ctx = self.repo.filectx(f, fileid=mf[f]).changectx()
                     data, found = self.substitute(data, f, ctx,
                                                   self.re_kw.subn)
                 else:
                     found = self.re_kw.search(data)
                 if found:
                     notify(msg % f)
                     self.repo.wwrite(f, data, mf.flags(f))
                     self.repo.dirstate.normal(f)
             self.restrict = False
 
     def shrinktext(self, text):
         '''Unconditionally removes all keyword substitutions from text.'''
         return self.re_kw.sub(r'$\1$', text)
 
     def shrink(self, fname, text):
         '''Returns text with all keyword substitutions removed.'''
         if self.matcher(fname) and not util.binary(text):
             return self.shrinktext(text)
         return text
 
     def shrinklines(self, fname, lines):
         '''Returns lines with keyword substitutions removed.'''
         if self.matcher(fname):
             text = ''.join(lines)
             if not util.binary(text):
                 return self.shrinktext(text).splitlines(True)
         return lines
 
     def wread(self, fname, data):
         '''If in restricted mode returns data read from wdir with
         keyword substitutions removed.'''
         return self.restrict and self.shrink(fname, data) or 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)
         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)
         if self.renamed(node):
             t2 = super(kwfilelog, self).read(node)
             return t2 != text
         return revlog.revlog.cmp(self, node, text)
 
 def _status(ui, repo, kwt, unknown, *pats, **opts):
     '''Bails out if [keyword] configuration is not active.
     Returns status of working directory.'''
     if kwt:
         matcher = cmdutil.match(repo, pats, opts)
         return repo.status(match=matcher, unknown=unknown, clean=True)
     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.'''
     if repo.dirstate.parents()[1] != nullid:
         raise util.Abort(_('outstanding uncommitted merge'))
     kwt = kwtools['templater']
     status = _status(ui, repo, kwt, False, *pats, **opts)
     modified, added, removed, deleted = status[:4]
     if modified or added or removed or deleted:
         raise util.Abort(_('outstanding uncommitted changes'))
     wlock = lock = None
     try:
         wlock = repo.wlock()
         lock = repo.lock()
         kwt.overwrite(None, expand, status[6])
     finally:
         release(lock, wlock)
 
 def demo(ui, repo, *args, **opts):
     '''print [keywordmaps] configuration and an expansion example
 
     Show current, custom, or default keyword template maps and their
     expansion.
 
     Extend current configuration by specifying maps as arguments and
     optionally by reading from an additional hgrc file.
 
     Override current keyword template maps with "default" option.
     '''
     def demostatus(stat):
         ui.status(_('\n\t%s\n') % stat)
 
     def demoitems(section, items):
         ui.write('[%s]\n' % section)
         for k, v in items:
             ui.write('%s = %s\n' % (k, v))
 
     msg = 'hg keyword config and expansion example'
     kwstatus = 'current'
     fn = 'demo.txt'
     branchname = 'demobranch'
     tmpdir = tempfile.mkdtemp('', 'kwdemo.')
     ui.note(_('creating temporary repository at %s\n') % tmpdir)
     repo = localrepo.localrepository(ui, tmpdir, True)
     ui.setconfig('keyword', fn, '')
     if args or opts.get('rcfile'):
         kwstatus = 'custom'
     if opts.get('rcfile'):
         ui.readconfig(opts.get('rcfile'))
     if opts.get('default'):
         kwstatus = 'default'
         kwmaps = kwtemplater.templates
         if ui.configitems('keywordmaps'):
             # override maps from optional rcfile
             for k, v in kwmaps.iteritems():
                 ui.setconfig('keywordmaps', k, v)
     elif args:
         # simulate hgrc parsing
         rcmaps = ['[keywordmaps]\n'] + [a + '\n' for a in args]
         fp = repo.opener('hgrc', 'w')
         fp.writelines(rcmaps)
         fp.close()
         ui.readconfig(repo.join('hgrc'))
     if not opts.get('default'):
         kwmaps = dict(ui.configitems('keywordmaps')) or kwtemplater.templates
     uisetup(ui)
     reposetup(ui, repo)
     for k, v in ui.configitems('extensions'):
         if k.endswith('keyword'):
             extension = '%s = %s' % (k, v)
             break
     demostatus('config using %s keyword template maps' % kwstatus)
     ui.write('[extensions]\n%s\n' % extension)
     demoitems('keyword', ui.configitems('keyword'))
     demoitems('keywordmaps', kwmaps.iteritems())
     keywords = '$' + '$\n$'.join(kwmaps.keys()) + '$\n'
     repo.wopener(fn, 'w').write(keywords)
     repo.add([fn])
     path = repo.wjoin(fn)
     ui.note(_('\n%s keywords written to %s:\n') % (kwstatus, path))
     ui.note(keywords)
     ui.note('\nhg -R "%s" branch "%s"\n' % (tmpdir, branchname))
     # silence branch command if not verbose
     quiet = ui.quiet
     ui.quiet = not ui.verbose
     commands.branch(ui, repo, branchname)
     ui.quiet = quiet
     for name, cmd in ui.configitems('hooks'):
         if name.split('.', 1)[0].find('commit') > -1:
             repo.ui.setconfig('hooks', name, '')
     ui.note(_('unhooked all commit hooks\n'))
     ui.note('hg -R "%s" ci -m "%s"\n' % (tmpdir, msg))
     repo.commit(text=msg)
     fmt = ui.verbose and ' in %s' % path or ''
     demostatus('%s keywords expanded%s' % (kwstatus, fmt))
     ui.write(repo.wread(fn))
     ui.debug(_('\nremoving temporary repository %s\n') % tmpdir)
     shutil.rmtree(tmpdir, ignore_errors=True)
 
 def expand(ui, repo, *pats, **opts):
     '''expand keywords in 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)
 
 def files(ui, repo, *pats, **opts):
     '''print files currently configured for keyword expansion
 
     Crosscheck which files in working directory are potential targets
     for keyword expansion. That is, files matched by [keyword] config
     patterns but not symlinks.
     '''
     kwt = kwtools['templater']
     status = _status(ui, repo, kwt, opts.get('untracked'), *pats, **opts)
     modified, added, removed, deleted, unknown, ignored, clean = status
-    files = util.sort(modified + added + clean + unknown)
+    files = sorted(modified + added + clean + unknown)
     wctx = repo[None]
     kwfiles = [f for f in files if kwt.iskwfile(f, wctx.flags)]
     cwd = pats and repo.getcwd() or ''
     kwfstats = not opts.get('ignore') and (('K', kwfiles),) or ()
     if opts.get('all') or opts.get('ignore'):
         kwfstats += (('I', [f for f in files if f not in kwfiles]),)
     for char, filenames in kwfstats:
         fmt = (opts.get('all') or ui.verbose) and '%s %%s\n' % char or '%s\n'
         for f in filenames:
             ui.write(fmt % repo.pathto(f, cwd))
 
 def shrink(ui, repo, *pats, **opts):
     '''revert expanded keywords in working directory
 
     Run before changing/disabling active keywords or if you experience
     problems with "hg import" or "hg merge".
 
     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):
     '''Collects [keyword] config in kwtools.
     Monkeypatches dispatch._parse if needed.'''
 
     for pat, opt in ui.configitems('keyword'):
         if opt != 'ignore':
             kwtools['inc'].append(pat)
         else:
             kwtools['exc'].append(pat)
 
     if kwtools['inc']:
         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 not kwtools['inc']
             or kwtools['hgcmd'] in nokwcommands.split()
             or '.hg' in util.splitpath(repo.root)
             or repo._url.startswith('bundle:')):
             return
     except AttributeError:
         pass
 
     kwtools['templater'] = kwt = kwtemplater(ui, repo)
 
     class kwrepo(repo.__class__):
         def file(self, f):
             if f[0] == '/':
                 f = f[1:]
             return kwfilelog(self.sopener, kwt, f)
 
         def wread(self, filename):
             data = super(kwrepo, self).wread(filename)
             return kwt.wread(filename, data)
 
         def commit(self, files=None, text='', user=None, date=None,
                    match=None, force=False, force_editor=False,
                    p1=None, p2=None, extra={}, empty_ok=False):
             wlock = lock = None
             _p1 = _p2 = None
             try:
                 wlock = self.wlock()
                 lock = self.lock()
                 # store and postpone commit hooks
                 commithooks = {}
                 for name, cmd in ui.configitems('hooks'):
                     if name.split('.', 1)[0] == 'commit':
                         commithooks[name] = cmd
                         ui.setconfig('hooks', name, None)
                 if commithooks:
                     # store parents for commit hook environment
                     if p1 is None:
                         _p1, _p2 = repo.dirstate.parents()
                     else:
                         _p1, _p2 = p1, p2 or nullid
                     _p1 = hex(_p1)
                     if _p2 == nullid:
                         _p2 = ''
                     else:
                         _p2 = hex(_p2)
 
                 n = super(kwrepo, self).commit(files, text, user, date, match,
                                                force, force_editor, p1, p2,
                                                extra, empty_ok)
 
                 # restore commit hooks
                 for name, cmd in commithooks.iteritems():
                     ui.setconfig('hooks', name, cmd)
                 if n is not None:
                     kwt.overwrite(n, True, None)
                     repo.hook('commit', node=n, parent1=_p1, parent2=_p2)
                 return n
             finally:
                 release(lock, wlock)
 
     # monkeypatches
     def kwpatchfile_init(orig, self, ui, fname, opener, missing=False):
         '''Monkeypatch/wrap patch.patchfile.__init__ to avoid
         rejects or conflicts due to expanded keywords in working dir.'''
         orig(self, ui, fname, opener, missing)
         # shrink keywords read from working dir
         self.lines = kwt.shrinklines(self.fname, self.lines)
 
     def kw_diff(orig, repo, node1=None, node2=None, match=None, changes=None,
                 opts=None):
         '''Monkeypatch patch.diff to avoid expansion except when
         comparing against working dir.'''
         if node2 is not None:
             kwt.matcher = util.never
         elif node1 is not None and node1 != repo['.'].node():
             kwt.restrict = True
         return orig(repo, node1, node2, match, changes, opts)
 
     def kwweb_skip(orig, web, req, tmpl):
         '''Wraps webcommands.x turning off keyword expansion.'''
         kwt.matcher = util.never
         return orig(web, req, tmpl)
 
     repo.__class__ = kwrepo
 
     extensions.wrapfunction(patch.patchfile, '__init__', kwpatchfile_init)
     extensions.wrapfunction(patch, 'diff', kw_diff)
     for c in 'annotate changeset rev filediff diff'.split():
         extensions.wrapfunction(webcommands, c, kwweb_skip)
 
 cmdtable = {
     'kwdemo':
         (demo,
          [('d', 'default', None, _('show default keyword template maps')),
           ('f', 'rcfile', [], _('read maps from rcfile'))],
          _('hg kwdemo [-d] [-f RCFILE] [TEMPLATEMAP]...')),
     'kwexpand': (expand, commands.walkopts,
                  _('hg kwexpand [OPTION]... [FILE]...')),
     'kwfiles':
         (files,
          [('a', 'all', None, _('show keyword status flags of all files')),
           ('i', 'ignore', None, _('show files excluded from expansion')),
           ('u', 'untracked', None, _('additionally show untracked files')),
          ] + commands.walkopts,
          _('hg kwfiles [OPTION]... [FILE]...')),
     'kwshrink': (shrink, commands.walkopts,
                  _('hg kwshrink [OPTION]... [FILE]...')),
 }

hgext/mq.py

@@ -1,2610 +1,2608 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, incorporated herein by reference.
 
 '''patch management and development
 
 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):
 
 prepare repository to work with patches   qinit
 create new patch                          qnew
 import existing patch                     qimport
 
 print patch series                        qseries
 print applied patches                     qapplied
 print name of top applied patch           qtop
 
 add known patch to applied stack          qpush
 remove patch from applied stack           qpop
 refresh contents of top applied patch     qrefresh
 '''
 
 from mercurial.i18n import _
 from mercurial.node import bin, hex, short, nullid, nullrev
 from mercurial.lock import release
 from mercurial import commands, cmdutil, hg, patch, util
 from mercurial import repair, extensions, url, error
 import os, sys, re, errno
 
 commands.norepo += " qclone"
 
 # 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:
     def __init__(self, rev, name=None):
         if not name:
             fields = rev.split(':', 1)
             if len(fields) == 2:
                 self.rev, self.name = fields
             else:
                 self.rev, self.name = None, None
         else:
             self.rev, self.name = rev, name
 
     def __str__(self):
         return self.rev + ':' + self.name
 
 class patchheader(object):
     def __init__(self, message, comments, user, date, haspatch):
         self.message = message
         self.comments = comments
         self.user = user
         self.date = date
         self.haspatch = haspatch
 
     def setuser(self, user):
         if not self.setheader(['From: ', '# User '], user):
             try:
                 patchheaderat = self.comments.index('# HG changeset patch')
                 self.comments.insert(patchheaderat + 1,'# User ' + user)
             except ValueError:
                 self.comments = ['From: ' + user, ''] + self.comments
         self.user = user
 
     def setdate(self, date):
         if self.setheader(['# Date '], date):
             self.date = date
 
     def setmessage(self, message):
         if self.comments:
             self._delmsg()
         self.message = [message]
         self.comments += self.message
 
     def setheader(self, prefixes, new):
         '''Update all references to a field in the patch header.
         If none found, add it email style.'''
         res = False
         for prefix in prefixes:
             for i in xrange(len(self.comments)):
                 if self.comments[i].startswith(prefix):
                     self.comments[i] = prefix + new
                     res = True
                     break
         return res
 
     def __str__(self):
         if not self.comments:
             return ''
         return '\n'.join(self.comments) + '\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 xrange(len(self.message)):
             while self.message[mi] != self.comments[ci]:
                 ci += 1
             del self.comments[ci]
 
 class queue:
     def __init__(self, ui, path, patchdir=None):
         self.basepath = path
         self.path = patchdir or os.path.join(path, "patches")
         self.opener = util.opener(self.path)
         self.ui = ui
         self.applied = []
         self.full_series = []
         self.applied_dirty = 0
         self.series_dirty = 0
         self.series_path = "series"
         self.status_path = "status"
         self.guards_path = "guards"
         self.active_guards = None
         self.guards_dirty = False
         self._diffopts = None
 
         if os.path.exists(self.join(self.series_path)):
             self.full_series = self.opener(self.series_path).read().splitlines()
         self.parse_series()
 
         if os.path.exists(self.join(self.status_path)):
             lines = self.opener(self.status_path).read().splitlines()
             self.applied = [statusentry(l) for l in lines]
 
     def diffopts(self):
         if self._diffopts is None:
             self._diffopts = patch.diffopts(self.ui)
         return self._diffopts
 
     def join(self, *p):
         return os.path.join(self.path, *p)
 
     def find_series(self, patch):
         pre = re.compile("(\s*)([^#]+)")
         index = 0
         for l in self.full_series:
             m = pre.match(l)
             if m:
                 s = m.group(2)
                 s = s.rstrip()
                 if s == patch:
                     return index
             index += 1
         return None
 
     guard_re = re.compile(r'\s?#([-+][^-+# \t\r\n\f][^# \t\r\n\f]*)')
 
     def parse_series(self):
         self.series = []
         self.series_guards = []
         for l in self.full_series:
             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.series_path)))
                 self.series.append(patch)
                 self.series_guards.append(self.guard_re.findall(comment))
 
     def check_guard(self, guard):
         if not guard:
             return _('guard cannot be an empty string')
         bad_chars = '# \t\r\n\f'
         first = guard[0]
         for c in '-+':
             if first == c:
                 return (_('guard %r starts with invalid character: %r') %
                         (guard, c))
         for c in bad_chars:
             if c in guard:
                 return _('invalid character in guard %r: %r') % (guard, c)
 
     def set_active(self, guards):
         for guard in guards:
             bad = self.check_guard(guard)
             if bad:
                 raise util.Abort(bad)
-        guards = util.sort(set(guards))
+        guards = sorted(set(guards))
         self.ui.debug(_('active guards: %s\n') % ' '.join(guards))
         self.active_guards = guards
         self.guards_dirty = True
 
     def active(self):
         if self.active_guards is None:
             self.active_guards = []
             try:
                 guards = self.opener(self.guards_path).read().split()
             except IOError, err:
                 if err.errno != errno.ENOENT: raise
                 guards = []
             for i, guard in enumerate(guards):
                 bad = self.check_guard(guard)
                 if bad:
                     self.ui.warn('%s:%d: %s\n' %
                                  (self.join(self.guards_path), i + 1, bad))
                 else:
                     self.active_guards.append(guard)
         return self.active_guards
 
     def set_guards(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.check_guard(g[1:])
             if bad:
                 raise util.Abort(bad)
         drop = self.guard_re.sub('', self.full_series[idx])
         self.full_series[idx] = drop + ''.join([' #' + g for g in guards])
         self.parse_series()
         self.series_dirty = True
 
     def pushable(self, idx):
         if isinstance(idx, str):
             idx = self.series.index(idx)
         patchguards = self.series_guards[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, 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, exactpos[0]
             return False, pos
         return True, ''
 
     def explain_pushable(self, idx, all_patches=False):
         write = all_patches and self.ui.write or 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 %r\n') %
                               (self.series[idx], why))
             if not pushable:
                 if why:
                     write(_('skipping %s - guarded by %r\n') %
                           (self.series[idx], why))
                 else:
                     write(_('skipping %s - no matching guards\n') %
                           self.series[idx])
 
     def save_dirty(self):
         def write_list(items, path):
             fp = self.opener(path, 'w')
             for i in items:
                 fp.write("%s\n" % i)
             fp.close()
         if self.applied_dirty: write_list(map(str, self.applied), self.status_path)
         if self.series_dirty: write_list(self.full_series, self.series_path)
         if self.guards_dirty: write_list(self.active_guards, self.guards_path)
 
     def readheaders(self, patch):
         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:
                 l = lines[-1]
                 if re.match('\s*$', l):
                     del lines[-1]
                 else:
                     break
 
         pf = self.join(patch)
         message = []
         comments = []
         user = None
         date = None
         format = None
         subject = None
         diffstart = 0
 
         for line in file(pf):
             line = line.rstrip()
             if line.startswith('diff --git'):
                 diffstart = 2
                 break
             if diffstart:
                 if line.startswith('+++ '):
                     diffstart = 2
                 break
             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 not line.startswith("# ") and line:
                     message.append(line)
                     format = None
             elif line == '# HG changeset patch':
                 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 == "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)
         eatempty(message)
         eatempty(comments)
 
         # make sure message isn't empty
         if format and format.startswith("tag") and subject:
             message.insert(0, "")
             message.insert(0, subject)
         return patchheader(message, comments, user, date, diffstart > 1)
 
     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 printdiff(self, repo, node1, node2=None, files=None,
                   fp=None, changes=None, opts={}):
         m = cmdutil.match(repo, files, opts)
         chunks = patch.diff(repo, node1, node2, m, changes, self.diffopts())
         write = fp is None and repo.ui.write or fp.write
         for chunk in chunks:
             write(chunk)
 
     def mergeone(self, repo, mergeq, head, patch, rev):
         # 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)
         self.strip(repo, n, update=False, backup='strip')
 
         ctx = repo[rev]
         ret = hg.merge(repo, rev)
         if ret:
             raise util.Abort(_("update returned %d") % ret)
         n = repo.commit(None, ctx.description(), ctx.user(), force=1)
         if n == None:
             raise util.Abort(_("repo commit failed"))
         try:
             ph = mergeq.readheaders(patch)
         except:
             raise util.Abort(_("unable to read %s") % patch)
 
         patchf = self.opener(patch, "w")
         comments = str(ph)
         if comments:
             patchf.write(comments)
         self.printdiff(repo, head, n, fp=patchf)
         patchf.close()
         self.removeundo(repo)
         return (0, n)
 
     def qparents(self, repo, rev=None):
         if rev is None:
             (p1, p2) = repo.dirstate.parents()
             if p2 == nullid:
                 return p1
             if len(self.applied) == 0:
                 return None
             return bin(self.applied[-1].rev)
         pp = repo.changelog.parents(rev)
         if pp[1] != nullid:
             arevs = [ x.rev for x in self.applied ]
             p0 = hex(pp[0])
             p1 = hex(pp[1])
             if p0 in arevs:
                 return pp[0]
             if p1 in arevs:
                 return pp[1]
         return pp[0]
 
     def mergepatch(self, repo, mergeq, series):
         if len(self.applied) == 0:
             # 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 = repo.commit(None, '[mq]: merge marker', user=None, force=1)
             self.removeundo(repo)
             self.applied.append(statusentry(hex(n), pname))
             self.applied_dirty = 1
 
         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.explain_pushable(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 = bin(info[1])
             (err, head) = self.mergeone(repo, mergeq, head, patch, rev)
             if head:
                 self.applied.append(statusentry(hex(head), patch))
                 self.applied_dirty = 1
             if err:
                 return (err, head)
         self.save_dirty()
         return (0, head)
 
     def patch(self, repo, patchfile):
         '''Apply patchfile  to the working directory.
         patchfile: file name of patch'''
         files = {}
         try:
             fuzz = patch.patch(patchfile, self.ui, strip=1, cwd=repo.root,
                                files=files)
         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"))
             return (False, files, False)
 
         return (True, files, fuzz)
 
     def apply(self, repo, series, list=False, update_status=True,
               strict=False, patchdir=None, merge=None, all_files={}):
         wlock = lock = tr = None
         try:
             wlock = repo.wlock()
             lock = repo.lock()
             tr = repo.transaction()
             try:
                 ret = self._apply(repo, series, list, update_status,
                                   strict, patchdir, merge, all_files=all_files)
                 tr.close()
                 self.save_dirty()
                 return ret
             except:
                 try:
                     tr.abort()
                 finally:
                     repo.invalidate()
                     repo.dirstate.invalidate()
                 raise
         finally:
             del tr
             release(lock, wlock)
             self.removeundo(repo)
 
     def _apply(self, repo, series, list=False, update_status=True,
                strict=False, patchdir=None, merge=None, all_files={}):
         # 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.explain_pushable(patchname, all_patches=True)
                 continue
             self.ui.warn(_("applying %s\n") % patchname)
             pf = os.path.join(patchdir, patchname)
 
             try:
                 ph = self.readheaders(patchname)
             except:
                 self.ui.warn(_("Unable to read %s\n") % patchname)
                 err = 1
                 break
 
             message = ph.message
             if not message:
                 message = _("imported patch %s\n") % patchname
             else:
                 if list:
                     message.append(_("\nimported patch %s") % patchname)
                 message = '\n'.join(message)
 
             if ph.haspatch:
                 (patcherr, files, fuzz) = self.patch(repo, pf)
                 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.exists(repo.wjoin(f)):
                         merged.append(f)
                     else:
                         removed.append(f)
                 for f in removed:
                     repo.dirstate.remove(f)
                 for f in merged:
                     repo.dirstate.merge(f)
                 p1, p2 = repo.dirstate.parents()
                 repo.dirstate.setparents(p1, merge)
 
             files = patch.updatedir(self.ui, repo, files)
             match = cmdutil.matchfiles(repo, files or [])
             n = repo.commit(files, message, ph.user, ph.date, match=match,
                             force=True)
 
             if n == None:
                 raise util.Abort(_("repo commit failed"))
 
             if update_status:
                 self.applied.append(statusentry(hex(n), patchname))
 
             if patcherr:
                 self.ui.warn(_("patch failed, rejects left in working dir\n"))
                 err = 1
                 break
 
             if fuzz and strict:
                 self.ui.warn(_("fuzz found when applying patch, stopping\n"))
                 err = 1
                 break
         return (err, n)
 
     def _clean_series(self, patches):
-        indices = util.sort([self.find_series(p) for p in patches])
-        for i in indices[-1::-1]:
+        for i in sorted([self.find_series(p) for p in patches], reverse=True):
             del self.full_series[i]
         self.parse_series()
         self.series_dirty = 1
 
     def finish(self, repo, revs):
-        revs.sort()
         firstrev = repo[self.applied[0].rev].rev()
         appliedbase = 0
         patches = []
-        for rev in util.sort(revs):
+        for rev in sorted(revs):
             if rev < firstrev:
                 raise util.Abort(_('revision %d is not managed') % rev)
             base = bin(self.applied[appliedbase].rev)
             node = repo.changelog.node(rev)
             if node != base:
                 raise util.Abort(_('cannot delete revision %d above '
                                    'applied patches') % rev)
             patches.append(self.applied[appliedbase].name)
             appliedbase += 1
 
         r = self.qrepo()
         if r:
             r.remove(patches, True)
         else:
             for p in patches:
                 os.unlink(self.join(p))
 
         del self.applied[:appliedbase]
         self.applied_dirty = 1
         self._clean_series(patches)
 
     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)
             realpatches.append(patch)
 
         appliedbase = 0
         if opts.get('rev'):
             if not self.applied:
                 raise util.Abort(_('no patches applied'))
             revs = cmdutil.revrange(repo, opts['rev'])
             if len(revs) > 1 and revs[0] > revs[1]:
                 revs.reverse()
             for rev in revs:
                 if appliedbase >= len(self.applied):
                     raise util.Abort(_("revision %d is not managed") % rev)
 
                 base = bin(self.applied[appliedbase].rev)
                 node = repo.changelog.node(rev)
                 if node != base:
                     raise util.Abort(_("cannot delete revision %d above "
                                        "applied patches") % rev)
                 realpatches.append(self.applied[appliedbase].name)
                 appliedbase += 1
 
         if not opts.get('keep'):
             r = self.qrepo()
             if r:
                 r.remove(realpatches, True)
             else:
                 for p in realpatches:
                     os.unlink(self.join(p))
 
         if appliedbase:
             del self.applied[:appliedbase]
             self.applied_dirty = 1
         self._clean_series(realpatches)
 
     def check_toppatch(self, repo):
         if len(self.applied) > 0:
             top = bin(self.applied[-1].rev)
             pp = repo.dirstate.parents()
             if top not in pp:
                 raise util.Abort(_("working directory revision is not qtip"))
             return top
         return None
     def check_localchanges(self, repo, force=False, refresh=True):
         m, a, r, d = repo.status()[:4]
         if m or a or r or d:
             if not force:
                 if refresh:
                     raise util.Abort(_("local changes found, refresh first"))
                 else:
                     raise util.Abort(_("local changes found"))
         return m, a, r, d
 
     _reserved = ('series', 'status', 'guards')
     def check_reserved_name(self, name):
         if (name in self._reserved or name.startswith('.hg')
             or name.startswith('.mq')):
             raise util.Abort(_('"%s" cannot be used as the name of a patch')
                              % name)
 
     def new(self, repo, patchfn, *pats, **opts):
         """options:
            msg: a string or a no-argument function returning a string
         """
         msg = opts.get('msg')
         force = opts.get('force')
         user = opts.get('user')
         date = opts.get('date')
         if date:
             date = util.parsedate(date)
         self.check_reserved_name(patchfn)
         if os.path.exists(self.join(patchfn)):
             raise util.Abort(_('patch "%s" already exists') % patchfn)
         if opts.get('include') or opts.get('exclude') or pats:
             match = cmdutil.match(repo, pats, opts)
             # detect missing files in pats
             def badfn(f, msg):
                 raise util.Abort('%s: %s' % (f, msg))
             match.bad = badfn
             m, a, r, d = repo.status(match=match)[:4]
         else:
             m, a, r, d = self.check_localchanges(repo, force)
             match = cmdutil.matchfiles(repo, m + a + r)
         commitfiles = m + a + r
         self.check_toppatch(repo)
         insert = self.full_series_end()
         wlock = repo.wlock()
         try:
             # if patch file write fails, abort early
             p = self.opener(patchfn, "w")
             try:
                 if date:
                     p.write("# HG changeset patch\n")
                     if user:
                         p.write("# User " + user + "\n")
                     p.write("# Date %d %d\n\n" % date)
                 elif user:
                     p.write("From: " + user + "\n\n")
 
                 if callable(msg):
                     msg = msg()
                 commitmsg = msg and msg or ("[mq]: %s" % patchfn)
                 n = repo.commit(commitfiles, commitmsg, user, date, match=match, force=True)
                 if n == None:
                     raise util.Abort(_("repo commit failed"))
                 try:
                     self.full_series[insert:insert] = [patchfn]
                     self.applied.append(statusentry(hex(n), patchfn))
                     self.parse_series()
                     self.series_dirty = 1
                     self.applied_dirty = 1
                     if msg:
                         msg = msg + "\n\n"
                         p.write(msg)
                     if commitfiles:
                         diffopts = self.diffopts()
                         if opts.get('git'): diffopts.git = True
                         parent = self.qparents(repo, n)
                         chunks = patch.diff(repo, node1=parent, node2=n,
                                             match=match, opts=diffopts)
                         for chunk in chunks:
                             p.write(chunk)
                     p.close()
                     wlock.release()
                     wlock = None
                     r = self.qrepo()
                     if r: r.add([patchfn])
                 except:
                     repo.rollback()
                     raise
             except Exception:
                 patchpath = self.join(patchfn)
                 try:
                     os.unlink(patchpath)
                 except:
                     self.ui.warn(_('error unlinking %s\n') % patchpath)
                 raise
             self.removeundo(repo)
         finally:
             release(wlock)
 
     def strip(self, repo, rev, update=True, backup="all", force=None):
         wlock = lock = None
         try:
             wlock = repo.wlock()
             lock = repo.lock()
 
             if update:
                 self.check_localchanges(repo, force=force, refresh=False)
                 urev = self.qparents(repo, rev)
                 hg.clean(repo, urev)
                 repo.dirstate.write()
 
             self.removeundo(repo)
             repair.strip(self.ui, repo, rev, backup)
             # strip may have unbundled a set of backed up revisions after
             # the actual strip
             self.removeundo(repo)
         finally:
             release(lock, wlock)
 
     def isapplied(self, patch):
         """returns (index, rev, patch)"""
         for i in xrange(len(self.applied)):
             a = self.applied[i]
             if a.name == patch:
                 return (i, a.rev, 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 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):
         patch = patch and str(patch)
 
         def partial_name(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 len(self.series) > 0 and len(self.applied) > 0:
                 if s == 'qtip':
                     return self.series[self.series_end(True)-1]
                 if s == 'qbase':
                     return self.series[0]
             return None
 
         if patch == None:
             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 = partial_name(patch)
                 if res:
                     return res
                 minus = patch.rfind('-')
                 if minus >= 0:
                     res = partial_name(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 = partial_name(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):
         wlock = repo.wlock()
         if repo.dirstate.parents()[0] != repo.changelog.tip():
             self.ui.status(_("(working directory not at tip)\n"))
 
         if not self.series:
             self.ui.warn(_('no patches in series\n'))
             return 0
 
         try:
             patch = self.lookup(patch)
             # 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:
                 info = self.isapplied(patch)
                 if info:
                     if info[0] < len(self.applied) - 1:
                         raise util.Abort(
                             _("cannot push to a previous patch: %s") % patch)
                     self.ui.warn(
                         _('qpush: %s is already at the top\n') % patch)
                     return
                 pushable, reason = self.pushable(patch)
                 if not pushable:
                     if reason:
                         reason = _('guarded by %r') % 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.series_end()
             if start == len(self.series):
                 self.ui.warn(_('patch series already fully applied\n'))
                 return 1
             if not force:
                 self.check_localchanges(repo)
 
             self.applied_dirty = 1
             if start > 0:
                 self.check_toppatch(repo)
             if not patch:
                 patch = self.series[start]
                 end = start + 1
             else:
                 end = self.series.index(patch, start) + 1
             s = self.series[start:end]
             all_files = {}
             try:
                 if mergeq:
                     ret = self.mergepatch(repo, mergeq, s)
                 else:
                     ret = self.apply(repo, s, list, all_files=all_files)
             except:
                 self.ui.warn(_('cleaning up working directory...'))
                 node = repo.dirstate.parents()[0]
                 hg.revert(repo, node, None)
                 unknown = repo.status(unknown=True)[4]
                 # only remove unknown files that we know we touched or
                 # created while patching
                 for f in unknown:
                     if f in all_files:
                         util.unlink(repo.wjoin(f))
                 self.ui.warn(_('done\n'))
                 raise
             top = self.applied[-1].name
             if ret[0]:
                 self.ui.write(_("errors during apply, please fix and "
                                 "refresh %s\n") % 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):
         def getfile(f, rev, flags):
             t = repo.file(f).read(rev)
             repo.wwrite(f, t, flags)
 
         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 len(self.applied) == 0:
                 # 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 = [ bin(x.rev) 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.hex() for p in repo[None].parents()]
                 needupdate = False
                 for entry in self.applied[start:]:
                     if entry.rev in parents:
                         needupdate = True
                         break
                 update = needupdate
 
             if not force and update:
                 self.check_localchanges(repo)
 
             self.applied_dirty = 1
             end = len(self.applied)
             rev = bin(self.applied[start].rev)
             if update:
                 top = self.check_toppatch(repo)
 
             try:
                 heads = repo.changelog.heads(rev)
             except error.LookupError:
                 node = short(rev)
                 raise util.Abort(_('trying to pop unknown node %s') % node)
 
             if heads != [bin(self.applied[-1].rev)]:
                 raise util.Abort(_("popping would remove a revision not "
                                    "managed by this patch queue"))
 
             # we know there are no local changes, so we can make a simplified
             # form of hg.update.
             if update:
                 qp = self.qparents(repo, rev)
                 changes = repo.changelog.read(qp)
                 mmap = repo.manifest.read(changes[0])
                 m, a, r, d = repo.status(qp, top)[:4]
                 if d:
                     raise util.Abort(_("deletions found between repo revs"))
                 for f in m:
                     getfile(f, mmap[f], mmap.flags(f))
                 for f in r:
                     getfile(f, mmap[f], mmap.flags(f))
                 for f in m + r:
                     repo.dirstate.normal(f)
                 for f in a:
                     try:
                         os.unlink(repo.wjoin(f))
                     except OSError, e:
                         if e.errno != errno.ENOENT:
                             raise
                     try: os.removedirs(os.path.dirname(repo.wjoin(f)))
                     except: pass
                     repo.dirstate.forget(f)
                 repo.dirstate.setparents(qp, nullid)
             del self.applied[start:end]
             self.strip(repo, rev, update=False, backup='strip')
             if len(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 = self.check_toppatch(repo)
         if not top:
             self.ui.write(_("no patches applied\n"))
             return
         qp = self.qparents(repo, top)
         self._diffopts = patch.diffopts(self.ui, opts)
         self.printdiff(repo, qp, files=pats, opts=opts)
 
     def refresh(self, repo, pats=None, **opts):
         if len(self.applied) == 0:
             self.ui.write(_("no patches applied\n"))
             return 1
         msg = opts.get('msg', '').rstrip()
         newuser = opts.get('user')
         newdate = opts.get('date')
         if newdate:
             newdate = '%d %d' % util.parsedate(newdate)
         wlock = repo.wlock()
         try:
             self.check_toppatch(repo)
             (top, patchfn) = (self.applied[-1].rev, self.applied[-1].name)
             top = bin(top)
             if repo.changelog.heads(top) != [top]:
                 raise util.Abort(_("cannot refresh a revision with children"))
             cparents = repo.changelog.parents(top)
             patchparent = self.qparents(repo, top)
             ph = self.readheaders(patchfn)
 
             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'):
                     self.diffopts().git = True
                     break
 
             if msg:
                 ph.setmessage(msg)
             if newuser:
                 ph.setuser(newuser)
             if newdate:
                 ph.setdate(newdate)
 
             # only commit new patch when write is complete
             patchf = self.opener(patchfn, 'w', atomictemp=True)
 
             patchf.seek(0)
             patchf.truncate()
 
             comments = str(ph)
             if comments:
                 patchf.write(comments)
 
             if opts.get('git'):
                 self.diffopts().git = True
             tip = repo.changelog.tip()
             if top == tip:
                 # if the top of our patch queue is also the tip, there is an
                 # optimization here.  We update the dirstate in place and strip
                 # off the tip commit.  Then just commit the current directory
                 # tree.  We can also send repo.commit the list of files
                 # changed to speed up the diff
                 #
                 # in short mode, we only diff the files included in the
                 # patch already plus specified files
                 #
                 # this should really read:
                 #   mm, dd, aa, aa2 = repo.status(tip, patchparent)[:4]
                 # but we do it backwards to take advantage of manifest/chlog
                 # caching against the next repo.status call
                 #
                 mm, aa, dd, aa2 = repo.status(patchparent, tip)[:4]
                 changes = repo.changelog.read(tip)
                 man = repo.manifest.read(changes[0])
                 aaa = aa[:]
                 matchfn = cmdutil.match(repo, pats, opts)
                 if opts.get('short'):
                     # if amending a patch, we start with existing
                     # files plus specified files - unfiltered
                     match = cmdutil.matchfiles(repo, mm + aa + dd + matchfn.files())
                     # filter with inc/exl options
                     matchfn = cmdutil.match(repo, opts=opts)
                 else:
                     match = cmdutil.matchall(repo)
                 m, a, r, d = repo.status(match=match)[:4]
 
                 # we might end up with files that were added between
                 # tip 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.append(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:
                         del dd[dd.index(x)]
                         mm.append(x)
                     else:
                         aa.append(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:
                         del aa[aa.index(x)]
                         forget.append(x)
                         continue
                     elif x in mm:
                         del mm[mm.index(x)]
                     dd.append(x)
 
                 m = list(set(mm))
                 r = list(set(dd))
                 a = list(set(aa))
                 c = [filter(matchfn, l) for l in (m, a, r)]
                 match = cmdutil.matchfiles(repo, set(c[0] + c[1] + c[2]))
                 chunks = patch.diff(repo, patchparent, match=match,
                                     changes=c, opts=self.diffopts())
                 for chunk in chunks:
                     patchf.write(chunk)
 
                 try:
                     if self.diffopts().git:
                         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 tip
                         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.forget(f)
 
                     if not msg:
                         if not ph.message:
                             message = "[mq]: %s\n" % patchfn
                         else:
                             message = "\n".join(ph.message)
                     else:
                         message = msg
 
                     user = ph.user or changes[1]
 
                     # assumes strip can roll itself back if interrupted
                     repo.dirstate.setparents(*cparents)
                     self.applied.pop()
                     self.applied_dirty = 1
                     self.strip(repo, top, update=False,
                                backup='strip')
                 except:
                     repo.dirstate.invalidate()
                     raise
 
                 try:
                     # might be nice to attempt to roll back strip after this
                     patchf.rename()
                     n = repo.commit(match.files(), message, user, ph.date,
                                     match=match, force=1)
                     self.applied.append(statusentry(hex(n), patchfn))
                 except:
                     ctx = repo[cparents[0]]
                     repo.dirstate.rebuild(ctx.node(), ctx.manifest())
                     self.save_dirty()
                     self.ui.warn(_('refresh interrupted while patch was popped! '
                                    '(revert --all, qpush to recover)\n'))
                     raise
             else:
                 self.printdiff(repo, patchparent, fp=patchf)
                 patchf.rename()
                 added = repo.status()[1]
                 for a in added:
                     f = repo.wjoin(a)
                     try:
                         os.unlink(f)
                     except OSError, e:
                         if e.errno != errno.ENOENT:
                             raise
                     try: os.removedirs(os.path.dirname(f))
                     except: pass
                     # forget the file copies in the dirstate
                     # push should readd the files later on
                     repo.dirstate.forget(a)
                 self.pop(repo, force=True)
                 self.push(repo, force=True)
         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.series_end()
         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.explain_pushable(i)
         return unapplied
 
     def qseries(self, repo, missing=None, start=0, length=None, status=None,
                 summary=False):
         def displayname(patchname):
             if summary:
                 ph = self.readheaders(patchname)
                 msg = ph.message
                 msg = msg and ': ' + msg[0] or ': '
             else:
                 msg = ''
             return '%s%s' % (patchname, msg)
 
         applied = set([p.name for p in self.applied])
         if length is None:
             length = len(self.series) - start
         if not missing:
             for i in xrange(start, start+length):
                 patch = self.series[i]
                 if patch in applied:
                     stat = 'A'
                 elif self.pushable(i)[0]:
                     stat = 'U'
                 else:
                     stat = 'G'
                 pfx = ''
                 if self.ui.verbose:
                     pfx = '%d %s ' % (i, stat)
                 elif status and status != stat:
                     continue
                 self.ui.write('%s%s\n' % (pfx, displayname(patch)))
         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.status_path, self.series_path,
                                    self.guards_path)
                         and not fl.startswith('.')):
                         msng_list.append(fl)
-            for x in util.sort(msng_list):
+            for x in sorted(msng_list):
                 pfx = self.ui.verbose and ('D ') or ''
                 self.ui.write("%s%s\n" % (pfx, displayname(x)))
 
     def issaveline(self, l):
         if l.name == '.hg.patches.save.line':
             return True
 
     def qrepo(self, create=False):
         if create or os.path.isdir(self.join(".hg")):
             return hg.repository(self.ui, path=self.path, create=create)
 
     def restore(self, repo, rev, delete=None, qupdate=None):
         c = repo.changelog.read(rev)
         desc = c[4].strip()
         lines = desc.splitlines()
         i = 0
         datastart = None
         series = []
         applied = []
         qpp = None
         for i in xrange(0, len(lines)):
             if lines[i] == 'Patch Data:':
                 datastart = i + 1
             elif lines[i].startswith('Dirstate:'):
                 l = lines[i].rstrip()
                 l = l[10:].split(' ')
                 qpp = [ bin(x) for x in l ]
             elif datastart != None:
                 l = lines[i].rstrip()
                 se = statusentry(l)
                 file_ = se.name
                 if se.rev:
                     applied.append(se)
                 else:
                     series.append(file_)
         if datastart == None:
             self.ui.warn(_("No saved patch data found\n"))
             return 1
         self.ui.warn(_("restoring status: %s\n") % lines[0])
         self.full_series = series
         self.applied = applied
         self.parse_series()
         self.series_dirty = 1
         self.applied_dirty = 1
         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
                 self.strip(repo, rev, update=update, backup='strip')
         if qpp:
             self.ui.warn(_("saved queue repository parents: %s %s\n") %
                          (short(qpp[0]), short(qpp[1])))
             if qupdate:
                 self.ui.status(_("queue directory updating\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 len(self.applied) == 0:
             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
 
         ar = [ ':' + x for x in self.full_series ]
         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"
         text = msg + "\n".join([str(x) for x in self.applied]) + '\n' + (ar and
                    "\n".join(ar) + '\n' or "")
         n = repo.commit(None, text, user=None, force=1)
         if not n:
             self.ui.warn(_("repo commit failed\n"))
             return 1
         self.applied.append(statusentry(hex(n),'.hg.patches.save.line'))
         self.applied_dirty = 1
         self.removeundo(repo)
 
     def full_series_end(self):
         if len(self.applied) > 0:
             p = self.applied[-1].name
             end = self.find_series(p)
             if end == None:
                 return len(self.full_series)
             return end + 1
         return 0
 
     def series_end(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 next(start):
             if all_patches:
                 return start
             i = start
             while i < len(self.series):
                 p, reason = self.pushable(i)
                 if p:
                     break
                 self.explain_pushable(i)
                 i += 1
             return i
         if len(self.applied) > 0:
             p = self.applied[-1].name
             try:
                 end = self.series.index(p)
             except ValueError:
                 return 0
             return next(end + 1)
         return next(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)
         def checkfile(patchname):
             if not force and os.path.exists(self.join(patchname)):
                 raise util.Abort(_('patch "%s" already exists')
                                  % patchname)
 
         if rev:
             if files:
                 raise util.Abort(_('option "-r" not valid when importing '
                                    'files'))
             rev = cmdutil.revrange(repo, rev)
             rev.sort(lambda x, y: cmp(y, x))
         if (len(files) > 1 or len(rev) > 1) and patchname:
             raise util.Abort(_('option "-n" not valid when importing multiple '
                                'patches'))
         i = 0
         added = []
         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[-1]))
             if len(heads) > 1:
                 raise util.Abort(_('revision %d is the root of more than one '
                                    'branch') % rev[-1])
             if self.applied:
                 base = hex(repo.changelog.node(rev[0]))
                 if base in [n.rev for n in self.applied]:
                     raise util.Abort(_('revision %d is already managed')
                                      % rev[0])
                 if heads != [bin(self.applied[-1].rev)]:
                     raise util.Abort(_('revision %d is not the parent of '
                                        'the queue') % rev[0])
                 base = repo.changelog.rev(bin(self.applied[0].rev))
                 lastparent = repo.changelog.parentrevs(base)[0]
             else:
                 if heads != [repo.changelog.node(rev[0])]:
                     raise util.Abort(_('revision %d has unmanaged children')
                                      % rev[0])
                 lastparent = None
 
             if git:
                 self.diffopts().git = True
 
             for r in rev:
                 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)
                 self.check_reserved_name(patchname)
                 checkseries(patchname)
                 checkfile(patchname)
                 self.full_series.insert(0, patchname)
 
                 patchf = self.opener(patchname, "w")
                 patch.export(repo, [n], fp=patchf, opts=self.diffopts())
                 patchf.close()
 
                 se = statusentry(hex(n), patchname)
                 self.applied.insert(0, se)
 
                 added.append(patchname)
                 patchname = None
             self.parse_series()
             self.applied_dirty = 1
 
         for filename in files:
             if existing:
                 if filename == '-':
                     raise util.Abort(_('-e is incompatible with import from -'))
                 if not patchname:
                     patchname = normname(filename)
                 self.check_reserved_name(patchname)
                 if not os.path.isfile(self.join(patchname)):
                     raise util.Abort(_("patch %s does not exist") % patchname)
             else:
                 try:
                     if filename == '-':
                         if not patchname:
                             raise util.Abort(_('need --name to import a patch from -'))
                         text = sys.stdin.read()
                     else:
                         text = url.open(self.ui, filename).read()
                 except (OSError, IOError):
                     raise util.Abort(_("unable to read %s") % filename)
                 if not patchname:
                     patchname = normname(os.path.basename(filename))
                 self.check_reserved_name(patchname)
                 checkfile(patchname)
                 patchf = self.opener(patchname, "w")
                 patchf.write(text)
             if not force:
                 checkseries(patchname)
             if patchname not in self.series:
                 index = self.full_series_end() + i
                 self.full_series[index:index] = [patchname]
             self.parse_series()
             self.ui.warn(_("adding %s to series file\n") % patchname)
             i += 1
             added.append(patchname)
             patchname = None
         self.series_dirty = 1
         qrepo = self.qrepo()
         if qrepo:
             qrepo.add(added)
 
 def delete(ui, repo, *patches, **opts):
     """remove patches from queue
 
     The patches must not be applied, unless they are arguments to the
     -r/--rev parameter. At least one patch or revision is required.
 
     With --rev, mq will stop managing the named revisions (converting
     them to regular mercurial changesets). The qfinish command should
     be used as an alternative for qdelete -r, as the latter option is
     deprecated.
 
     With -k/--keep, the patch files are preserved in the patch
     directory."""
     q = repo.mq
     q.delete(repo, patches, opts)
     q.save_dirty()
     return 0
 
 def applied(ui, repo, patch=None, **opts):
     """print the patches already applied"""
     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.series_end(True)
     return q.qseries(repo, length=end, status='A', summary=opts.get('summary'))
 
 def unapplied(ui, repo, patch=None, **opts):
     """print the patches not yet applied"""
     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.series_end(True)
     q.qseries(repo, start=start, status='U', summary=opts.get('summary'))
 
 def qimport(ui, repo, *filename, **opts):
     """import a patch
 
     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 tip -n patch will place tip 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.
 
     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.
     """
     q = repo.mq
     q.qimport(repo, filename, patchname=opts['name'],
               existing=opts['existing'], force=opts['force'], rev=opts['rev'],
               git=opts['git'])
     q.save_dirty()
     return 0
 
 def init(ui, repo, **opts):
     """init a new queue repository
 
     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."""
     q = repo.mq
     r = q.init(repo, create=opts['create_repo'])
     q.save_dirty()
     if r:
         if not os.path.exists(r.wjoin('.hgignore')):
             fp = r.wopener('.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.wopener('series', 'w').close()
         r.add(['.hgignore', 'series'])
         commands.add(ui, r)
     return 0
 
 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 qinit -c.
     '''
     def patchdir(repo):
         url = repo.url()
         if url.endswith('/'):
             url = url[:-1]
         return url + '/.hg/patches'
     if dest is None:
         dest = hg.defaultdest(source)
     sr = hg.repository(cmdutil.remoteui(ui, opts), ui.expandpath(source))
     if opts['patches']:
         patchespath = ui.expandpath(opts['patches'])
     else:
         patchespath = patchdir(sr)
     try:
         hg.repository(ui, patchespath)
     except error.RepoError:
         raise util.Abort(_('versioned patch repository not found'
                            ' (see qinit -c)'))
     qbase, destrev = None, None
     if sr.local():
         if sr.mq.applied:
             qbase = bin(sr.mq.applied[0].rev)
             if not hg.islocal(dest):
                 heads = set(sr.heads())
                 destrev = list(heads.difference(sr.heads(qbase)))
                 destrev.append(sr.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, sr.url(), dest,
                       pull=opts['pull'],
                       rev=destrev,
                       update=False,
                       stream=opts['uncompressed'])
     ui.note(_('cloning patch repository\n'))
     hg.clone(ui, opts['patches'] or patchdir(sr), patchdir(dr),
              pull=opts['pull'], update=not opts['noupdate'],
              stream=opts['uncompressed'])
     if dr.local():
         if qbase:
             ui.note(_('stripping applied patches from destination '
                       'repository\n'))
             dr.mq.strip(dr, qbase, update=False, backup=None)
         if not opts['noupdate']:
             ui.note(_('updating destination repository\n'))
             hg.update(dr, dr.changelog.tip())
 
 def commit(ui, repo, *pats, **opts):
     """commit changes in the queue repository"""
     q = repo.mq
     r = q.qrepo()
     if not r: raise util.Abort('no queue repository')
     commands.commit(r.ui, r, *pats, **opts)
 
 def series(ui, repo, **opts):
     """print the entire series file"""
     repo.mq.qseries(repo, missing=opts['missing'], summary=opts['summary'])
     return 0
 
 def top(ui, repo, **opts):
     """print the name of the current patch"""
     q = repo.mq
     t = q.applied and q.series_end(True) or 0
     if t:
         return q.qseries(repo, start=t-1, length=1, status='A',
                          summary=opts.get('summary'))
     else:
         ui.write(_("no patches applied\n"))
         return 1
 
 def next(ui, repo, **opts):
     """print the name of the next patch"""
     q = repo.mq
     end = q.series_end()
     if end == len(q.series):
         ui.write(_("all patches applied\n"))
         return 1
     return q.qseries(repo, start=end, length=1, summary=opts.get('summary'))
 
 def prev(ui, repo, **opts):
     """print the name of the previous patch"""
     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
     return q.qseries(repo, start=l-2, length=1, status='A',
                      summary=opts.get('summary'))
 
 def setupheaderopts(ui, opts):
     def do(opt,val):
         if not opts[opt] and opts['current' + opt]:
             opts[opt] = val
     do('user', ui.username())
     do('date', "%d %d" % util.makedate())
 
 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). It will refuse to run if there are any outstanding changes
     unless -f/--force is specified, in which case the patch will be
     initialized with them. 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.
     """
     msg = cmdutil.logmessage(opts)
     def getmsg(): return ui.edit(msg, ui.username())
     q = repo.mq
     opts['msg'] = msg
     if opts.get('edit'):
         opts['msg'] = getmsg
     else:
         opts['msg'] = msg
     setupheaderopts(ui, opts)
     q.new(repo, patch, *args, **opts)
     q.save_dirty()
     return 0
 
 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.
 
     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.
     """
     q = repo.mq
     message = cmdutil.logmessage(opts)
     if opts['edit']:
         if not q.applied:
             ui.write(_("no patches applied\n"))
             return 1
         if message:
             raise util.Abort(_('option "-e" incompatible with "-m" or "-l"'))
         patch = q.applied[-1].name
         ph = q.readheaders(patch)
         message = ui.edit('\n'.join(ph.message), ph.user or ui.username())
     setupheaderopts(ui, opts)
     ret = q.refresh(repo, pats, msg=message, **opts)
     q.save_dirty()
     return ret
 
 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.
     """
     repo.mq.diff(repo, pats, opts)
     return 0
 
 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 '* * *'."""
 
     q = repo.mq
 
     if not files:
         raise util.Abort(_('qfold requires at least one patch name'))
     if not q.check_toppatch(repo):
         raise util.Abort(_('No patches applied'))
 
     message = cmdutil.logmessage(opts)
     if opts['edit']:
         if message:
             raise util.Abort(_('option "-e" incompatible with "-m" or "-l"'))
 
     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') % 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 = q.readheaders(p)
             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)
         patch.updatedir(ui, repo, files)
 
     if not message:
         ph = q.readheaders(parent)
         message, user = ph.message, ph.user
         for msg in messages:
             message.append('* * *')
             message.extend(msg)
         message = '\n'.join(message)
 
     if opts['edit']:
         message = ui.edit(message, user or ui.username())
 
     q.refresh(repo, msg=message)
     q.delete(repo, patches, opts)
     q.save_dirty()
 
 def goto(ui, repo, patch, **opts):
     '''push or pop patches until named patch is at top of stack'''
     q = repo.mq
     patch = q.lookup(patch)
     if q.isapplied(patch):
         ret = q.pop(repo, patch, force=opts['force'])
     else:
         ret = q.push(repo, patch, force=opts['force'])
     q.save_dirty()
     return ret
 
 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 qselect command has activated it. A patch with
     a negative guard ("-foo") is never pushed if the 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
     '''
     def status(idx):
         guards = q.series_guards[idx] or ['unguarded']
         ui.write('%s: %s\n' % (q.series[idx], ' '.join(guards)))
     q = repo.mq
     patch = None
     args = list(args)
     if opts['list']:
         if args or opts['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['none']:
         idx = q.find_series(patch)
         if idx is None:
             raise util.Abort(_('no patch named %s') % patch)
         q.set_guards(idx, args)
         q.save_dirty()
     else:
         status(q.series.index(q.lookup(patch)))
 
 def header(ui, repo, patch=None):
     """print the header of the topmost or specified patch"""
     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 = repo.mq.readheaders(patch)
 
     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 == 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
 
 def push(ui, repo, patch=None, **opts):
     """push the next patch onto the stack
 
     When -f/--force is applied, all local changes in patched files
     will be lost.
     """
     q = repo.mq
     mergeq = None
 
     if opts['merge']:
         if opts['name']:
             newpath = repo.join(opts['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.join(""), newpath)
         ui.warn(_("merging with queue at: %s\n") % mergeq.path)
     ret = q.push(repo, patch, force=opts['force'], list=opts['list'],
                  mergeq=mergeq, all=opts.get('all'))
     return ret
 
 def pop(ui, repo, patch=None, **opts):
     """pop the current patch off the stack
 
     By default, 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.
     """
     localupdate = True
     if opts['name']:
         q = queue(ui, repo.join(""), repo.join(opts['name']))
         ui.warn(_('using patch queue: %s\n') % q.path)
         localupdate = False
     else:
         q = repo.mq
     ret = q.pop(repo, patch, force=opts['force'], update=localupdate,
                 all=opts['all'])
     q.save_dirty()
     return ret
 
 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."""
 
     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)
     if os.path.exists(absdest):
         raise util.Abort(_('%s already exists') % absdest)
 
     if name in q.series:
         raise util.Abort(_('A patch named %s already exists in the series file') % name)
 
     if ui.verbose:
         ui.write('renaming %s to %s\n' % (patch, name))
     i = q.find_series(patch)
     guards = q.guard_re.findall(q.full_series[i])
     q.full_series[i] = name + ''.join([' #' + g for g in guards])
     q.parse_series()
     q.series_dirty = 1
 
     info = q.isapplied(patch)
     if info:
         q.applied[info[0]] = statusentry(info[1], name)
     q.applied_dirty = 1
 
     util.rename(q.join(patch), absdest)
     r = q.qrepo()
     if r:
         wlock = r.wlock()
         try:
             if r.dirstate[patch] == 'a':
                 r.dirstate.forget(patch)
                 r.dirstate.add(name)
             else:
                 if r.dirstate[name] == 'r':
                     r.undelete([name])
                 r.copy(patch, name)
                 r.remove([patch], False)
         finally:
             wlock.release()
 
     q.save_dirty()
 
 def restore(ui, repo, rev, **opts):
     """restore the queue state saved by a revision"""
     rev = repo.lookup(rev)
     q = repo.mq
     q.restore(repo, rev, delete=opts['delete'],
               qupdate=opts['update'])
     q.save_dirty()
     return 0
 
 def save(ui, repo, **opts):
     """save current queue state"""
     q = repo.mq
     message = cmdutil.logmessage(opts)
     ret = q.save(repo, msg=message)
     if ret:
         return ret
     q.save_dirty()
     if opts['copy']:
         path = q.path
         if opts['name']:
             newpath = os.path.join(q.basepath, opts['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['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['empty']:
         try:
             os.unlink(q.join(q.status_path))
         except:
             pass
     return 0
 
 def strip(ui, repo, rev, **opts):
     """strip a revision and all its descendants from the repository
 
     If one of the working directory's parent revisions is stripped, the
     working directory will be updated to the parent of the stripped
     revision.
     """
     backup = 'all'
     if opts['backup']:
         backup = 'strip'
     elif opts['nobackup']:
         backup = 'none'
 
     rev = repo.lookup(rev)
     p = repo.dirstate.parents()
     cl = repo.changelog
     update = True
     if p[0] == nullid:
         update = False
     elif p[1] == nullid and rev != cl.ancestor(p[0], rev):
         update = False
     elif rev not in (cl.ancestor(p[0], rev), cl.ancestor(p[1], rev)):
         update = False
 
     repo.mq.strip(repo, rev, backup=backup, update=update, force=opts['force'])
     return 0
 
 def select(ui, repo, *args, **opts):
     '''set or print guarded patches to push
 
     Use the 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.'''
 
     q = repo.mq
     guards = q.active()
     if args or opts['none']:
         old_unapplied = q.unapplied(repo)
         old_guarded = [i for i in xrange(len(q.applied)) if
                        not q.pushable(i)[0]]
         q.set_active(args)
         q.save_dirty()
         if not args:
             ui.status(_('guards deactivated\n'))
         if not opts['pop'] and not opts['reapply']:
             unapplied = q.unapplied(repo)
             guarded = [i for i in xrange(len(q.applied))
                        if not q.pushable(i)[0]]
             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['series']:
         guards = {}
         noguards = 0
         for gs in q.series_guards:
             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(lambda a, b: cmp(a[0][1:], b[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['reapply'] and q.applied and q.appliedname(-1)
     popped = False
     if opts['pop'] or opts['reapply']:
         for i in xrange(len(q.applied)):
             pushable, reason = q.pushable(i)
             if not pushable:
                 ui.status(_('popping guarded patches\n'))
                 popped = True
                 if i == 0:
                     q.pop(repo, all=True)
                 else:
                     q.pop(repo, i-1)
                 break
     if popped:
         try:
             if reapply:
                 ui.status(_('reapplying unguarded patches\n'))
                 q.push(repo, reapply)
         finally:
             q.save_dirty()
 
 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.
     """
     if not opts['applied'] and not revrange:
         raise util.Abort(_('no revisions specified'))
     elif opts['applied']:
         revrange = ('qbase:qtip',) + revrange
 
     q = repo.mq
     if not q.applied:
         ui.status(_('no patches applied\n'))
         return 0
 
     revs = cmdutil.revrange(repo, revrange)
     q.finish(repo, revs)
     q.save_dirty()
     return 0
 
 def reposetup(ui, repo):
     class mqrepo(repo.__class__):
         def abort_if_wdir_patched(self, errmsg, force=False):
             if self.mq.applied and not force:
                 parent = hex(self.dirstate.parents()[0])
                 if parent in [s.rev for s in self.mq.applied]:
                     raise util.Abort(errmsg)
 
         def commit(self, *args, **opts):
             if len(args) >= 6:
                 force = args[5]
             else:
                 force = opts.get('force')
             self.abort_if_wdir_patched(
                 _('cannot commit over an applied mq patch'),
                 force)
 
             return super(mqrepo, self).commit(*args, **opts)
 
         def push(self, remote, force=False, revs=None):
             if self.mq.applied and not force and not revs:
                 raise util.Abort(_('source has mq patches applied'))
             return super(mqrepo, self).push(remote, force, revs)
 
         def tags(self):
             if self.tagscache:
                 return self.tagscache
 
             tagscache = super(mqrepo, self).tags()
 
             q = self.mq
             if not q.applied:
                 return tagscache
 
             mqtags = [(bin(patch.rev), patch.name) for patch in q.applied]
 
             if mqtags[-1][0] not in self.changelog.nodemap:
                 self.ui.warn(_('mq status file refers to unknown node %s\n')
                              % short(mqtags[-1][0]))
                 return tagscache
 
             mqtags.append((mqtags[-1][0], 'qtip'))
             mqtags.append((mqtags[0][0], 'qbase'))
             mqtags.append((self.changelog.parents(mqtags[0][0])[0], 'qparent'))
             for patch in mqtags:
                 if patch[1] in tagscache:
                     self.ui.warn(_('Tag %s overrides mq patch of the same name\n')
                                  % patch[1])
                 else:
                     tagscache[patch[1]] = patch[0]
 
             return tagscache
 
         def _branchtags(self, partial, lrev):
             q = self.mq
             if not q.applied:
                 return super(mqrepo, self)._branchtags(partial, lrev)
 
             cl = self.changelog
             qbasenode = bin(q.applied[0].rev)
             if qbasenode not in cl.nodemap:
                 self.ui.warn(_('mq status file refers to unknown node %s\n')
                              % short(qbasenode))
                 return super(mqrepo, self)._branchtags(partial, lrev)
 
             qbase = cl.rev(qbasenode)
             start = lrev + 1
             if start < qbase:
                 # update the cache (excluding the patches) and save it
                 self._updatebranchcache(partial, lrev+1, qbase)
                 self._writebranchcache(partial, cl.node(qbase-1), qbase-1)
                 start = qbase
             # if start = qbase, the cache is as updated as it should be.
             # if start > qbase, the cache includes (part of) the patches.
             # we might as well use it, but we won't save it.
 
             # update the cache up to the tip
             self._updatebranchcache(partial, start, len(cl))
 
             return partial
 
     if repo.local():
         repo.__class__ = mqrepo
         repo.mq = queue(ui, repo.join(""))
 
 def mqimport(orig, ui, repo, *args, **kwargs):
     if hasattr(repo, 'abort_if_wdir_patched'):
         repo.abort_if_wdir_patched(_('cannot import over an applied patch'),
                                    kwargs.get('force'))
     return orig(ui, repo, *args, **kwargs)
 
 def uisetup(ui):
     extensions.wrapcommand(commands.table, 'import', mqimport)
 
 seriesopts = [('s', 'summary', None, _('print first line of patch header'))]
 
 cmdtable = {
     "qapplied": (applied, [] + seriesopts, _('hg qapplied [-s] [PATCH]')),
     "qclone":
         (clone,
          [('', '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')),
          ] + commands.remoteopts,
          _('hg qclone [OPTION]... SOURCE [DEST]')),
     "qcommit|qci":
         (commit,
          commands.table["^commit|ci"][1],
          _('hg qcommit [OPTION]... [FILE]...')),
     "^qdiff":
         (diff,
          commands.diffopts + commands.diffopts2 + commands.walkopts,
          _('hg qdiff [OPTION]... [FILE]...')),
     "qdelete|qremove|qrm":
         (delete,
          [('k', 'keep', None, _('keep patch file')),
           ('r', 'rev', [], _('stop managing a revision'))],
          _('hg qdelete [-k] [-r REV]... [PATCH]...')),
     'qfold':
         (fold,
          [('e', 'edit', None, _('edit patch header')),
           ('k', 'keep', None, _('keep folded patch files')),
          ] + commands.commitopts,
          _('hg qfold [-e] [-k] [-m TEXT] [-l FILE] PATCH...')),
     'qgoto':
         (goto,
          [('f', 'force', None, _('overwrite any local changes'))],
          _('hg qgoto [OPTION]... PATCH')),
     'qguard':
         (guard,
          [('l', 'list', None, _('list all patches and guards')),
           ('n', 'none', None, _('drop all guards'))],
          _('hg qguard [-l] [-n] -- [PATCH] [+GUARD]... [-GUARD]...')),
     'qheader': (header, [], _('hg qheader [PATCH]')),
     "^qimport":
         (qimport,
          [('e', 'existing', None, _('import file in patch directory')),
           ('n', 'name', '', _('patch file name')),
           ('f', 'force', None, _('overwrite existing files')),
           ('r', 'rev', [], _('place existing revisions under mq control')),
           ('g', 'git', None, _('use git extended diff format'))],
          _('hg qimport [-e] [-n NAME] [-f] [-g] [-r REV]... FILE...')),
     "^qinit":
         (init,
          [('c', 'create-repo', None, _('create queue repository'))],
          _('hg qinit [-c]')),
     "qnew":
         (new,
          [('e', 'edit', None, _('edit commit message')),
           ('f', 'force', None, _('import uncommitted changes into patch')),
           ('g', 'git', None, _('use git extended diff format')),
           ('U', 'currentuser', None, _('add "From: <current user>" to patch')),
           ('u', 'user', '', _('add "From: <given user>" to patch')),
           ('D', 'currentdate', None, _('add "Date: <current date>" to patch')),
           ('d', 'date', '', _('add "Date: <given date>" to patch'))
           ] + commands.walkopts + commands.commitopts,
          _('hg qnew [-e] [-m TEXT] [-l FILE] [-f] PATCH [FILE]...')),
     "qnext": (next, [] + seriesopts, _('hg qnext [-s]')),
     "qprev": (prev, [] + seriesopts, _('hg qprev [-s]')),
     "^qpop":
         (pop,
          [('a', 'all', None, _('pop all patches')),
           ('n', 'name', '', _('queue name to pop')),
           ('f', 'force', None, _('forget any local changes'))],
          _('hg qpop [-a] [-n NAME] [-f] [PATCH | INDEX]')),
     "^qpush":
         (push,
          [('f', 'force', None, _('apply if the patch has rejects')),
           ('l', 'list', None, _('list patch name in commit text')),
           ('a', 'all', None, _('apply all patches')),
           ('m', 'merge', None, _('merge from another queue')),
           ('n', 'name', '', _('merge queue name'))],
          _('hg qpush [-f] [-l] [-a] [-m] [-n NAME] [PATCH | INDEX]')),
     "^qrefresh":
         (refresh,
          [('e', 'edit', None, _('edit commit message')),
           ('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 "From: <current user>" in patch')),
           ('u', 'user', '', _('add/update "From: <given user>" in patch')),
           ('D', 'currentdate', None, _('update "Date: <current date>" in patch (if present)')),
           ('d', 'date', '', _('update "Date: <given date>" in patch (if present)'))
           ] + commands.walkopts + commands.commitopts,
          _('hg qrefresh [-I] [-X] [-e] [-m TEXT] [-l FILE] [-s] [FILE]...')),
     'qrename|qmv':
         (rename, [], _('hg qrename PATCH1 [PATCH2]')),
     "qrestore":
         (restore,
          [('d', 'delete', None, _('delete save entry')),
           ('u', 'update', None, _('update queue working directory'))],
          _('hg qrestore [-d] [-u] REV')),
     "qsave":
         (save,
          [('c', 'copy', None, _('copy patch directory')),
           ('n', 'name', '', _('copy directory 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]')),
     "qselect":
         (select,
          [('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]...')),
     "qseries":
         (series,
          [('m', 'missing', None, _('print patches not in series')),
          ] + seriesopts,
          _('hg qseries [-ms]')),
     "^strip":
         (strip,
          [('f', 'force', None, _('force removal with local changes')),
           ('b', 'backup', None, _('bundle unrelated changesets')),
           ('n', 'nobackup', None, _('no backups'))],
          _('hg strip [-f] [-b] [-n] REV')),
     "qtop": (top, [] + seriesopts, _('hg qtop [-s]')),
     "qunapplied": (unapplied, [] + seriesopts, _('hg qunapplied [-s] [PATCH]')),
     "qfinish":
         (finish,
          [('a', 'applied', None, _('finish all applied changesets'))],
          _('hg qfinish [-a] [REV...]')),
 }

hgext/purge.py

@@ -1,110 +1,110 b''
 # Copyright (C) 2006 - Marco Barisione <[e-mail]>
 #
 # This is a small extension for Mercurial (http://www.selenic.com/mercurial)
 # 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/).
 #
 # To enable the "purge" extension put these lines in your ~/.hgrc:
 #  [extensions]
 #  hgext.purge =
 #
 # 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, write to the Free Software
 # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
 from mercurial import util, commands, cmdutil
 from mercurial.i18n import _
 import os, stat
 
 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:
      - Unknown files: files marked with "?" by "hg status"
      - Empty directories: in fact Mercurial ignores directories unless
        they contain files under source control managment
     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")
 
     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
 
     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))
 
     def removefile(path):
         try:
             os.remove(path)
         except OSError:
             # read-only files cannot be unlinked under Windows
             s = os.stat(path)
             if (s.st_mode & stat.S_IWRITE) != 0:
                 raise
             os.chmod(path, stat.S_IMODE(s.st_mode) | stat.S_IWRITE)
             os.remove(path)
 
     directories = []
     match = cmdutil.match(repo, dirs, opts)
     match.dir = directories.append
     status = repo.status(match=match, ignored=opts['all'], unknown=True)
 
-    for f in util.sort(status[4] + status[5]):
+    for f in sorted(status[4] + status[5]):
         ui.note(_('Removing file %s\n') % f)
         remove(removefile, f)
 
-    for f in util.sort(directories)[::-1]:
+    for f in sorted(directories, reverse=True):
         if match(f) and not os.listdir(repo.wjoin(f)):
             ui.note(_('Removing directory %s\n') % f)
             remove(os.rmdir, f)
 
 cmdtable = {
     'purge|clean':
         (purge,
          [('a', 'abort-on-err', None, _('abort if an error occurs')),
           ('',  'all', None, _('purge ignored files too')),
           ('p', 'print', None, _('print the file names instead of deleting them')),
           ('0', 'print0', None, _('end filenames with NUL, for use with xargs'
                                   ' (implies -p/--print)')),
          ] + commands.walkopts,
          _('hg purge [OPTION]... [DIR]...'))
 }

hgext/rebase.py

@@ -1,472 +1,472 b''
 # rebase.py - rebasing feature for mercurial
 #
 # Copyright 2008 Stefano Tortarolo <stefano.tortarolo at gmail dot com>
 #
 # This software may be used and distributed according to the terms
 # of the GNU General Public License, incorporated herein by reference.
 
 '''move sets of revisions to a different ancestor
 
 This extension lets you rebase changesets in an existing Mercurial
 repository.
 
 For more information:
 http://www.selenic.com/mercurial/wiki/index.cgi/RebaseProject
 '''
 
 from mercurial import util, repair, merge, cmdutil, commands, error
 from mercurial import extensions, ancestor, copies, patch
 from mercurial.commands import templateopts
 from mercurial.node import nullrev
 from mercurial.lock import release
 from mercurial.i18n import _
 import os, errno
 
 def rebasemerge(repo, rev, first=False):
     'return the correct ancestor'
     oldancestor = ancestor.ancestor
 
     def newancestor(a, b, pfunc):
         ancestor.ancestor = oldancestor
         if b == rev:
             return repo[rev].parents()[0].rev()
         return ancestor.ancestor(a, b, pfunc)
 
     if not first:
         ancestor.ancestor = newancestor
     else:
         repo.ui.debug(_("first revision, do not change ancestor\n"))
     stats = merge.update(repo, rev, True, True, False)
     return stats
 
 def rebase(ui, repo, **opts):
     """move changeset (and descendants) to a different branch
 
     Rebase uses repeated merging to graft changesets from one part of
     history onto another. This can be useful for linearizing local
     changes relative to a master development tree.
 
     If a rebase is interrupted to manually resolve a merge, it can be
     continued with --continue/-c or aborted with --abort/-a.
     """
     originalwd = target = None
     external = nullrev
     state = skipped = {}
 
     lock = wlock = None
     try:
         lock = repo.lock()
         wlock = repo.wlock()
 
         # Validate input and define rebasing points
         destf = opts.get('dest', None)
         srcf = opts.get('source', None)
         basef = opts.get('base', None)
         contf = opts.get('continue')
         abortf = opts.get('abort')
         collapsef = opts.get('collapse', False)
         extrafn = opts.get('extrafn')
         keepf = opts.get('keep', False)
         keepbranchesf = opts.get('keepbranches', False)
 
         if contf or abortf:
             if contf and abortf:
                 raise error.ParseError('rebase',
                                        _('cannot use both abort and continue'))
             if collapsef:
                 raise error.ParseError(
                     'rebase', _('cannot use collapse with continue or abort'))
 
             if srcf or basef or destf:
                 raise error.ParseError('rebase',
                     _('abort and continue do not allow specifying revisions'))
 
             (originalwd, target, state, collapsef, keepf,
                                 keepbranchesf, external) = restorestatus(repo)
             if abortf:
                 abort(repo, originalwd, target, state)
                 return
         else:
             if srcf and basef:
                 raise error.ParseError('rebase', _('cannot specify both a '
                                                    'revision and a base'))
             cmdutil.bail_if_changed(repo)
             result = buildstate(repo, destf, srcf, basef, collapsef)
             if result:
                 originalwd, target, state, external = result
             else: # Empty state built, nothing to rebase
                 repo.ui.status(_('nothing to rebase\n'))
                 return
 
         if keepbranchesf:
             if extrafn:
                 raise error.ParseError(
                     'rebase', _('cannot use both keepbranches and extrafn'))
             def extrafn(ctx, extra):
                 extra['branch'] = ctx.branch()
 
         # Rebase
         targetancestors = list(repo.changelog.ancestors(target))
         targetancestors.append(target)
 
-        for rev in util.sort(state):
+        for rev in sorted(state):
             if state[rev] == -1:
                 storestatus(repo, originalwd, target, state, collapsef, keepf,
                                                     keepbranchesf, external)
                 rebasenode(repo, rev, target, state, skipped, targetancestors,
                                                        collapsef, extrafn)
         ui.note(_('rebase merging completed\n'))
 
         if collapsef:
             p1, p2 = defineparents(repo, min(state), target,
                                                         state, targetancestors)
             concludenode(repo, rev, p1, external, state, collapsef,
                          last=True, skipped=skipped, extrafn=extrafn)
 
         if 'qtip' in repo.tags():
             updatemq(repo, state, skipped, **opts)
 
         if not keepf:
             # Remove no more useful revisions
             if set(repo.changelog.descendants(min(state))) - set(state):
                 ui.warn(_("warning: new changesets detected on source branch, "
                                                         "not stripping\n"))
             else:
                 repair.strip(repo.ui, repo, repo[min(state)].node(), "strip")
 
         clearstatus(repo)
         ui.status(_("rebase completed\n"))
         if os.path.exists(repo.sjoin('undo')):
             util.unlink(repo.sjoin('undo'))
         if skipped:
             ui.note(_("%d revisions have been skipped\n") % len(skipped))
     finally:
         release(lock, wlock)
 
 def concludenode(repo, rev, p1, p2, state, collapse, last=False, skipped={},
                  extrafn=None):
     """Skip commit if collapsing has been required and rev is not the last
     revision, commit otherwise
     """
     repo.ui.debug(_(" set parents\n"))
     if collapse and not last:
         repo.dirstate.setparents(repo[p1].node())
         return None
 
     repo.dirstate.setparents(repo[p1].node(), repo[p2].node())
 
     # Commit, record the old nodeid
     m, a, r = repo.status()[:3]
     newrev = nullrev
     try:
         if last:
             commitmsg = 'Collapsed revision'
             for rebased in state:
                 if rebased not in skipped:
                     commitmsg += '\n* %s' % repo[rebased].description()
             commitmsg = repo.ui.edit(commitmsg, repo.ui.username())
         else:
             commitmsg = repo[rev].description()
         # Commit might fail if unresolved files exist
         extra = {'rebase_source': repo[rev].hex()}
         if extrafn:
             extrafn(repo[rev], extra)
         newrev = repo.commit(m+a+r,
                             text=commitmsg,
                             user=repo[rev].user(),
                             date=repo[rev].date(),
                             extra=extra)
         return newrev
     except util.Abort:
         # Invalidate the previous setparents
         repo.dirstate.invalidate()
         raise
 
 def rebasenode(repo, rev, target, state, skipped, targetancestors, collapse,
                extrafn):
     'Rebase a single revision'
     repo.ui.debug(_("rebasing %d:%s\n") % (rev, repo[rev]))
 
     p1, p2 = defineparents(repo, rev, target, state, targetancestors)
 
     repo.ui.debug(_(" future parents are %d and %d\n") % (repo[p1].rev(),
                                                             repo[p2].rev()))
 
     # Merge phase
     if len(repo.parents()) != 2:
         # Update to target and merge it with local
         if repo['.'].rev() != repo[p1].rev():
             repo.ui.debug(_(" update to %d:%s\n") % (repo[p1].rev(), repo[p1]))
             merge.update(repo, p1, False, True, False)
         else:
             repo.ui.debug(_(" already in target\n"))
         repo.dirstate.write()
         repo.ui.debug(_(" merge against %d:%s\n") % (repo[rev].rev(), repo[rev]))
         first = repo[rev].rev() == repo[min(state)].rev()
         stats = rebasemerge(repo, rev, first)
 
         if stats[3] > 0:
             raise util.Abort(_('fix unresolved conflicts with hg resolve then '
                                                 'run hg rebase --continue'))
     else: # we have an interrupted rebase
         repo.ui.debug(_('resuming interrupted rebase\n'))
 
     # Keep track of renamed files in the revision that is going to be rebased
     # Here we simulate the copies and renames in the source changeset
     cop, diver = copies.copies(repo, repo[rev], repo[target], repo[p2], True)
     m1 = repo[rev].manifest()
     m2 = repo[target].manifest()
     for k, v in cop.iteritems():
         if k in m1:
             if v in m1 or v in m2:
                 repo.dirstate.copy(v, k)
                 if v in m2 and v not in m1:
                     repo.dirstate.remove(v)
                 
     newrev = concludenode(repo, rev, p1, p2, state, collapse,
                           extrafn=extrafn)
 
     # Update the state
     if newrev is not None:
         state[rev] = repo[newrev].rev()
     else:
         if not collapse:
             repo.ui.note(_('no changes, revision %d skipped\n') % rev)
             repo.ui.debug(_('next revision set to %s\n') % p1)
             skipped[rev] = True
         state[rev] = p1
 
 def defineparents(repo, rev, target, state, targetancestors):
     'Return the new parent relationship of the revision that will be rebased'
     parents = repo[rev].parents()
     p1 = p2 = nullrev
 
     P1n = parents[0].rev()
     if P1n in targetancestors:
         p1 = target
     elif P1n in state:
         p1 = state[P1n]
     else: # P1n external
         p1 = target
         p2 = P1n
 
     if len(parents) == 2 and parents[1].rev() not in targetancestors:
         P2n = parents[1].rev()
         # interesting second parent
         if P2n in state:
             if p1 == target: # P1n in targetancestors or external
                 p1 = state[P2n]
             else:
                 p2 = state[P2n]
         else: # P2n external
             if p2 != nullrev: # P1n external too => rev is a merged revision
                 raise util.Abort(_('cannot use revision %d as base, result '
                         'would have 3 parents') % rev)
             p2 = P2n
     return p1, p2
 
 def isagitpatch(repo, patchname):
     'Return true if the given patch is in git format'
     mqpatch = os.path.join(repo.mq.path, patchname)
     for line in patch.linereader(file(mqpatch, 'rb')):
         if line.startswith('diff --git'):
             return True
     return False
 
 def updatemq(repo, state, skipped, **opts):
     'Update rebased mq patches - finalize and then import them'
     mqrebase = {}
     for p in repo.mq.applied:
         if repo[p.rev].rev() in state:
             repo.ui.debug(_('revision %d is an mq patch (%s), finalize it.\n') %
                                         (repo[p.rev].rev(), p.name))
             mqrebase[repo[p.rev].rev()] = (p.name, isagitpatch(repo, p.name))
 
     if mqrebase:
         repo.mq.finish(repo, mqrebase.keys())
 
         # We must start import from the newest revision
         mq = mqrebase.keys()
         mq.sort()
         mq.reverse()
         for rev in mq:
             if rev not in skipped:
                 repo.ui.debug(_('import mq patch %d (%s)\n')
                               % (state[rev], mqrebase[rev][0]))
                 repo.mq.qimport(repo, (), patchname=mqrebase[rev][0],
                             git=mqrebase[rev][1],rev=[str(state[rev])])
         repo.mq.save_dirty()
 
 def storestatus(repo, originalwd, target, state, collapse, keep, keepbranches,
                                                                 external):
     'Store the current status to allow recovery'
     f = repo.opener("rebasestate", "w")
     f.write(repo[originalwd].hex() + '\n')
     f.write(repo[target].hex() + '\n')
     f.write(repo[external].hex() + '\n')
     f.write('%d\n' % int(collapse))
     f.write('%d\n' % int(keep))
     f.write('%d\n' % int(keepbranches))
     for d, v in state.iteritems():
         oldrev = repo[d].hex()
         newrev = repo[v].hex()
         f.write("%s:%s\n" % (oldrev, newrev))
     f.close()
     repo.ui.debug(_('rebase status stored\n'))
 
 def clearstatus(repo):
     'Remove the status files'
     if os.path.exists(repo.join("rebasestate")):
         util.unlink(repo.join("rebasestate"))
 
 def restorestatus(repo):
     'Restore a previously stored status'
     try:
         target = None
         collapse = False
         external = nullrev
         state = {}
         f = repo.opener("rebasestate")
         for i, l in enumerate(f.read().splitlines()):
             if i == 0:
                 originalwd = repo[l].rev()
             elif i == 1:
                 target = repo[l].rev()
             elif i == 2:
                 external = repo[l].rev()
             elif i == 3:
                 collapse = bool(int(l))
             elif i == 4:
                 keep = bool(int(l))
             elif i == 5:
                 keepbranches = bool(int(l))
             else:
                 oldrev, newrev = l.split(':')
                 state[repo[oldrev].rev()] = repo[newrev].rev()
         repo.ui.debug(_('rebase status resumed\n'))
         return originalwd, target, state, collapse, keep, keepbranches, external
     except IOError, err:
         if err.errno != errno.ENOENT:
             raise
         raise util.Abort(_('no rebase in progress'))
 
 def abort(repo, originalwd, target, state):
     'Restore the repository to its original state'
     if set(repo.changelog.descendants(target)) - set(state.values()):
         repo.ui.warn(_("warning: new changesets detected on target branch, "
                                                     "not stripping\n"))
     else:
         # Strip from the first rebased revision
         merge.update(repo, repo[originalwd].rev(), False, True, False)
         rebased = filter(lambda x: x > -1, state.values())
         if rebased:
             strippoint = min(rebased)
             repair.strip(repo.ui, repo, repo[strippoint].node(), "strip")
         clearstatus(repo)
         repo.ui.status(_('rebase aborted\n'))
 
 def buildstate(repo, dest, src, base, collapse):
     'Define which revisions are going to be rebased and where'
     targetancestors = set()
 
     if not dest:
         # Destination defaults to the latest revision in the current branch
         branch = repo[None].branch()
         dest = repo[branch].rev()
     else:
         if 'qtip' in repo.tags() and (repo[dest].hex() in
                                 [s.rev for s in repo.mq.applied]):
             raise util.Abort(_('cannot rebase onto an applied mq patch'))
         dest = repo[dest].rev()
 
     if src:
         commonbase = repo[src].ancestor(repo[dest])
         if commonbase == repo[src]:
             raise util.Abort(_('cannot rebase an ancestor'))
         if commonbase == repo[dest]:
             raise util.Abort(_('cannot rebase a descendant'))
         source = repo[src].rev()
     else:
         if base:
             cwd = repo[base].rev()
         else:
             cwd = repo['.'].rev()
 
         if cwd == dest:
             repo.ui.debug(_('already working on current\n'))
             return None
 
         targetancestors = set(repo.changelog.ancestors(dest))
         if cwd in targetancestors:
             repo.ui.debug(_('already working on the current branch\n'))
             return None
 
         cwdancestors = set(repo.changelog.ancestors(cwd))
         cwdancestors.add(cwd)
         rebasingbranch = cwdancestors - targetancestors
         source = min(rebasingbranch)
 
     repo.ui.debug(_('rebase onto %d starting from %d\n') % (dest, source))
     state = dict.fromkeys(repo.changelog.descendants(source), nullrev)
     external = nullrev
     if collapse:
         if not targetancestors:
             targetancestors = set(repo.changelog.ancestors(dest))
         for rev in state:
             # Check externals and fail if there are more than one
             for p in repo[rev].parents():
                 if (p.rev() not in state and p.rev() != source
                             and p.rev() not in targetancestors):
                     if external != nullrev:
                         raise util.Abort(_('unable to collapse, there is more '
                                 'than one external parent'))
                     external = p.rev()
 
     state[source] = nullrev
     return repo['.'].rev(), repo[dest].rev(), state, external
 
 def pullrebase(orig, ui, repo, *args, **opts):
     'Call rebase after pull if the latter has been invoked with --rebase'
     if opts.get('rebase'):
         if opts.get('update'):
             del opts.get['update']
             ui.debug(_('--update and --rebase are not compatible, ignoring '
                                         'the update flag\n'))
 
         cmdutil.bail_if_changed(repo)
         revsprepull = len(repo)
         orig(ui, repo, *args, **opts)
         revspostpull = len(repo)
         if revspostpull > revsprepull:
             rebase(ui, repo, **opts)
             branch = repo[None].branch()
             dest = repo[branch].rev()
             if dest != repo['.'].rev():
                 # there was nothing to rebase we force an update
                 merge.update(repo, dest, False, False, False)
     else:
         orig(ui, repo, *args, **opts)
 
 def uisetup(ui):
     'Replace pull with a decorator to provide --rebase option'
     entry = extensions.wrapcommand(commands.table, 'pull', pullrebase)
     entry[1].append(('', 'rebase', None,
                      _("rebase working directory to branch head"))
 )
 
 cmdtable = {
 "rebase":
         (rebase,
         [
         ('s', 'source', '', _('rebase from a given revision')),
         ('b', 'base', '', _('rebase from the base of a given revision')),
         ('d', 'dest', '', _('rebase onto a given revision')),
         ('', 'collapse', False, _('collapse the rebased revisions')),
         ('', 'keep', False, _('keep original revisions')),
         ('', 'keepbranches', False, _('keep original branches')),
         ('c', 'continue', False, _('continue an interrupted rebase')),
         ('a', 'abort', False, _('abort an interrupted rebase')),] +
          templateopts,
         _('hg rebase [-s REV | -b REV] [-d REV] [--collapse] [--keep] '
                             '[--keepbranches] | [-c] | [-a]')),
 }

hgext/transplant.py

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

mercurial/changelog.py

@@ -1,221 +1,221 b''
 # changelog.py - changelog class for mercurial
 #
 # Copyright 2005-2007 Matt Mackall <[e-mail]>
 #
 # This software may be used and distributed according to the terms
 # of the GNU General Public License, incorporated herein by reference.
 
 from node import bin, hex, nullid
 from i18n import _
 import util, error, revlog, encoding
 
 def _string_escape(text):
     """
     >>> d = {'nl': chr(10), 'bs': chr(92), 'cr': chr(13), 'nul': chr(0)}
     >>> s = "ab%(nl)scd%(bs)s%(bs)sn%(nul)sab%(cr)scd%(bs)s%(nl)s" % d
     >>> s
     'ab\\ncd\\\\\\\\n\\x00ab\\rcd\\\\\\n'
     >>> res = _string_escape(s)
     >>> s == res.decode('string_escape')
     True
     """
     # subset of the string_escape codec
     text = text.replace('\\', '\\\\').replace('\n', '\\n').replace('\r', '\\r')
     return text.replace('\0', '\\0')
 
 class appender:
     '''the changelog index must be updated last on disk, so we use this class
     to delay writes to it'''
     def __init__(self, fp, buf):
         self.data = buf
         self.fp = fp
         self.offset = fp.tell()
         self.size = util.fstat(fp).st_size
 
     def end(self):
         return self.size + len("".join(self.data))
     def tell(self):
         return self.offset
     def flush(self):
         pass
     def close(self):
         self.fp.close()
 
     def seek(self, offset, whence=0):
         '''virtual file offset spans real file and data'''
         if whence == 0:
             self.offset = offset
         elif whence == 1:
             self.offset += offset
         elif whence == 2:
             self.offset = self.end() + offset
         if self.offset < self.size:
             self.fp.seek(self.offset)
 
     def read(self, count=-1):
         '''only trick here is reads that span real file and data'''
         ret = ""
         if self.offset < self.size:
             s = self.fp.read(count)
             ret = s
             self.offset += len(s)
             if count > 0:
                 count -= len(s)
         if count != 0:
             doff = self.offset - self.size
             self.data.insert(0, "".join(self.data))
             del self.data[1:]
             s = self.data[0][doff:doff+count]
             self.offset += len(s)
             ret += s
         return ret
 
     def write(self, s):
         self.data.append(str(s))
         self.offset += len(s)
 
 class changelog(revlog.revlog):
     def __init__(self, opener):
         revlog.revlog.__init__(self, opener, "00changelog.i")
 
     def delayupdate(self):
         "delay visibility of index updates to other readers"
         self._realopener = self.opener
         self.opener = self._delayopener
         self._delaycount = len(self)
         self._delaybuf = []
         self._delayname = None
 
     def finalize(self, tr):
         "finalize index updates"
         self.opener = self._realopener
         # move redirected index data back into place
         if self._delayname:
             util.rename(self._delayname + ".a", self._delayname)
         elif self._delaybuf:
             fp = self.opener(self.indexfile, 'a')
             fp.write("".join(self._delaybuf))
             fp.close()
             self._delaybuf = []
         # split when we're done
         self.checkinlinesize(tr)
 
     def _delayopener(self, name, mode='r'):
         fp = self._realopener(name, mode)
         # only divert the index
         if not name == self.indexfile:
             return fp
         # if we're doing an initial clone, divert to another file
         if self._delaycount == 0:
             self._delayname = fp.name
             if not len(self):
                 # make sure to truncate the file
                 mode = mode.replace('a', 'w')
             return self._realopener(name + ".a", mode)
         # otherwise, divert to memory
         return appender(fp, self._delaybuf)
 
     def readpending(self, file):
         r = revlog.revlog(self.opener, file)
         self.index = r.index
         self.nodemap = r.nodemap
         self._chunkcache = r._chunkcache
 
     def writepending(self):
         "create a file containing the unfinalized state for pretxnchangegroup"
         if self._delaybuf:
             # make a temporary copy of the index
             fp1 = self._realopener(self.indexfile)
             fp2 = self._realopener(self.indexfile + ".a", "w")
             fp2.write(fp1.read())
             # add pending data
             fp2.write("".join(self._delaybuf))
             fp2.close()
             # switch modes so finalize can simply rename
             self._delaybuf = []
             self._delayname = fp1.name
 
         if self._delayname:
             return True
 
         return False
 
     def checkinlinesize(self, tr, fp=None):
         if self.opener == self._delayopener:
             return
         return revlog.revlog.checkinlinesize(self, tr, fp)
 
     def decode_extra(self, text):
         extra = {}
         for l in text.split('\0'):
             if l:
                 k, v = l.decode('string_escape').split(':', 1)
                 extra[k] = v
         return extra
 
     def encode_extra(self, d):
         # keys must be sorted to produce a deterministic changelog entry
-        items = [_string_escape('%s:%s' % (k, d[k])) for k in util.sort(d)]
+        items = [_string_escape('%s:%s' % (k, d[k])) for k in sorted(d)]
         return "\0".join(items)
 
     def read(self, node):
         """
         format used:
         nodeid\n        : manifest node in ascii
         user\n          : user, no \n or \r allowed
         time tz extra\n : date (time is int or float, timezone is int)
                         : extra is metadatas, encoded and separated by '\0'
                         : older versions ignore it
         files\n\n       : files modified by the cset, no \n or \r allowed
         (.*)            : comment (free text, ideally utf-8)
 
         changelog v0 doesn't use extra
         """
         text = self.revision(node)
         if not text:
             return (nullid, "", (0, 0), [], "", {'branch': 'default'})
         last = text.index("\n\n")
         desc = encoding.tolocal(text[last + 2:])
         l = text[:last].split('\n')
         manifest = bin(l[0])
         user = encoding.tolocal(l[1])
 
         extra_data = l[2].split(' ', 2)
         if len(extra_data) != 3:
             time = float(extra_data.pop(0))
             try:
                 # various tools did silly things with the time zone field.
                 timezone = int(extra_data[0])
             except:
                 timezone = 0
             extra = {}
         else:
             time, timezone, extra = extra_data
             time, timezone = float(time), int(timezone)
             extra = self.decode_extra(extra)
         if not extra.get('branch'):
             extra['branch'] = 'default'
         files = l[3:]
         return (manifest, user, (time, timezone), files, desc, extra)
 
     def add(self, manifest, files, desc, transaction, p1=None, p2=None,
                   user=None, date=None, extra={}):
 
         user = user.strip()
         if "\n" in user:
             raise error.RevlogError(_("username %s contains a newline")
                                     % repr(user))
         user, desc = encoding.fromlocal(user), encoding.fromlocal(desc)
 
         if date:
             parseddate = "%d %d" % util.parsedate(date)
         else:
             parseddate = "%d %d" % util.makedate()
         if extra and extra.get("branch") in ("default", ""):
             del extra["branch"]
         if extra:
             extra = self.encode_extra(extra)
             parseddate = "%s %s" % (parseddate, extra)
-        l = [hex(manifest), user, parseddate] + util.sort(files) + ["", desc]
+        l = [hex(manifest), user, parseddate] + sorted(files) + ["", desc]
         text = "\n".join(l)
         return self.addrevision(text, transaction, len(self), p1, p2)

mercurial/cmdutil.py

@@ -1,1226 +1,1226 b''
 # cmdutil.py - help for command processing in mercurial
 #
 # Copyright 2005-2007 Matt Mackall <[e-mail]>
 #
 # This software may be used and distributed according to the terms
 # of the GNU General Public License, incorporated herein by reference.
 
 from node import hex, nullid, nullrev, short
 from i18n import _
 import os, sys, bisect, stat, encoding
 import mdiff, bdiff, util, templater, templatefilters, patch, errno, error
 import match as _match
 
 revrangesep = ':'
 
 def findpossible(cmd, table, strict=False):
     """
     Return cmd -> (aliases, command table entry)
     for each matching command.
     Return debug commands (or their aliases) only if no normal command matches.
     """
     choice = {}
     debugchoice = {}
     for e in table.keys():
         aliases = e.lstrip("^").split("|")
         found = None
         if cmd in aliases:
             found = cmd
         elif not strict:
             for a in aliases:
                 if a.startswith(cmd):
                     found = a
                     break
         if found is not None:
             if aliases[0].startswith("debug") or found.startswith("debug"):
                 debugchoice[found] = (aliases, table[e])
             else:
                 choice[found] = (aliases, table[e])
 
     if not choice and debugchoice:
         choice = debugchoice
 
     return choice
 
 def findcmd(cmd, table, strict=True):
     """Return (aliases, command table entry) for command string."""
     choice = findpossible(cmd, table, strict)
 
     if cmd in choice:
         return choice[cmd]
 
     if len(choice) > 1:
         clist = choice.keys()
         clist.sort()
         raise error.AmbiguousCommand(cmd, clist)
 
     if choice:
         return choice.values()[0]
 
     raise error.UnknownCommand(cmd)
 
 def bail_if_changed(repo):
     if repo.dirstate.parents()[1] != nullid:
         raise util.Abort(_('outstanding uncommitted merge'))
     modified, added, removed, deleted = repo.status()[:4]
     if modified or added or removed or deleted:
         raise util.Abort(_("outstanding uncommitted changes"))
 
 def logmessage(opts):
     """ get the log message according to -m and -l option """
     message = opts.get('message')
     logfile = opts.get('logfile')
 
     if message and logfile:
         raise util.Abort(_('options --message and --logfile are mutually '
                            'exclusive'))
     if not message and logfile:
         try:
             if logfile == '-':
                 message = sys.stdin.read()
             else:
                 message = open(logfile).read()
         except IOError, inst:
             raise util.Abort(_("can't read commit message '%s': %s") %
                              (logfile, inst.strerror))
     return message
 
 def loglimit(opts):
     """get the log limit according to option -l/--limit"""
     limit = opts.get('limit')
     if limit:
         try:
             limit = int(limit)
         except ValueError:
             raise util.Abort(_('limit must be a positive integer'))
         if limit <= 0: raise util.Abort(_('limit must be positive'))
     else:
         limit = sys.maxint
     return limit
 
 def remoteui(src, opts):
     'build a remote ui from ui or repo and opts'
     if hasattr(src, 'baseui'): # looks like a repository
         dst = src.baseui # drop repo-specific config
         src = src.ui # copy target options from repo
     else: # assume it's a global ui object
         dst = src # keep all global options
 
     # copy ssh-specific options
     for o in 'ssh', 'remotecmd':
         v = opts.get(o) or src.config('ui', o)
         if v:
             dst.setconfig("ui", o, v)
     # copy bundle-specific options
     r = src.config('bundle', 'mainreporoot')
     if r:
         dst.setconfig('bundle', 'mainreporoot', r)
 
     return dst
 
 def revpair(repo, revs):
     '''return pair of nodes, given list of revisions. second item can
     be None, meaning use working dir.'''
 
     def revfix(repo, val, defval):
         if not val and val != 0 and defval is not None:
             val = defval
         return repo.lookup(val)
 
     if not revs:
         return repo.dirstate.parents()[0], None
     end = None
     if len(revs) == 1:
         if revrangesep in revs[0]:
             start, end = revs[0].split(revrangesep, 1)
             start = revfix(repo, start, 0)
             end = revfix(repo, end, len(repo) - 1)
         else:
             start = revfix(repo, revs[0], None)
     elif len(revs) == 2:
         if revrangesep in revs[0] or revrangesep in revs[1]:
             raise util.Abort(_('too many revisions specified'))
         start = revfix(repo, revs[0], None)
         end = revfix(repo, revs[1], None)
     else:
         raise util.Abort(_('too many revisions specified'))
     return start, end
 
 def revrange(repo, revs):
     """Yield revision as strings from a list of revision specifications."""
 
     def revfix(repo, val, defval):
         if not val and val != 0 and defval is not None:
             return defval
         return repo.changelog.rev(repo.lookup(val))
 
     seen, l = {}, []
     for spec in revs:
         if revrangesep in spec:
             start, end = spec.split(revrangesep, 1)
             start = revfix(repo, start, 0)
             end = revfix(repo, end, len(repo) - 1)
             step = start > end and -1 or 1
             for rev in xrange(start, end+step, step):
                 if rev in seen:
                     continue
                 seen[rev] = 1
                 l.append(rev)
         else:
             rev = revfix(repo, spec, None)
             if rev in seen:
                 continue
             seen[rev] = 1
             l.append(rev)
 
     return l
 
 def make_filename(repo, pat, node,
                   total=None, seqno=None, revwidth=None, pathname=None):
     node_expander = {
         'H': lambda: hex(node),
         'R': lambda: str(repo.changelog.rev(node)),
         'h': lambda: short(node),
         }
     expander = {
         '%': lambda: '%',
         'b': lambda: os.path.basename(repo.root),
         }
 
     try:
         if node:
             expander.update(node_expander)
         if node:
             expander['r'] = (lambda:
                     str(repo.changelog.rev(node)).zfill(revwidth or 0))
         if total is not None:
             expander['N'] = lambda: str(total)
         if seqno is not None:
             expander['n'] = lambda: str(seqno)
         if total is not None and seqno is not None:
             expander['n'] = lambda: str(seqno).zfill(len(str(total)))
         if pathname is not None:
             expander['s'] = lambda: os.path.basename(pathname)
             expander['d'] = lambda: os.path.dirname(pathname) or '.'
             expander['p'] = lambda: pathname
 
         newname = []
         patlen = len(pat)
         i = 0
         while i < patlen:
             c = pat[i]
             if c == '%':
                 i += 1
                 c = pat[i]
                 c = expander[c]()
             newname.append(c)
             i += 1
         return ''.join(newname)
     except KeyError, inst:
         raise util.Abort(_("invalid format spec '%%%s' in output file name") %
                          inst.args[0])
 
 def make_file(repo, pat, node=None,
               total=None, seqno=None, revwidth=None, mode='wb', pathname=None):
 
     writable = 'w' in mode or 'a' in mode
 
     if not pat or pat == '-':
         return writable and sys.stdout or sys.stdin
     if hasattr(pat, 'write') and writable:
         return pat
     if hasattr(pat, 'read') and 'r' in mode:
         return pat
     return open(make_filename(repo, pat, node, total, seqno, revwidth,
                               pathname),
                 mode)
 
 def match(repo, pats=[], opts={}, globbed=False, default='relpath'):
     if not globbed and default == 'relpath':
         pats = util.expand_glob(pats or [])
     m = _match.match(repo.root, repo.getcwd(), pats,
                     opts.get('include'), opts.get('exclude'), default)
     def badfn(f, msg):
         repo.ui.warn("%s: %s\n" % (m.rel(f), msg))
         return False
     m.bad = badfn
     return m
 
 def matchall(repo):
     return _match.always(repo.root, repo.getcwd())
 
 def matchfiles(repo, files):
     return _match.exact(repo.root, repo.getcwd(), files)
 
 def findrenames(repo, added=None, removed=None, threshold=0.5):
     '''find renamed files -- yields (before, after, score) tuples'''
     if added is None or removed is None:
         added, removed = repo.status()[1:3]
     ctx = repo['.']
     for a in added:
         aa = repo.wread(a)
         bestname, bestscore = None, threshold
         for r in removed:
             rr = ctx.filectx(r).data()
 
             # bdiff.blocks() returns blocks of matching lines
             # count the number of bytes in each
             equal = 0
             alines = mdiff.splitnewlines(aa)
             matches = bdiff.blocks(aa, rr)
             for x1,x2,y1,y2 in matches:
                 for line in alines[x1:x2]:
                     equal += len(line)
 
             lengths = len(aa) + len(rr)
             if lengths:
                 myscore = equal*2.0 / lengths
                 if myscore >= bestscore:
                     bestname, bestscore = r, myscore
         if bestname:
             yield bestname, a, bestscore
 
 def addremove(repo, pats=[], opts={}, dry_run=None, similarity=None):
     if dry_run is None:
         dry_run = opts.get('dry_run')
     if similarity is None:
         similarity = float(opts.get('similarity') or 0)
     add, remove = [], []
     mapping = {}
     audit_path = util.path_auditor(repo.root)
     m = match(repo, pats, opts)
     for abs in repo.walk(m):
         target = repo.wjoin(abs)
         good = True
         try:
             audit_path(abs)
         except:
             good = False
         rel = m.rel(abs)
         exact = m.exact(abs)
         if good and abs not in repo.dirstate:
             add.append(abs)
             mapping[abs] = rel, m.exact(abs)
             if repo.ui.verbose or not exact:
                 repo.ui.status(_('adding %s\n') % ((pats and rel) or abs))
         if repo.dirstate[abs] != 'r' and (not good or not util.lexists(target)
             or (os.path.isdir(target) and not os.path.islink(target))):
             remove.append(abs)
             mapping[abs] = rel, exact
             if repo.ui.verbose or not exact:
                 repo.ui.status(_('removing %s\n') % ((pats and rel) or abs))
     if not dry_run:
         repo.remove(remove)
         repo.add(add)
     if similarity > 0:
         for old, new, score in findrenames(repo, add, remove, similarity):
             oldrel, oldexact = mapping[old]
             newrel, newexact = mapping[new]
             if repo.ui.verbose or not oldexact or not newexact:
                 repo.ui.status(_('recording removal of %s as rename to %s '
                                  '(%d%% similar)\n') %
                                (oldrel, newrel, score * 100))
             if not dry_run:
                 repo.copy(old, new)
 
 def copy(ui, repo, pats, opts, rename=False):
     # called with the repo lock held
     #
     # hgsep => pathname that uses "/" to separate directories
     # ossep => pathname that uses os.sep to separate directories
     cwd = repo.getcwd()
     targets = {}
     after = opts.get("after")
     dryrun = opts.get("dry_run")
 
     def walkpat(pat):
         srcs = []
         m = match(repo, [pat], opts, globbed=True)
         for abs in repo.walk(m):
             state = repo.dirstate[abs]
             rel = m.rel(abs)
             exact = m.exact(abs)
             if state in '?r':
                 if exact and state == '?':
                     ui.warn(_('%s: not copying - file is not managed\n') % rel)
                 if exact and state == 'r':
                     ui.warn(_('%s: not copying - file has been marked for'
                               ' remove\n') % rel)
                 continue
             # abs: hgsep
             # rel: ossep
             srcs.append((abs, rel, exact))
         return srcs
 
     # abssrc: hgsep
     # relsrc: ossep
     # otarget: ossep
     def copyfile(abssrc, relsrc, otarget, exact):
         abstarget = util.canonpath(repo.root, cwd, otarget)
         reltarget = repo.pathto(abstarget, cwd)
         target = repo.wjoin(abstarget)
         src = repo.wjoin(abssrc)
         state = repo.dirstate[abstarget]
 
         # check for collisions
         prevsrc = targets.get(abstarget)
         if prevsrc is not None:
             ui.warn(_('%s: not overwriting - %s collides with %s\n') %
                     (reltarget, repo.pathto(abssrc, cwd),
                      repo.pathto(prevsrc, cwd)))
             return
 
         # check for overwrites
         exists = os.path.exists(target)
         if not after and exists or after and state in 'mn':
             if not opts['force']:
                 ui.warn(_('%s: not overwriting - file exists\n') %
                         reltarget)
                 return
 
         if after:
             if not exists:
                 return
         elif not dryrun:
             try:
                 if exists:
                     os.unlink(target)
                 targetdir = os.path.dirname(target) or '.'
                 if not os.path.isdir(targetdir):
                     os.makedirs(targetdir)
                 util.copyfile(src, target)
             except IOError, inst:
                 if inst.errno == errno.ENOENT:
                     ui.warn(_('%s: deleted in working copy\n') % relsrc)
                 else:
                     ui.warn(_('%s: cannot copy - %s\n') %
                             (relsrc, inst.strerror))
                     return True # report a failure
 
         if ui.verbose or not exact:
             if rename:
                 ui.status(_('moving %s to %s\n') % (relsrc, reltarget))
             else:
                 ui.status(_('copying %s to %s\n') % (relsrc, reltarget))
 
         targets[abstarget] = abssrc
 
         # fix up dirstate
         origsrc = repo.dirstate.copied(abssrc) or abssrc
         if abstarget == origsrc: # copying back a copy?
             if state not in 'mn' and not dryrun:
                 repo.dirstate.normallookup(abstarget)
         else:
             if repo.dirstate[origsrc] == 'a' and origsrc == abssrc:
                 if not ui.quiet:
                     ui.warn(_("%s has not been committed yet, so no copy "
                               "data will be stored for %s.\n")
                             % (repo.pathto(origsrc, cwd), reltarget))
                 if repo.dirstate[abstarget] in '?r' and not dryrun:
                     repo.add([abstarget])
             elif not dryrun:
                 repo.copy(origsrc, abstarget)
 
         if rename and not dryrun:
             repo.remove([abssrc], not after)
 
     # pat: ossep
     # dest ossep
     # srcs: list of (hgsep, hgsep, ossep, bool)
     # return: function that takes hgsep and returns ossep
     def targetpathfn(pat, dest, srcs):
         if os.path.isdir(pat):
             abspfx = util.canonpath(repo.root, cwd, pat)
             abspfx = util.localpath(abspfx)
             if destdirexists:
                 striplen = len(os.path.split(abspfx)[0])
             else:
                 striplen = len(abspfx)
             if striplen:
                 striplen += len(os.sep)
             res = lambda p: os.path.join(dest, util.localpath(p)[striplen:])
         elif destdirexists:
             res = lambda p: os.path.join(dest,
                                          os.path.basename(util.localpath(p)))
         else:
             res = lambda p: dest
         return res
 
     # pat: ossep
     # dest ossep
     # srcs: list of (hgsep, hgsep, ossep, bool)
     # return: function that takes hgsep and returns ossep
     def targetpathafterfn(pat, dest, srcs):
         if util.patkind(pat, None)[0]:
             # a mercurial pattern
             res = lambda p: os.path.join(dest,
                                          os.path.basename(util.localpath(p)))
         else:
             abspfx = util.canonpath(repo.root, cwd, pat)
             if len(abspfx) < len(srcs[0][0]):
                 # A directory. Either the target path contains the last
                 # component of the source path or it does not.
                 def evalpath(striplen):
                     score = 0
                     for s in srcs:
                         t = os.path.join(dest, util.localpath(s[0])[striplen:])
                         if os.path.exists(t):
                             score += 1
                     return score
 
                 abspfx = util.localpath(abspfx)
                 striplen = len(abspfx)
                 if striplen:
                     striplen += len(os.sep)
                 if os.path.isdir(os.path.join(dest, os.path.split(abspfx)[1])):
                     score = evalpath(striplen)
                     striplen1 = len(os.path.split(abspfx)[0])
                     if striplen1:
                         striplen1 += len(os.sep)
                     if evalpath(striplen1) > score:
                         striplen = striplen1
                 res = lambda p: os.path.join(dest,
                                              util.localpath(p)[striplen:])
             else:
                 # a file
                 if destdirexists:
                     res = lambda p: os.path.join(dest,
                                         os.path.basename(util.localpath(p)))
                 else:
                     res = lambda p: dest
         return res
 
 
     pats = util.expand_glob(pats)
     if not pats:
         raise util.Abort(_('no source or destination specified'))
     if len(pats) == 1:
         raise util.Abort(_('no destination specified'))
     dest = pats.pop()
     destdirexists = os.path.isdir(dest) and not os.path.islink(dest)
     if not destdirexists:
         if len(pats) > 1 or util.patkind(pats[0], None)[0]:
             raise util.Abort(_('with multiple sources, destination must be an '
                                'existing directory'))
         if util.endswithsep(dest):
             raise util.Abort(_('destination %s is not a directory') % dest)
 
     tfn = targetpathfn
     if after:
         tfn = targetpathafterfn
     copylist = []
     for pat in pats:
         srcs = walkpat(pat)
         if not srcs:
             continue
         copylist.append((tfn(pat, dest, srcs), srcs))
     if not copylist:
         raise util.Abort(_('no files to copy'))
 
     errors = 0
     for targetpath, srcs in copylist:
         for abssrc, relsrc, exact in srcs:
             if copyfile(abssrc, relsrc, targetpath(abssrc), exact):
                 errors += 1
 
     if errors:
         ui.warn(_('(consider using --after)\n'))
 
     return errors
 
 def service(opts, parentfn=None, initfn=None, runfn=None):
     '''Run a command as a service.'''
 
     if opts['daemon'] and not opts['daemon_pipefds']:
         rfd, wfd = os.pipe()
         args = sys.argv[:]
         args.append('--daemon-pipefds=%d,%d' % (rfd, wfd))
         # Don't pass --cwd to the child process, because we've already
         # changed directory.
         for i in xrange(1,len(args)):
             if args[i].startswith('--cwd='):
                 del args[i]
                 break
             elif args[i].startswith('--cwd'):
                 del args[i:i+2]
                 break
         pid = os.spawnvp(os.P_NOWAIT | getattr(os, 'P_DETACH', 0),
                          args[0], args)
         os.close(wfd)
         os.read(rfd, 1)
         if parentfn:
             return parentfn(pid)
         else:
             os._exit(0)
 
     if initfn:
         initfn()
 
     if opts['pid_file']:
         fp = open(opts['pid_file'], 'w')
         fp.write(str(os.getpid()) + '\n')
         fp.close()
 
     if opts['daemon_pipefds']:
         rfd, wfd = [int(x) for x in opts['daemon_pipefds'].split(',')]
         os.close(rfd)
         try:
             os.setsid()
         except AttributeError:
             pass
         os.write(wfd, 'y')
         os.close(wfd)
         sys.stdout.flush()
         sys.stderr.flush()
         fd = os.open(util.nulldev, os.O_RDWR)
         if fd != 0: os.dup2(fd, 0)
         if fd != 1: os.dup2(fd, 1)
         if fd != 2: os.dup2(fd, 2)
         if fd not in (0, 1, 2): os.close(fd)
 
     if runfn:
         return runfn()
 
 class changeset_printer(object):
     '''show changeset information when templating not requested.'''
 
     def __init__(self, ui, repo, patch, diffopts, buffered):
         self.ui = ui
         self.repo = repo
         self.buffered = buffered
         self.patch = patch
         self.diffopts = diffopts
         self.header = {}
         self.hunk = {}
         self.lastheader = None
 
     def flush(self, rev):
         if rev in self.header:
             h = self.header[rev]
             if h != self.lastheader:
                 self.lastheader = h
                 self.ui.write(h)
             del self.header[rev]
         if rev in self.hunk:
             self.ui.write(self.hunk[rev])
             del self.hunk[rev]
             return 1
         return 0
 
     def show(self, ctx, copies=(), **props):
         if self.buffered:
             self.ui.pushbuffer()
             self._show(ctx, copies, props)
             self.hunk[ctx.rev()] = self.ui.popbuffer()
         else:
             self._show(ctx, copies, props)
 
     def _show(self, ctx, copies, props):
         '''show a single changeset or file revision'''
         changenode = ctx.node()
         rev = ctx.rev()
 
         if self.ui.quiet:
             self.ui.write("%d:%s\n" % (rev, short(changenode)))
             return
 
         log = self.repo.changelog
         changes = log.read(changenode)
         date = util.datestr(changes[2])
         extra = changes[5]
         branch = extra.get("branch")
 
         hexfunc = self.ui.debugflag and hex or short
 
         parents = [(p, hexfunc(log.node(p)))
                    for p in self._meaningful_parentrevs(log, rev)]
 
         self.ui.write(_("changeset:   %d:%s\n") % (rev, hexfunc(changenode)))
 
         # don't show the default branch name
         if branch != 'default':
             branch = encoding.tolocal(branch)
             self.ui.write(_("branch:      %s\n") % branch)
         for tag in self.repo.nodetags(changenode):
             self.ui.write(_("tag:         %s\n") % tag)
         for parent in parents:
             self.ui.write(_("parent:      %d:%s\n") % parent)
 
         if self.ui.debugflag:
             self.ui.write(_("manifest:    %d:%s\n") %
                           (self.repo.manifest.rev(changes[0]), hex(changes[0])))
         self.ui.write(_("user:        %s\n") % changes[1])
         self.ui.write(_("date:        %s\n") % date)
 
         if self.ui.debugflag:
             files = self.repo.status(log.parents(changenode)[0], changenode)[:3]
             for key, value in zip([_("files:"), _("files+:"), _("files-:")],
                                   files):
                 if value:
                     self.ui.write("%-12s %s\n" % (key, " ".join(value)))
         elif changes[3] and self.ui.verbose:
             self.ui.write(_("files:       %s\n") % " ".join(changes[3]))
         if copies and self.ui.verbose:
             copies = ['%s (%s)' % c for c in copies]
             self.ui.write(_("copies:      %s\n") % ' '.join(copies))
 
         if extra and self.ui.debugflag:
-            for key, value in util.sort(extra.items()):
+            for key, value in sorted(extra.items()):
                 self.ui.write(_("extra:       %s=%s\n")
                               % (key, value.encode('string_escape')))
 
         description = changes[4].strip()
         if description:
             if self.ui.verbose:
                 self.ui.write(_("description:\n"))
                 self.ui.write(description)
                 self.ui.write("\n\n")
             else:
                 self.ui.write(_("summary:     %s\n") %
                               description.splitlines()[0])
         self.ui.write("\n")
 
         self.showpatch(changenode)
 
     def showpatch(self, node):
         if self.patch:
             prev = self.repo.changelog.parents(node)[0]
             chunks = patch.diff(self.repo, prev, node, match=self.patch,
                                 opts=patch.diffopts(self.ui, self.diffopts))
             for chunk in chunks:
                 self.ui.write(chunk)
             self.ui.write("\n")
 
     def _meaningful_parentrevs(self, log, rev):
         """Return list of meaningful (or all if debug) parentrevs for rev.
 
         For merges (two non-nullrev revisions) both parents are meaningful.
         Otherwise the first parent revision is considered meaningful if it
         is not the preceding revision.
         """
         parents = log.parentrevs(rev)
         if not self.ui.debugflag and parents[1] == nullrev:
             if parents[0] >= rev - 1:
                 parents = []
             else:
                 parents = [parents[0]]
         return parents
 
 
 class changeset_templater(changeset_printer):
     '''format changeset information.'''
 
     def __init__(self, ui, repo, patch, diffopts, mapfile, buffered):
         changeset_printer.__init__(self, ui, repo, patch, diffopts, buffered)
         filters = templatefilters.filters.copy()
         filters['formatnode'] = (ui.debugflag and (lambda x: x)
                                  or (lambda x: x[:12]))
         self.t = templater.templater(mapfile, filters,
                                      cache={
                                          'parent': '{rev}:{node|formatnode} ',
                                          'manifest': '{rev}:{node|formatnode}',
                                          'filecopy': '{name} ({source})'})
 
     def use_template(self, t):
         '''set template string to use'''
         self.t.cache['changeset'] = t
 
     def _meaningful_parentrevs(self, ctx):
         """Return list of meaningful (or all if debug) parentrevs for rev.
         """
         parents = ctx.parents()
         if len(parents) > 1:
             return parents
         if self.ui.debugflag:
             return [parents[0], self.repo['null']]
         if parents[0].rev() >= ctx.rev() - 1:
             return []
         return parents
 
     def _show(self, ctx, copies, props):
         '''show a single changeset or file revision'''
 
         def showlist(name, values, plural=None, **args):
             '''expand set of values.
             name is name of key in template map.
             values is list of strings or dicts.
             plural is plural of name, if not simply name + 's'.
 
             expansion works like this, given name 'foo'.
 
             if values is empty, expand 'no_foos'.
 
             if 'foo' not in template map, return values as a string,
             joined by space.
 
             expand 'start_foos'.
 
             for each value, expand 'foo'. if 'last_foo' in template
             map, expand it instead of 'foo' for last key.
 
             expand 'end_foos'.
             '''
             if plural: names = plural
             else: names = name + 's'
             if not values:
                 noname = 'no_' + names
                 if noname in self.t:
                     yield self.t(noname, **args)
                 return
             if name not in self.t:
                 if isinstance(values[0], str):
                     yield ' '.join(values)
                 else:
                     for v in values:
                         yield dict(v, **args)
                 return
             startname = 'start_' + names
             if startname in self.t:
                 yield self.t(startname, **args)
             vargs = args.copy()
             def one(v, tag=name):
                 try:
                     vargs.update(v)
                 except (AttributeError, ValueError):
                     try:
                         for a, b in v:
                             vargs[a] = b
                     except ValueError:
                         vargs[name] = v
                 return self.t(tag, **vargs)
             lastname = 'last_' + name
             if lastname in self.t:
                 last = values.pop()
             else:
                 last = None
             for v in values:
                 yield one(v)
             if last is not None:
                 yield one(last, tag=lastname)
             endname = 'end_' + names
             if endname in self.t:
                 yield self.t(endname, **args)
 
         def showbranches(**args):
             branch = ctx.branch()
             if branch != 'default':
                 branch = encoding.tolocal(branch)
                 return showlist('branch', [branch], plural='branches', **args)
 
         def showparents(**args):
             parents = [[('rev', p.rev()), ('node', p.hex())]
                        for p in self._meaningful_parentrevs(ctx)]
             return showlist('parent', parents, **args)
 
         def showtags(**args):
             return showlist('tag', ctx.tags(), **args)
 
         def showextras(**args):
-            for key, value in util.sort(ctx.extra().items()):
+            for key, value in sorted(ctx.extra().items()):
                 args = args.copy()
                 args.update(dict(key=key, value=value))
                 yield self.t('extra', **args)
 
         def showcopies(**args):
             c = [{'name': x[0], 'source': x[1]} for x in copies]
             return showlist('file_copy', c, plural='file_copies', **args)
 
         files = []
         def getfiles():
             if not files:
                 files[:] = self.repo.status(ctx.parents()[0].node(),
                                             ctx.node())[:3]
             return files
         def showfiles(**args):
             return showlist('file', ctx.files(), **args)
         def showmods(**args):
             return showlist('file_mod', getfiles()[0], **args)
         def showadds(**args):
             return showlist('file_add', getfiles()[1], **args)
         def showdels(**args):
             return showlist('file_del', getfiles()[2], **args)
         def showmanifest(**args):
             args = args.copy()
             args.update(dict(rev=self.repo.manifest.rev(ctx.changeset()[0]),
                              node=hex(ctx.changeset()[0])))
             return self.t('manifest', **args)
 
         def showdiffstat(**args):
             diff = patch.diff(self.repo, ctx.parents()[0].node(), ctx.node())
             files, adds, removes = 0, 0, 0
             for i in patch.diffstatdata(util.iterlines(diff)):
                 files += 1
                 adds += i[1]
                 removes += i[2]
             return '%s: +%s/-%s' % (files, adds, removes)
 
         defprops = {
             'author': ctx.user(),
             'branches': showbranches,
             'date': ctx.date(),
             'desc': ctx.description().strip(),
             'file_adds': showadds,
             'file_dels': showdels,
             'file_mods': showmods,
             'files': showfiles,
             'file_copies': showcopies,
             'manifest': showmanifest,
             'node': ctx.hex(),
             'parents': showparents,
             'rev': ctx.rev(),
             'tags': showtags,
             'extras': showextras,
             'diffstat': showdiffstat,
             }
         props = props.copy()
         props.update(defprops)
 
         # find correct templates for current mode
 
         tmplmodes = [
             (True, None),
             (self.ui.verbose, 'verbose'),
             (self.ui.quiet, 'quiet'),
             (self.ui.debugflag, 'debug'),
         ]
 
         types = {'header': '', 'changeset': 'changeset'}
         for mode, postfix  in tmplmodes:
             for type in types:
                 cur = postfix and ('%s_%s' % (type, postfix)) or type
                 if mode and cur in self.t:
                     types[type] = cur
 
         try:
 
             # write header
             if types['header']:
                 h = templater.stringify(self.t(types['header'], **props))
                 if self.buffered:
                     self.header[ctx.rev()] = h
                 else:
                     self.ui.write(h)
 
             # write changeset metadata, then patch if requested
             key = types['changeset']
             self.ui.write(templater.stringify(self.t(key, **props)))
             self.showpatch(ctx.node())
 
         except KeyError, inst:
             msg = _("%s: no key named '%s'")
             raise util.Abort(msg % (self.t.mapfile, inst.args[0]))
         except SyntaxError, inst:
             raise util.Abort(_('%s: %s') % (self.t.mapfile, inst.args[0]))
 
 def show_changeset(ui, repo, opts, buffered=False, matchfn=False):
     """show one changeset using template or regular display.
 
     Display format will be the first non-empty hit of:
     1. option 'template'
     2. option 'style'
     3. [ui] setting 'logtemplate'
     4. [ui] setting 'style'
     If all of these values are either the unset or the empty string,
     regular display via changeset_printer() is done.
     """
     # options
     patch = False
     if opts.get('patch'):
         patch = matchfn or matchall(repo)
 
     tmpl = opts.get('template')
     style = None
     if tmpl:
         tmpl = templater.parsestring(tmpl, quoted=False)
     else:
         style = opts.get('style')
 
     # ui settings
     if not (tmpl or style):
         tmpl = ui.config('ui', 'logtemplate')
         if tmpl:
             tmpl = templater.parsestring(tmpl)
         else:
             style = ui.config('ui', 'style')
 
     if not (tmpl or style):
         return changeset_printer(ui, repo, patch, opts, buffered)
 
     mapfile = None
     if style and not tmpl:
         mapfile = style
         if not os.path.split(mapfile)[0]:
             mapname = (templater.templatepath('map-cmdline.' + mapfile)
                        or templater.templatepath(mapfile))
             if mapname: mapfile = mapname
 
     try:
         t = changeset_templater(ui, repo, patch, opts, mapfile, buffered)
     except SyntaxError, inst:
         raise util.Abort(inst.args[0])
     if tmpl: t.use_template(tmpl)
     return t
 
 def finddate(ui, repo, date):
     """Find the tipmost changeset that matches the given date spec"""
     df = util.matchdate(date)
     get = util.cachefunc(lambda r: repo[r].changeset())
     changeiter, matchfn = walkchangerevs(ui, repo, [], get, {'rev':None})
     results = {}
     for st, rev, fns in changeiter:
         if st == 'add':
             d = get(rev)[2]
             if df(d[0]):
                 results[rev] = d
         elif st == 'iter':
             if rev in results:
                 ui.status(_("Found revision %s from %s\n") %
                           (rev, util.datestr(results[rev])))
                 return str(rev)
 
     raise util.Abort(_("revision matching date not found"))
 
 def walkchangerevs(ui, repo, pats, change, opts):
     '''Iterate over files and the revs in which they changed.
 
     Callers most commonly need to iterate backwards over the history
     in which they are interested. Doing so has awful (quadratic-looking)
     performance, so we use iterators in a "windowed" way.
 
     We walk a window of revisions in the desired order.  Within the
     window, we first walk forwards to gather data, then in the desired
     order (usually backwards) to display it.
 
     This function returns an (iterator, matchfn) tuple. The iterator
     yields 3-tuples. They will be of one of the following forms:
 
     "window", incrementing, lastrev: stepping through a window,
     positive if walking forwards through revs, last rev in the
     sequence iterated over - use to reset state for the current window
 
     "add", rev, fns: out-of-order traversal of the given file names
     fns, which changed during revision rev - use to gather data for
     possible display
 
     "iter", rev, None: in-order traversal of the revs earlier iterated
     over with "add" - use to display data'''
 
     def increasing_windows(start, end, windowsize=8, sizelimit=512):
         if start < end:
             while start < end:
                 yield start, min(windowsize, end-start)
                 start += windowsize
                 if windowsize < sizelimit:
                     windowsize *= 2
         else:
             while start > end:
                 yield start, min(windowsize, start-end-1)
                 start -= windowsize
                 if windowsize < sizelimit:
                     windowsize *= 2
 
     m = match(repo, pats, opts)
     follow = opts.get('follow') or opts.get('follow_first')
 
     if not len(repo):
         return [], m
 
     if follow:
         defrange = '%s:0' % repo['.'].rev()
     else:
         defrange = '-1:0'
     revs = revrange(repo, opts['rev'] or [defrange])
     wanted = set()
     slowpath = m.anypats() or (m.files() and opts.get('removed'))
     fncache = {}
 
     if not slowpath and not m.files():
         # No files, no patterns.  Display all revs.
         wanted = set(revs)
     copies = []
     if not slowpath:
         # Only files, no patterns.  Check the history of each file.
         def filerevgen(filelog, node):
             cl_count = len(repo)
             if node is None:
                 last = len(filelog) - 1
             else:
                 last = filelog.rev(node)
             for i, window in increasing_windows(last, nullrev):
                 revs = []
                 for j in xrange(i - window, i + 1):
                     n = filelog.node(j)
                     revs.append((filelog.linkrev(j),
                                  follow and filelog.renamed(n)))
                 revs.reverse()
                 for rev in revs:
                     # only yield rev for which we have the changelog, it can
                     # happen while doing "hg log" during a pull or commit
                     if rev[0] < cl_count:
                         yield rev
         def iterfiles():
             for filename in m.files():
                 yield filename, None
             for filename_node in copies:
                 yield filename_node
         minrev, maxrev = min(revs), max(revs)
         for file_, node in iterfiles():
             filelog = repo.file(file_)
             if not len(filelog):
                 if node is None:
                     # A zero count may be a directory or deleted file, so
                     # try to find matching entries on the slow path.
                     if follow:
                         raise util.Abort(_('cannot follow nonexistent file: "%s"') % file_)
                     slowpath = True
                     break
                 else:
                     ui.warn(_('%s:%s copy source revision cannot be found!\n')
                             % (file_, short(node)))
                     continue
             for rev, copied in filerevgen(filelog, node):
                 if rev <= maxrev:
                     if rev < minrev:
                         break
                     fncache.setdefault(rev, [])
                     fncache[rev].append(file_)
                     wanted.add(rev)
                     if follow and copied:
                         copies.append(copied)
     if slowpath:
         if follow:
             raise util.Abort(_('can only follow copies/renames for explicit '
                                'file names'))
 
         # The slow path checks files modified in every changeset.
         def changerevgen():
             for i, window in increasing_windows(len(repo) - 1, nullrev):
                 for j in xrange(i - window, i + 1):
                     yield j, change(j)[3]
 
         for rev, changefiles in changerevgen():
             matches = filter(m, changefiles)
             if matches:
                 fncache[rev] = matches
                 wanted.add(rev)
 
     class followfilter:
         def __init__(self, onlyfirst=False):
             self.startrev = nullrev
             self.roots = []
             self.onlyfirst = onlyfirst
 
         def match(self, rev):
             def realparents(rev):
                 if self.onlyfirst:
                     return repo.changelog.parentrevs(rev)[0:1]
                 else:
                     return filter(lambda x: x != nullrev,
                                   repo.changelog.parentrevs(rev))
 
             if self.startrev == nullrev:
                 self.startrev = rev
                 return True
 
             if rev > self.startrev:
                 # forward: all descendants
                 if not self.roots:
                     self.roots.append(self.startrev)
                 for parent in realparents(rev):
                     if parent in self.roots:
                         self.roots.append(rev)
                         return True
             else:
                 # backwards: all parents
                 if not self.roots:
                     self.roots.extend(realparents(self.startrev))
                 if rev in self.roots:
                     self.roots.remove(rev)
                     self.roots.extend(realparents(rev))
                     return True
 
             return False
 
     # it might be worthwhile to do this in the iterator if the rev range
     # is descending and the prune args are all within that range
     for rev in opts.get('prune', ()):
         rev = repo.changelog.rev(repo.lookup(rev))
         ff = followfilter()
         stop = min(revs[0], revs[-1])
         for x in xrange(rev, stop-1, -1):
             if ff.match(x):
                 wanted.discard(x)
 
     def iterate():
         if follow and not m.files():
             ff = followfilter(onlyfirst=opts.get('follow_first'))
             def want(rev):
                 return ff.match(rev) and rev in wanted
         else:
             def want(rev):
                 return rev in wanted
 
         for i, window in increasing_windows(0, len(revs)):
             yield 'window', revs[0] < revs[-1], revs[-1]
             nrevs = [rev for rev in revs[i:i+window] if want(rev)]
-            for rev in util.sort(list(nrevs)):
+            for rev in sorted(nrevs):
                 fns = fncache.get(rev)
                 if not fns:
                     def fns_generator():
                         for f in change(rev)[3]:
                             if m(f):
                                 yield f
                     fns = fns_generator()
                 yield 'add', rev, fns
             for rev in nrevs:
                 yield 'iter', rev, None
     return iterate(), m
 
 def commit(ui, repo, commitfunc, pats, opts):
     '''commit the specified files or all outstanding changes'''
     date = opts.get('date')
     if date:
         opts['date'] = util.parsedate(date)
     message = logmessage(opts)
 
     # extract addremove carefully -- this function can be called from a command
     # that doesn't support addremove
     if opts.get('addremove'):
         addremove(repo, pats, opts)
 
     m = match(repo, pats, opts)
     if pats:
         modified, added, removed = repo.status(match=m)[:3]
-        files = util.sort(modified + added + removed)
+        files = sorted(modified + added + removed)
 
         def is_dir(f):
             name = f + '/'
             i = bisect.bisect(files, name)
             return i < len(files) and files[i].startswith(name)
 
         for f in m.files():
             if f == '.':
                 continue
             if f not in files:
                 rf = repo.wjoin(f)
                 rel = repo.pathto(f)
                 try:
                     mode = os.lstat(rf)[stat.ST_MODE]
                 except OSError:
                     if is_dir(f): # deleted directory ?
                         continue
                     raise util.Abort(_("file %s not found!") % rel)
                 if stat.S_ISDIR(mode):
                     if not is_dir(f):
                         raise util.Abort(_("no match under directory %s!")
                                          % rel)
                 elif not (stat.S_ISREG(mode) or stat.S_ISLNK(mode)):
                     raise util.Abort(_("can't commit %s: "
                                        "unsupported file type!") % rel)
                 elif f not in repo.dirstate:
                     raise util.Abort(_("file %s not tracked!") % rel)
         m = matchfiles(repo, files)
     try:
         return commitfunc(ui, repo, message, m, opts)
     except ValueError, inst:
         raise util.Abort(str(inst))