Merge with crew

contrib/churn.py

@@ -1,178 +1,204 b''
 # churn.py - create a graph showing who changed the most lines
 #
 # Copyright 2006 Josef "Jeff" Sipek <[e-mail]>
 #
 # This software may be used and distributed according to the terms
 # of the GNU General Public License, incorporated herein by reference.
 #
 #
 # Aliases map file format is simple one alias per line in the following
 # format:
 #
 # <alias email> <actual email>
 
-import sys
 from mercurial.i18n import gettext as _
 from mercurial import hg, mdiff, cmdutil, ui, util, templater, node
+import os, sys
+
+def get_tty_width():
+    if 'COLUMNS' in os.environ:
+        try:
+            return int(os.environ['COLUMNS'])
+        except ValueError:
+            pass
+    try:
+        import termios, fcntl, struct
+        buf = 'abcd'
+        for dev in (sys.stdout, sys.stdin):
+            try:
+                if buf != 'abcd':
+                    break
+                fd = dev.fileno()
+                if not os.isatty(fd):
+                    continue
+                buf = fcntl.ioctl(fd, termios.TIOCGWINSZ, buf)
+            except ValueError:
+                pass
+        if buf != 'abcd':
+           return struct.unpack('hh', buf)[1]
+    except ImportError:
+        pass
+    return 80
 
 def __gather(ui, repo, node1, node2):
     def dirtywork(f, mmap1, mmap2):
         lines = 0
 
         to = mmap1 and repo.file(f).read(mmap1[f]) or None
         tn = mmap2 and repo.file(f).read(mmap2[f]) or None
 
         diff = mdiff.unidiff(to, "", tn, "", f).split("\n")
 
         for line in diff:
             if not line:
                 continue # skip EOF
             if line.startswith(" "):
                 continue # context line
             if line.startswith("--- ") or line.startswith("+++ "):
                 continue # begining of diff
             if line.startswith("@@ "):
                 continue # info line
 
             # changed lines
             lines += 1
 
         return lines
 
     ##
 
     lines = 0
 
     changes = repo.status(node1, node2, None, util.always)[:5]
 
     modified, added, removed, deleted, unknown = changes
 
     who = repo.changelog.read(node2)[1]
     who = templater.email(who) # get the email of the person
 
     mmap1 = repo.manifest.read(repo.changelog.read(node1)[0])
     mmap2 = repo.manifest.read(repo.changelog.read(node2)[0])
     for f in modified:
         lines += dirtywork(f, mmap1, mmap2)
 
     for f in added:
         lines += dirtywork(f, None, mmap2)
 
     for f in removed:
         lines += dirtywork(f, mmap1, None)
 
     for f in deleted:
         lines += dirtywork(f, mmap1, mmap2)
 
     for f in unknown:
         lines += dirtywork(f, mmap1, mmap2)
 
     return (who, lines)
 
 def gather_stats(ui, repo, amap, revs=None, progress=False):
     stats = {}
 
     cl    = repo.changelog
 
     if not revs:
         revs = range(0, cl.count())
 
     nr_revs = len(revs)
     cur_rev = 0
 
     for rev in revs:
         cur_rev += 1 # next revision
 
         node2    = cl.node(rev)
         node1    = cl.parents(node2)[0]
 
         if cl.parents(node2)[1] != node.nullid:
             ui.note(_('Revision %d is a merge, ignoring...\n') % (rev,))
             continue
 
         who, lines = __gather(ui, repo, node1, node2)
 
         # remap the owner if possible
         if amap.has_key(who):
             ui.note("using '%s' alias for '%s'\n" % (amap[who], who))
             who = amap[who]
 
         if not stats.has_key(who):
             stats[who] = 0
         stats[who] += lines
 
         ui.note("rev %d: %d lines by %s\n" % (rev, lines, who))
 
         if progress:
             if int(100.0*(cur_rev - 1)/nr_revs) < int(100.0*cur_rev/nr_revs):
                 ui.write("%d%%.." % (int(100.0*cur_rev/nr_revs),))
                 sys.stdout.flush()
 
     if progress:
         ui.write("done\n")
         sys.stdout.flush()
 
     return stats
 
 def churn(ui, repo, **opts):
     "Graphs the number of lines changed"
 
     def pad(s, l):
         if len(s) < l:
             return s + " " * (l-len(s))
         return s[0:l]
 
     def graph(n, maximum, width, char):
         n = int(n * width / float(maximum))
 
         return char * (n)
 
     def get_aliases(f):
         aliases = {}
 
         for l in f.readlines():
             l = l.strip()
             alias, actual = l.split(" ")
             aliases[alias] = actual
 
         return aliases
 
     amap = {}
     aliases = opts.get('aliases')
     if aliases:
         try:
             f = open(aliases,"r")
         except OSError, e:
             print "Error: " + e
             return
 
         amap = get_aliases(f)
         f.close()
 
     revs = [int(r) for r in cmdutil.revrange(repo, opts['rev'])]
     revs.sort()
     stats = gather_stats(ui, repo, amap, revs, opts.get('progress'))
 
     # make a list of tuples (name, lines) and sort it in descending order
     ordered = stats.items()
     ordered.sort(lambda x, y: cmp(y[1], x[1]))
 
     maximum = ordered[0][1]
 
-    ui.note("Assuming 80 character terminal\n")
-    width = 80 - 1
+    width = get_tty_width()
+    ui.note(_("assuming %i character terminal\n") % width)
+    width -= 1
 
     for i in ordered:
         person = i[0]
         lines = i[1]
         print "%s %6d %s" % (pad(person, 20), lines,
                 graph(lines, maximum, width - 20 - 1 - 6 - 2 - 2, '*'))
 
 cmdtable = {
     "churn":
     (churn,
      [('r', 'rev', [], _('limit statistics to the specified revisions')),
       ('', 'aliases', '', _('file with email aliases')),
       ('', 'progress', None, _('show progress'))],
     'hg churn [-r revision range] [-a file] [--progress]'),
 }

hgext/alias.py

@@ -1,77 +1,76 b''
 # Copyright (C) 2007 Brendan Cully <[e-mail]>
 # This file is published under the GNU GPL.
 
 '''allow user-defined command aliases
 
 To use, create entries in your hgrc of the form
 
 [alias]
 mycmd = cmd --args
 '''
 
 from mercurial.cmdutil import findcmd, UnknownCommand, AmbiguousCommand
 from mercurial import commands
 
 cmdtable = {}
 
 class RecursiveCommand(Exception): pass
 
 class lazycommand(object):
     '''defer command lookup until needed, so that extensions loaded
     after alias can be aliased'''
     def __init__(self, ui, name, target):
         self._ui = ui
         self._name = name
         self._target = target
         self._cmd = None
 
     def __len__(self):
         self._resolve()
         return len(self._cmd)
 
     def __getitem__(self, key):
         self._resolve()
         return self._cmd[key]
 
     def __iter__(self):
         self._resolve()
         return self._cmd.__iter__()
 
     def _resolve(self):
         if self._cmd is not None:
             return
 
         try:
             self._cmd = findcmd(self._ui, self._target)[1]
             if self._cmd == self:
                 raise RecursiveCommand()
             if self._target in commands.norepo.split(' '):
                 commands.norepo += ' %s' % self._name
             return
         except UnknownCommand:
             msg = '*** [alias] %s: command %s is unknown' % \
                   (self._name, self._target)
         except AmbiguousCommand:
             msg = '*** [alias] %s: command %s is ambiguous' % \
                   (self._name, self._target)
         except RecursiveCommand:
             msg = '*** [alias] %s: circular dependency on %s' % \
                   (self._name, self._target)
         def nocmd(*args, **opts):
             self._ui.warn(msg + '\n')
             return 1
         nocmd.__doc__ = msg
         self._cmd = (nocmd, [], '')
         commands.norepo += ' %s' % self._name
 
 def uisetup(ui):
     for cmd, target in ui.configitems('alias'):
         if not target:
             ui.warn('*** [alias] %s: no definition\n' % cmd)
             continue
         args = target.split(' ')
         tcmd = args.pop(0)
         if args:
-            pui = ui.parentui or ui
-            pui.setconfig('defaults', cmd, ' '.join(args))
+            ui.setconfig('defaults', cmd, ' '.join(args))
         cmdtable[cmd] = lazycommand(ui, cmd, tcmd)

hgext/convert/__init__.py

@@ -1,353 +1,353 b''
 # convert.py Foreign SCM converter
 #
 # Copyright 2005-2007 Matt Mackall <[e-mail]>
 #
 # This software may be used and distributed according to the terms
 # of the GNU General Public License, incorporated herein by reference.
 
 from common import NoRepo, converter_source, converter_sink
 from cvs import convert_cvs
 from git import convert_git
 from hg import convert_mercurial
 from subversion import convert_svn
 
 import os, shutil
 from mercurial import hg, ui, util, commands
 
 commands.norepo += " convert"
 
 converters = [convert_cvs, convert_git, convert_svn, convert_mercurial]
 
 def convertsource(ui, path, **opts):
     for c in converters:
         if not hasattr(c, 'getcommit'):
             continue
         try:
             return c(ui, path, **opts)
         except NoRepo:
             pass
     raise util.Abort('%s: unknown repository type' % path)
 
 def convertsink(ui, path):
     if not os.path.isdir(path):
         raise util.Abort("%s: not a directory" % path)
     for c in converters:
         if not hasattr(c, 'putcommit'):
             continue
         try:
             return c(ui, path)
         except NoRepo:
             pass
     raise util.Abort('%s: unknown repository type' % path)
 
 class convert(object):
     def __init__(self, ui, source, dest, mapfile, opts):
 
         self.source = source
         self.dest = dest
         self.ui = ui
         self.opts = opts
         self.commitcache = {}
         self.mapfile = mapfile
         self.mapfilefd = None
         self.authors = {}
         self.authorfile = None
 
         self.map = {}
         try:
             origmapfile = open(self.mapfile, 'r')
             for l in origmapfile:
                 sv, dv = l[:-1].split()
                 self.map[sv] = dv
             origmapfile.close()
         except IOError:
             pass
 
         # Read first the dst author map if any
         authorfile = self.dest.authorfile()
         if authorfile and os.path.exists(authorfile):
             self.readauthormap(authorfile)
         # Extend/Override with new author map if necessary
         if opts.get('authors'):
             self.readauthormap(opts.get('authors'))
             self.authorfile = self.dest.authorfile()
 
     def walktree(self, heads):
         '''Return a mapping that identifies the uncommitted parents of every
         uncommitted changeset.'''
         visit = heads
         known = {}
         parents = {}
         while visit:
             n = visit.pop(0)
             if n in known or n in self.map: continue
             known[n] = 1
             self.commitcache[n] = self.source.getcommit(n)
             cp = self.commitcache[n].parents
             parents[n] = []
             for p in cp:
                 parents[n].append(p)
                 visit.append(p)
 
         return parents
 
     def toposort(self, parents):
         '''Return an ordering such that every uncommitted changeset is
         preceeded by all its uncommitted ancestors.'''
         visit = parents.keys()
         seen = {}
         children = {}
 
         while visit:
             n = visit.pop(0)
             if n in seen: continue
             seen[n] = 1
             # Ensure that nodes without parents are present in the 'children'
             # mapping.
             children.setdefault(n, [])
             for p in parents[n]:
                 if not p in self.map:
                     visit.append(p)
                 children.setdefault(p, []).append(n)
 
         s = []
         removed = {}
         visit = children.keys()
         while visit:
             n = visit.pop(0)
             if n in removed: continue
             dep = 0
             if n in parents:
                 for p in parents[n]:
                     if p in self.map: continue
                     if p not in removed:
                         # we're still dependent
                         visit.append(n)
                         dep = 1
                         break
 
             if not dep:
                 # all n's parents are in the list
                 removed[n] = 1
                 if n not in self.map:
                     s.append(n)
                 if n in children:
                     for c in children[n]:
                         visit.insert(0, c)
 
         if self.opts.get('datesort'):
             depth = {}
             for n in s:
                 depth[n] = 0
                 pl = [p for p in self.commitcache[n].parents
                       if p not in self.map]
                 if pl:
                     depth[n] = max([depth[p] for p in pl]) + 1
 
             s = [(depth[n], self.commitcache[n].date, n) for n in s]
             s.sort()
             s = [e[2] for e in s]
 
         return s
 
     def mapentry(self, src, dst):
         if self.mapfilefd is None:
             try:
                 self.mapfilefd = open(self.mapfile, "a")
             except IOError, (errno, strerror):
                 raise util.Abort("Could not open map file %s: %s, %s\n" % (self.mapfile, errno, strerror))
         self.map[src] = dst
         self.mapfilefd.write("%s %s\n" % (src, dst))
         self.mapfilefd.flush()
 
     def writeauthormap(self):
         authorfile = self.authorfile
         if authorfile:
            self.ui.status('Writing author map file %s\n' % authorfile)
            ofile = open(authorfile, 'w+')
            for author in self.authors:
                ofile.write("%s=%s\n" % (author, self.authors[author]))
            ofile.close()
 
     def readauthormap(self, authorfile):
         afile = open(authorfile, 'r')
         for line in afile:
             try:
                 srcauthor = line.split('=')[0].strip()
                 dstauthor = line.split('=')[1].strip()
                 if srcauthor in self.authors and dstauthor != self.authors[srcauthor]:
                     self.ui.status(
                         'Overriding mapping for author %s, was %s, will be %s\n'
                         % (srcauthor, self.authors[srcauthor], dstauthor))
                 else:
                     self.ui.debug('Mapping author %s to %s\n'
                                   % (srcauthor, dstauthor))
                     self.authors[srcauthor] = dstauthor
             except IndexError:
                 self.ui.warn(
                     'Ignoring bad line in author file map %s: %s\n'
                     % (authorfile, line))
         afile.close()
 
     def copy(self, rev):
         c = self.commitcache[rev]
         files = self.source.getchanges(rev)
-        
+
         do_copies = (hasattr(c, 'copies') and hasattr(self.dest, 'copyfile'))
 
         for f, v in files:
             try:
                 data = self.source.getfile(f, v)
             except IOError, inst:
                 self.dest.delfile(f)
             else:
                 e = self.source.getmode(f, v)
                 self.dest.putfile(f, e, data)
                 if do_copies:
                     if f in c.copies:
                         # Merely marks that a copy happened.
                         self.dest.copyfile(c.copies[f], f)
 
 
         r = [self.map[v] for v in c.parents]
         f = [f for f, v in files]
         newnode = self.dest.putcommit(f, r, c)
         self.mapentry(rev, newnode)
 
     def convert(self):
         try:
             self.source.setrevmap(self.map)
             self.ui.status("scanning source...\n")
             heads = self.source.getheads()
             parents = self.walktree(heads)
             self.ui.status("sorting...\n")
             t = self.toposort(parents)
             num = len(t)
             c = None
 
             self.ui.status("converting...\n")
             for c in t:
                 num -= 1
                 desc = self.commitcache[c].desc
                 if "\n" in desc:
                     desc = desc.splitlines()[0]
                 author = self.commitcache[c].author
                 author = self.authors.get(author, author)
                 self.commitcache[c].author = author
                 self.ui.status("%d %s\n" % (num, desc))
                 self.copy(c)
 
             tags = self.source.gettags()
             ctags = {}
             for k in tags:
                 v = tags[k]
                 if v in self.map:
                     ctags[k] = self.map[v]
 
             if c and ctags:
                 nrev = self.dest.puttags(ctags)
                 # write another hash correspondence to override the previous
                 # one so we don't end up with extra tag heads
                 if nrev:
                     self.mapentry(c, nrev)
 
             self.writeauthormap()
         finally:
             self.cleanup()
 
     def cleanup(self):
        if self.mapfilefd:
            self.mapfilefd.close()
 
 def _convert(ui, src, dest=None, mapfile=None, **opts):
-    '''Convert a foreign SCM repository to a Mercurial one.
+    """Convert a foreign SCM repository to a Mercurial one.
 
     Accepted source formats:
     - GIT
     - CVS
     - SVN
 
     Accepted destination formats:
     - Mercurial
 
     If no revision is given, all revisions will be converted. Otherwise,
     convert will only import up to the named revision (given in a format
     understood by the source).
 
     If no destination directory name is specified, it defaults to the
     basename of the source with '-hg' appended.  If the destination
     repository doesn't exist, it will be created.
 
     If <mapfile> isn't given, it will be put in a default location
     (<dest>/.hg/shamap by default).  The <mapfile> is a simple text
     file that maps each source commit ID to the destination ID for
     that revision, like so:
     <source ID> <destination ID>
 
     If the file doesn't exist, it's automatically created.  It's updated
     on each commit copied, so convert-repo can be interrupted and can
     be run repeatedly to copy new commits.
 
     The [username mapping] file is a simple text file that maps each source
     commit author to a destination commit author. It is handy for source SCMs
     that use unix logins to identify authors (eg: CVS). One line per author
     mapping and the line format is:
     srcauthor=whatever string you want
-    '''
+    """
 
     util._encoding = 'UTF-8'
 
     if not dest:
         dest = hg.defaultdest(src) + "-hg"
         ui.status("assuming destination %s\n" % dest)
 
     # Try to be smart and initalize things when required
     created = False
     if os.path.isdir(dest):
         if len(os.listdir(dest)) > 0:
             try:
                 hg.repository(ui, dest)
                 ui.status("destination %s is a Mercurial repository\n" % dest)
             except hg.RepoError:
                 raise util.Abort(
                     "destination directory %s is not empty.\n"
                     "Please specify an empty directory to be initialized\n"
                     "or an already initialized mercurial repository"
                     % dest)
         else:
             ui.status("initializing destination %s repository\n" % dest)
             hg.repository(ui, dest, create=True)
             created = True
     elif os.path.exists(dest):
         raise util.Abort("destination %s exists and is not a directory" % dest)
     else:
         ui.status("initializing destination %s repository\n" % dest)
         hg.repository(ui, dest, create=True)
         created = True
 
     destc = convertsink(ui, dest)
 
     try:
         srcc = convertsource(ui, src, rev=opts.get('rev'))
     except Exception:
         if created:
             shutil.rmtree(dest, True)
         raise
 
     if not mapfile:
         try:
             mapfile = destc.mapfile()
         except:
             mapfile = os.path.join(destc, "map")
 
     c = convert(ui, srcc, destc, mapfile, opts)
     c.convert()
 
 cmdtable = {
     "convert":
         (_convert,
          [('A', 'authors', '', 'username mapping filename'),
           ('r', 'rev', '', 'import up to target revision REV'),
           ('', 'datesort', None, 'try to sort changesets by date')],
          'hg convert [OPTION]... SOURCE [DEST [MAPFILE]]'),
 }

hgext/convert/common.py

@@ -1,121 +1,121 b''
 # common code for the convert extension
 
 class NoRepo(Exception): pass
 
 class commit(object):
     def __init__(self, **parts):
         self.rev = None
         self.branch = None
 
         for x in "author date desc parents".split():
             if not x in parts:
                 raise util.Abort("commit missing field %s" % x)
         self.__dict__.update(parts)
         if not self.desc or self.desc.isspace():
             self.desc = '*** empty log message ***'
 
 class converter_source(object):
     """Conversion source interface"""
 
     def __init__(self, ui, path, rev=None):
         """Initialize conversion source (or raise NoRepo("message")
         exception if path is not a valid repository)"""
         self.ui = ui
         self.path = path
         self.rev = rev
 
         self.encoding = 'utf-8'
 
     def setrevmap(self, revmap):
         """set the map of already-converted revisions"""
         pass
 
     def getheads(self):
         """Return a list of this repository's heads"""
         raise NotImplementedError()
 
     def getfile(self, name, rev):
         """Return file contents as a string"""
         raise NotImplementedError()
 
     def getmode(self, name, rev):
         """Return file mode, eg. '', 'x', or 'l'"""
         raise NotImplementedError()
 
     def getchanges(self, version):
         """Return sorted list of (filename, id) tuples for all files changed in rev.
 
         id just tells us which revision to return in getfile(), e.g. in
         git it's an object hash."""
         raise NotImplementedError()
 
     def getcommit(self, version):
         """Return the commit object for version"""
         raise NotImplementedError()
 
     def gettags(self):
         """Return the tags as a dictionary of name: revision"""
         raise NotImplementedError()
 
     def recode(self, s, encoding=None):
         if not encoding:
             encoding = self.encoding or 'utf-8'
-            
+
         try:
             return s.decode(encoding).encode("utf-8")
         except:
             try:
                 return s.decode("latin-1").encode("utf-8")
             except:
                 return s.decode(encoding, "replace").encode("utf-8")
 
 class converter_sink(object):
     """Conversion sink (target) interface"""
 
     def __init__(self, ui, path):
         """Initialize conversion sink (or raise NoRepo("message")
         exception if path is not a valid repository)"""
         raise NotImplementedError()
 
     def getheads(self):
         """Return a list of this repository's heads"""
         raise NotImplementedError()
 
     def mapfile(self):
         """Path to a file that will contain lines
         source_rev_id sink_rev_id
         mapping equivalent revision identifiers for each system."""
         raise NotImplementedError()
 
     def authorfile(self):
         """Path to a file that will contain lines
         srcauthor=dstauthor
         mapping equivalent authors identifiers for each system."""
         return None
 
     def putfile(self, f, e, data):
         """Put file for next putcommit().
         f: path to file
         e: '', 'x', or 'l' (regular file, executable, or symlink)
         data: file contents"""
         raise NotImplementedError()
 
     def delfile(self, f):
         """Delete file for next putcommit().
         f: path to file"""
         raise NotImplementedError()
 
     def putcommit(self, files, parents, commit):
         """Create a revision with all changed files listed in 'files'
         and having listed parents. 'commit' is a commit object containing
         at a minimum the author, date, and message for this changeset.
         Called after putfile() and delfile() calls. Note that the sink
         repository is not told to update itself to a particular revision
         (or even what that revision would be) before it receives the
         file data."""
         raise NotImplementedError()
 
     def puttags(self, tags):
         """Put tags into sink.
         tags: {tagname: sink_rev_id, ...}"""
         raise NotImplementedError()

hgext/convert/subversion.py

@@ -1,589 +1,667 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")
+#
+# Set these in a hgrc, or on the command line as follows:
+#
+#   hg convert --config convert.svn.trunk=wackoname [...]
 
-import pprint
 import locale
-
+import os
+import cPickle as pickle
 from mercurial import util
 
 # 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, commit, converter_source
 
 try:
     from svn.core import SubversionException, Pool
     import svn.core
     import svn.ra
     import svn.delta
     import svn
     import transport
 except ImportError:
     pass
 
 class CompatibilityException(Exception): pass
 
+class changedpath(object):
+    def __init__(self, p):
+        self.copyfrom_path = p.copyfrom_path
+        self.copyfrom_rev = p.copyfrom_rev
+        self.action = p.action
+
 # SVN conversion code stolen from bzr-svn and tailor
 class convert_svn(converter_source):
     def __init__(self, ui, url, rev=None):
         super(convert_svn, self).__init__(ui, url, rev=rev)
 
         try:
             SubversionException
         except NameError:
             msg = 'subversion python bindings could not be loaded\n'
             ui.warn(msg)
             raise NoRepo(msg)
 
         self.encoding = locale.getpreferredencoding()
         self.lastrevs = {}
 
         latest = None
         if rev:
             try:
                 latest = int(rev)
             except ValueError:
                 raise util.Abort('svn: revision %s is not an integer' % rev)
         try:
             # Support file://path@rev syntax. Useful e.g. to convert
             # deleted branches.
-            url, latest = url.rsplit("@", 1)
-            latest = int(latest)
+            at = url.rfind('@')
+            if at >= 0:
+                latest = int(url[at+1:])
+                url = url[:at]
         except ValueError, e:
             pass
         self.url = url
         self.encoding = 'UTF-8' # Subversion is always nominal UTF-8
         try:
-            self.transport = transport.SvnRaTransport(url = url)
+            self.transport = transport.SvnRaTransport(url=url)
             self.ra = self.transport.ra
-            self.ctx = svn.client.create_context()
+            self.ctx = self.transport.client
             self.base = svn.ra.get_repos_root(self.ra)
             self.module = self.url[len(self.base):]
             self.modulemap = {} # revision, module
             self.commits = {}
             self.files = {}
             self.uuid = svn.ra.get_uuid(self.ra).decode(self.encoding)
         except SubversionException, e:
             raise NoRepo("couldn't open SVN repo %s" % url)
 
         try:
             self.get_blacklist()
         except IOError, e:
             pass
 
         self.last_changed = self.latest(self.module, latest)
 
         self.head = self.revid(self.last_changed)
 
     def setrevmap(self, revmap):
         lastrevs = {}
         for revid in revmap.keys():
             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:
+            return svn.client.ls(self.url.rstrip('/') + '/' + path,
+                                 optrev, False, self.ctx)
+        except SubversionException, err:
+            return []
+
     def getheads(self):
         # detect standard /branches, /tags, /trunk layout
         optrev = svn.core.svn_opt_revision_t()
         optrev.kind = svn.core.svn_opt_revision_number
         optrev.value.number = self.last_changed
         rpath = self.url.strip('/')
-        paths = svn.client.ls(rpath, optrev, False, self.ctx)
-        if 'branches' in paths and 'trunk' in paths:
-            self.module += '/trunk'
+        cfgtrunk = self.ui.config('convert', 'svn.trunk')
+        cfgbranches = self.ui.config('convert', 'svn.branches')
+        trunk = (cfgtrunk or 'trunk').strip('/')
+        branches = (cfgbranches or 'branches').strip('/')
+        if self.exists(trunk, optrev) and self.exists(branches, optrev):
+            self.ui.note('found trunk at %r and branches at %r\n' %
+                         (trunk, branches))
+            oldmodule = self.module
+            self.module += '/' + trunk
             lt = self.latest(self.module, self.last_changed)
             self.head = self.revid(lt)
             self.heads = [self.head]
-            branches = svn.client.ls(rpath + '/branches', optrev, False, self.ctx)
-            for branch in branches.keys():
-                module = '/branches/' + branch
+            branchnames = svn.client.ls(rpath + '/' + branches, optrev, False,
+                                        self.ctx)
+            for branch in branchnames.keys():
+                if oldmodule:
+                    module = '/' + oldmodule + '/' + branches + '/' + branch
+                else:
+                    module = '/' + branches + '/' + branch
                 brevnum = self.latest(module, self.last_changed)
                 brev = self.revid(brevnum, module)
                 self.ui.note('found branch %s at %d\n' % (branch, brevnum))
                 self.heads.append(brev)
+        elif cfgtrunk or cfgbranches:
+            raise util.Abort(_('trunk/branch layout expected, '
+                               'but not found'))
         else:
+            self.ui.note('working with one branch\n')
             self.heads = [self.head]
         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):        
+    def getmode(self, file, rev):
         return self.modecache[(file, rev)]
 
     def getchanges(self, rev):
         self.modecache = {}
         files = self.files[rev]
         cl = files
         cl.sort()
         # caller caches the result, so free it here to release memory
         del self.files[rev]
         return cl
 
     def getcommit(self, rev):
         if rev not in self.commits:
             uuid, module, revnum = self.revsplit(rev)
             self.module = module
             self.reparent(module)
             stop = self.lastrevs.get(module, 0)
             self._fetch_revisions(from_revnum=revnum, to_revnum=stop)
         commit = self.commits[rev]
         # caller caches the result, so free it here to release memory
         del self.commits[rev]
         return commit
 
+    def get_log(self, paths, start, end, limit=0, discover_changed_paths=True,
+                strict_node_history=False):
+        '''wrapper for svn.ra.get_log.
+        on a large repository, svn.ra.get_log pins huge amounts of
+        memory that cannot be recovered.  work around it by forking
+        and writing results over a pipe.'''
+
+        def child(fp):
+            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=self.url)
+                svn.ra.get_log(t.ra, paths, start, end, limit,
+                               discover_changed_paths,
+                               strict_node_history,
+                               receiver)
+            except SubversionException, (_, num):
+                self.ui.print_exc()
+                pickle.dump(num, fp, protocol)
+            else:
+                pickle.dump(None, fp, protocol)
+            fp.close()
+
+        def parent(fp):
+            while True:
+                entry = pickle.load(fp)
+                try:
+                    orig_paths, revnum, author, date, message = entry
+                except:
+                    if entry is None:
+                        break
+                    raise SubversionException("child raised exception", entry)
+                yield entry
+
+        rfd, wfd = os.pipe()
+        pid = os.fork()
+        if pid:
+            os.close(wfd)
+            for p in parent(os.fdopen(rfd, 'rb')):
+                yield p
+            ret = os.waitpid(pid, 0)[1]
+            if ret:
+                raise util.Abort(_('get_log %s') % util.explain_exit(ret))
+        else:
+            os.close(rfd)
+            child(os.fdopen(wfd, 'wb'))
+            os._exit(0)
+
     def gettags(self):
         tags = {}
-        def parselogentry(*arg, **args):
-            orig_paths, revnum, author, date, message, pool = arg
-            for path in orig_paths:
-                if not path.startswith('/tags/'):
-                    continue
-                ent = orig_paths[path]
-                source = ent.copyfrom_path
-                rev = ent.copyfrom_rev
-                tag = path.split('/', 2)[2]
-                tags[tag] = self.revid(rev, module=source)
-
         start = self.revnum(self.head)
         try:
-            svn.ra.get_log(self.ra, ['/tags'], 0, start, 0, True, False,
-                           parselogentry)
-            return tags
-        except SubversionException:
+            for entry in self.get_log(['/tags'], 0, start):
+                orig_paths, revnum, author, date, message = entry
+                for path in orig_paths:
+                    if not path.startswith('/tags/'):
+                        continue
+                    ent = orig_paths[path]
+                    source = ent.copyfrom_path
+                    rev = ent.copyfrom_rev
+                    tag = path.split('/', 2)[2]
+                    tags[tag] = self.revid(rev, module=source)
+        except SubversionException, (_, num):
             self.ui.note('no tags found at revision %d\n' % start)
-            return {}
+        return tags
 
     # -- helper functions --
 
     def revid(self, revnum, module=None):
         if not module:
             module = self.module
         return (u"svn:%s%s@%s" % (self.uuid, module, revnum)).decode(self.encoding)
 
     def revnum(self, rev):
         return int(rev.split('@')[-1])
 
     def revsplit(self, rev):
         url, revnum = rev.encode(self.encoding).split('@', 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 revision affecting path, up to stop'
         if not stop:
             stop = svn.ra.get_latest_revnum(self.ra)
         try:
             self.reparent('')
             dirent = svn.ra.stat(self.ra, path.strip('/'), stop)
             self.reparent(self.module)
         except SubversionException:
             dirent = None
         if not dirent:
-            raise util.Abort('%s not found up to revision %d' \
-                             % (path, stop))
+            print self.base, path
+            raise util.Abort('%s not found up to revision %d' % (path, stop))
 
         return dirent.created_rev
 
     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, e:
                     pass # not an integer or a comment
 
     def is_blacklisted(self, svn_rev):
         return svn_rev in self.blacklist
 
     def reparent(self, module):
         svn_url = self.base + module
         self.ui.debug("reparent to %s\n" % svn_url.encode(self.encoding))
         svn.ra.reparent(self.ra, svn_url.encode(self.encoding))
 
     def _fetch_revisions(self, from_revnum = 0, to_revnum = 347):
         def get_entry_from_path(path, 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[len(module):]
                 if relative.startswith('/'):
                     return relative[1:]
                 else:
                     return relative
 
             # The path is outside our tracked tree...
             self.ui.debug('Ignoring %r since it is not under %r\n' % (path, module))
             return None
 
-        received = []
-        # svn.ra.get_log requires no other calls to the ra until it completes,
-        # so we just collect the log entries and parse them afterwards
-        def receivelog(*arg, **args):
-            received.append(arg)
-
         self.child_cset = None
-        def parselogentry(*arg, **args):
-            orig_paths, revnum, author, date, message, pool = arg
-
-            if self.is_blacklisted(revnum):
-                self.ui.note('skipping blacklisted revision %d\n' % revnum)
-                return
-
-            self.ui.debug("parsing revision %d\n" % revnum)
-           
-            if orig_paths is None:
-                self.ui.debug('revision %d has no entries\n' % revnum)
-                return
+        def parselogentry(orig_paths, revnum, author, date, message):
+            self.ui.debug("parsing revision %d (%d changes)\n" %
+                          (revnum, len(orig_paths)))
 
             if revnum in self.modulemap:
                 new_module = self.modulemap[revnum]
                 if new_module != self.module:
                     self.module = new_module
                     self.reparent(self.module)
 
             copyfrom = {} # Map of entrypath, revision for finding source of deleted revisions.
             copies = {}
             entries = []
             rev = self.revid(revnum)
             parents = []
 
             # branch log might return entries for a parent we already have
             if (rev in self.commits or
                 (revnum < self.lastrevs.get(self.module, 0))):
                 return
 
             try:
                 branch = self.module.split("/")[-1]
                 if branch == 'trunk':
                     branch = ''
             except IndexError:
                 branch = None
 
-            paths = orig_paths.keys()
-            paths.sort()
-            for path in paths:
+            orig_paths = orig_paths.items()
+            orig_paths.sort()
+            for path, ent in orig_paths:
                 # self.ui.write("path %s\n" % path)
                 if path == self.module: # Follow branching back in history
-                    ent = orig_paths[path]
                     if ent:
                         if ent.copyfrom_path:
                             # ent.copyfrom_rev may not be the actual last revision
                             prev = self.latest(ent.copyfrom_path, ent.copyfrom_rev)
                             self.modulemap[prev] = ent.copyfrom_path
                             parents = [self.revid(prev, ent.copyfrom_path)]
                             self.ui.note('found parent of branch %s at %d: %s\n' % \
                                          (self.module, prev, ent.copyfrom_path))
                         else:
                             self.ui.debug("No copyfrom path, don't know what to do.\n")
                             # Maybe it was added and there is no more history.
                 entrypath = get_entry_from_path(path, module=self.module)
                 # self.ui.write("entrypath %s\n" % entrypath)
                 if entrypath is None:
                     # Outside our area of interest
                     self.ui.debug("boring@%s: %s\n" % (revnum, path))
                     continue
                 entry = entrypath.decode(self.encoding)
-                ent = orig_paths[path]
 
                 kind = svn.ra.check_path(self.ra, entrypath, revnum)
                 if kind == svn.core.svn_node_file:
                     if ent.copyfrom_path:
                         copyfrom_path = get_entry_from_path(ent.copyfrom_path)
                         if copyfrom_path:
                             self.ui.debug("Copied to %s from %s@%s\n" % (entry, copyfrom_path, ent.copyfrom_rev))
                             # It's probably important for hg that the source
                             # exists in the revision's parent, not just the
                             # ent.copyfrom_rev
                             fromkind = svn.ra.check_path(self.ra, copyfrom_path, ent.copyfrom_rev)
                             if fromkind != 0:
                                 copies[self.recode(entry)] = self.recode(copyfrom_path)
                     entries.append(self.recode(entry))
                 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
                     if parents:
                         uuid, old_module, fromrev = self.revsplit(parents[0])
                     else:
                         fromrev = revnum - 1
                         # might always need to be revnum - 1 in these 3 lines?
                         old_module = self.modulemap.get(fromrev, self.module)
 
                     basepath = old_module + "/" + get_entry_from_path(path, module=self.module)
                     entrypath = old_module + "/" + get_entry_from_path(path, module=self.module)
 
                     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))
 
                     fromkind = svn.ra.check_path(self.ra, entrypath, fromrev)
                     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 
+                        # 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, 
+                            # cause problems if instead of revnum -1,
                             # we have to look in (copyfrom_path, revnum - 1)
                             entrypath = get_entry_from_path("/" + 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.
                     # 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 = self._find_children(path, revnum)
                     children.sort()
                     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, 
+                        # cause problems if instead of revnum -1,
                         # we have to look in (copyfrom_path, revnum - 1)
                         entrypath = get_entry_from_path("/" + child, module=self.module)
                         # print child, self.module, entrypath
                         if entrypath:
                             # Need to filter out directories here...
                             kind = svn.ra.check_path(self.ra, 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
 
                     # Can do this with the copy command "hg copy"
                     # if ent.copyfrom_path:
                     #     copyfrom_entry = get_entry_from_path(ent.copyfrom_path.decode(self.encoding),
                     #             module=self.module)
                     #     copyto_entry = entrypath
                     #
                     #     print "copy directory", copyfrom_entry, 'to', copyto_entry
                     #
                     #     copies.append((copyfrom_entry, copyto_entry))
 
                     if ent.copyfrom_path:
                         copyfrom_path = ent.copyfrom_path.decode(self.encoding)
                         copyfrom_entry = get_entry_from_path(copyfrom_path, module=self.module)
                         if copyfrom_entry:
                             copyfrom[path] = ent
                             self.ui.debug("mark %s came from %s\n" % (path, copyfrom[path]))
 
                             # Good, /probably/ a regular copy. Really should check
                             # to see whether the parent revision actually contains
                             # the directory in question.
                             children = self._find_children(self.recode(copyfrom_path), ent.copyfrom_rev)
                             children.sort()
                             for child in children:
                                 entrypath = get_entry_from_path("/" + child, module=self.module)
                                 if entrypath:
                                     entry = entrypath.decode(self.encoding)
                                     # print "COPY COPY From", copyfrom_entry, entry
                                     copyto_path = path + entry[len(copyfrom_entry):]
                                     copyto_entry =  get_entry_from_path(copyto_path, module=self.module)
                                     # print "COPY", entry, "COPY To", copyto_entry
                                     copies[self.recode(copyto_entry)] = self.recode(entry)
                                     # copy from quux splort/quuxfile
 
             self.modulemap[revnum] = self.module # track backwards in time
             # a list of (filename, id) where id lets us retrieve the file.
-            # eg in git, id is the object hash. for svn it'll be the 
+            # eg in git, id is the object hash. for svn it'll be the
             self.files[rev] = zip(entries, [rev] * len(entries))
             if not entries:
                 return
 
             # Example SVN datetime. Includes microseconds.
             # ISO-8601 conformant
             # '2007-01-04T17:35:00.902377Z'
             date = util.parsedate(date[:18] + " UTC", ["%Y-%m-%dT%H:%M:%S"])
 
             log = message and self.recode(message)
             author = author and self.recode(author) or ''
 
             cset = commit(author=author,
-                          date=util.datestr(date), 
-                          desc=log, 
+                          date=util.datestr(date),
+                          desc=log,
                           parents=parents,
                           copies=copies,
                           branch=branch,
                           rev=rev.encode('utf-8'))
 
             self.commits[rev] = cset
             if self.child_cset and not self.child_cset.parents:
                 self.child_cset.parents = [rev]
             self.child_cset = cset
 
-        self.ui.note('fetching revision log for "%s" from %d to %d\n' % \
+        self.ui.note('fetching revision log for "%s" from %d to %d\n' %
                      (self.module, from_revnum, to_revnum))
 
         try:
             discover_changed_paths = True
             strict_node_history = False
-            svn.ra.get_log(self.ra, [self.module], from_revnum, to_revnum, 0,
-                           discover_changed_paths, strict_node_history,
-                           receivelog)
-            for entry in received:
-                parselogentry(*entry)
+            for entry in self.get_log([self.module], from_revnum, to_revnum):
+                orig_paths, revnum, author, date, message = entry
+                if self.is_blacklisted(revnum):
+                    self.ui.note('skipping blacklisted revision %d\n' % revnum)
+                    continue
+                if orig_paths is None:
+                    self.ui.debug('revision %d has no entries\n' % revnum)
+                    continue
+                parselogentry(orig_paths, revnum, author, date, message)
         except SubversionException, (_, num):
             if num == svn.core.SVN_ERR_FS_NO_SUCH_REVISION:
-                raise NoSuchRevision(branch=self, 
+                raise NoSuchRevision(branch=self,
                     revision="Revision number %d" % to_revnum)
             raise
 
     def _getfile(self, file, rev):
         io = StringIO()
         # TODO: ra.get_file transmits the whole file instead of diffs.
         mode = ''
         try:
             revnum = self.revnum(rev)
             if self.module != self.modulemap[revnum]:
                 self.module = self.modulemap[revnum]
                 self.reparent(self.module)
             info = svn.ra.get_file(self.ra, file, revnum, io)
             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
         data = io.getvalue()
         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("/")
 
         def _find_children_fallback(path, revnum):
             # SWIG python bindings for getdir are broken up to at least 1.4.3
             pool = Pool()
             optrev = svn.core.svn_opt_revision_t()
             optrev.kind = svn.core.svn_opt_revision_number
             optrev.value.number = revnum
             rpath = '/'.join([self.base, path]).strip('/')
             return ['%s/%s' % (path, x) for x in svn.client.ls(rpath, optrev, True, self.ctx, pool).keys()]
 
         if hasattr(self, '_find_children_fallback'):
             return _find_children_fallback(path, revnum)
 
         self.reparent("/" + path)
         pool = Pool()
 
         children = []
         def find_children_inner(children, path, revnum = revnum):
             if hasattr(svn.ra, 'get_dir2'): # Since SVN 1.4
                 fields = 0xffffffff # Binding does not provide SVN_DIRENT_ALL
                 getdir = svn.ra.get_dir2(self.ra, path, revnum, fields, pool)
             else:
                 getdir = svn.ra.get_dir(self.ra, path, revnum, pool)
             if type(getdir) == dict:
                 # python binding for getdir is broken up to at least 1.4.3
                 raise CompatibilityException()
             dirents = getdir[0]
             if type(dirents) == int:
                 # got here once due to infinite recursion bug
-                # pprint.pprint(getdir)
                 return
             c = dirents.keys()
             c.sort()
             for child in c:
                 dirent = dirents[child]
                 if dirent.kind == svn.core.svn_node_dir:
                     find_children_inner(children, (path + "/" + child).strip("/"))
                 else:
                     children.append((path + "/" + child).strip("/"))
 
         try:
             find_children_inner(children, "")
         except CompatibilityException:
             self._find_children_fallback = True
             self.reparent(self.module)
             return _find_children_fallback(path, revnum)
 
         self.reparent(self.module)
         return [path + "/" + c for c in children]

hgext/convert/transport.py

@@ -1,134 +1,125 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2007 Daniel Holth <[e-mail]>
 # This is a stripped-down version of the original bzr-svn transport.py,
 # Copyright (C) 2006 Jelmer Vernooij <[e-mail]>
 
 # 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 cStringIO import StringIO
 import os
 from tempfile import mktemp
 
 from svn.core import SubversionException, Pool
 import svn.ra
+import svn.client
 import svn.core
 
-# Some older versions of the Python bindings need to be 
+# Some older versions of the Python bindings need to be
 # explicitly initialized. But what we want to do probably
 # won't work worth a darn against those libraries anyway!
 svn.ra.initialize()
 
 svn_config = svn.core.svn_config_get_config(None)
 
 
 def _create_auth_baton(pool):
     """Create a Subversion authentication baton. """
     import svn.client
     # Give the client context baton a suite of authentication
     # providers.h
     providers = [
         svn.client.get_simple_provider(pool),
         svn.client.get_username_provider(pool),
         svn.client.get_ssl_client_cert_file_provider(pool),
         svn.client.get_ssl_client_cert_pw_file_provider(pool),
         svn.client.get_ssl_server_trust_file_provider(pool),
         ]
     return svn.core.svn_auth_open(providers, pool)
 
-
-#    # The SVN libraries don't like trailing slashes...
-#    return url.rstrip('/')
-
-
-class SvnRaCallbacks(svn.ra.callbacks2_t):
-    """Remote access callbacks implementation for bzr-svn."""
-    def __init__(self, pool):
-        svn.ra.callbacks2_t.__init__(self)
-        self.auth_baton = _create_auth_baton(pool)
-        self.pool = pool
-    
-    def open_tmp_file(self, pool):
-        return mktemp(prefix='tailor-svn')
-
 class NotBranchError(SubversionException):
     pass
 
 class SvnRaTransport(object):
     """
     Open an ra connection to a Subversion repository.
     """
     def __init__(self, url="", ra=None):
         self.pool = Pool()
         self.svn_url = url
+        self.username = ''
+        self.password = ''
 
         # Only Subversion 1.4 has reparent()
         if ra is None or not hasattr(svn.ra, 'reparent'):
-            self.callbacks = SvnRaCallbacks(self.pool)
+            self.client = svn.client.create_context(self.pool)
+            ab = _create_auth_baton(self.pool)
+            if False:
+                svn.core.svn_auth_set_parameter(
+                    ab, svn.core.SVN_AUTH_PARAM_DEFAULT_USERNAME, self.username)
+                svn.core.svn_auth_set_parameter(
+                    ab, svn.core.SVN_AUTH_PARAM_DEFAULT_PASSWORD, self.password)
+            self.client.auth_baton = ab
+            self.client.config = svn_config
             try:
-                ver = svn.ra.version()
-                try: # Older SVN bindings
-                    self.ra = svn.ra.open2(self.svn_url.encode('utf8'), self.callbacks, None, svn_config, None)
-                except TypeError, e:
-                    self.ra = svn.ra.open2(self.svn_url.encode('utf8'), self.callbacks, svn_config, None)
+                self.ra = svn.client.open_ra_session(
+                    self.svn_url.encode('utf8'),
+                    self.client, self.pool)
             except SubversionException, (_, num):
-                if num == svn.core.SVN_ERR_RA_ILLEGAL_URL:
-                    raise NotBranchError(url)
-                if num == svn.core.SVN_ERR_RA_LOCAL_REPOS_OPEN_FAILED:
-                    raise NotBranchError(url)
-                if num == svn.core.SVN_ERR_BAD_URL:
+                if num in (svn.core.SVN_ERR_RA_ILLEGAL_URL,
+                           svn.core.SVN_ERR_RA_LOCAL_REPOS_OPEN_FAILED,
+                           svn.core.SVN_ERR_BAD_URL):
                     raise NotBranchError(url)
                 raise
-
         else:
             self.ra = ra
             svn.ra.reparent(self.ra, self.svn_url.encode('utf8'))
 
     class Reporter:
         def __init__(self, (reporter, report_baton)):
             self._reporter = reporter
             self._baton = report_baton
 
         def set_path(self, path, revnum, start_empty, lock_token, pool=None):
             svn.ra.reporter2_invoke_set_path(self._reporter, self._baton,
                         path, revnum, start_empty, lock_token, pool)
 
         def delete_path(self, path, pool=None):
             svn.ra.reporter2_invoke_delete_path(self._reporter, self._baton,
                     path, pool)
 
         def link_path(self, path, url, revision, start_empty, lock_token,
                       pool=None):
             svn.ra.reporter2_invoke_link_path(self._reporter, self._baton,
                     path, url, revision, start_empty, lock_token,
                     pool)
 
         def finish_report(self, pool=None):
             svn.ra.reporter2_invoke_finish_report(self._reporter,
                     self._baton, pool)
 
         def abort_report(self, pool=None):
             svn.ra.reporter2_invoke_abort_report(self._reporter,
                     self._baton, pool)
 
     def do_update(self, revnum, path, *args, **kwargs):
         return self.Reporter(svn.ra.do_update(self.ra, revnum, path, *args, **kwargs))
 
     def clone(self, offset=None):
         """See Transport.clone()."""
         if offset is None:
             return self.__class__(self.base)
 
         return SvnRaTransport(urlutils.join(self.base, offset), ra=self.ra)

hgext/purge.py

@@ -1,168 +1,168 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 hg, util
 from mercurial.i18n import _
 import os
 
-def dopurge(ui, repo, dirs=None, act=True, ignored=False, 
+def dopurge(ui, repo, dirs=None, act=True, ignored=False,
             abort_on_err=False, eol='\n',
             force=False, include=None, exclude=None):
     def error(msg):
         if abort_on_err:
             raise util.Abort(msg)
         else:
             ui.warn(_('warning: %s\n') % msg)
 
     def remove(remove_func, name):
         if act:
             try:
                 remove_func(os.path.join(repo.root, name))
             except OSError, e:
                 error(_('%s cannot be removed') % name)
         else:
             ui.write('%s%s' % (name, eol))
 
     directories = []
     files = []
     missing = []
     roots, match, anypats = util.cmdmatcher(repo.root, repo.getcwd(), dirs,
                                             include, exclude)
     for src, f, st in repo.dirstate.statwalk(files=roots, match=match,
                                              ignored=ignored, directories=True):
         if src == 'd':
             directories.append(f)
         elif src == 'm':
             missing.append(f)
         elif src == 'f' and f not in repo.dirstate:
             files.append(f)
 
     _check_missing(ui, repo, missing, force)
 
     directories.sort()
 
     for f in files:
         if f not in repo.dirstate:
             ui.note(_('Removing file %s\n') % f)
             remove(os.remove, f)
 
     for f in directories[::-1]:
         if match(f) and not os.listdir(repo.wjoin(f)):
             ui.note(_('Removing directory %s\n') % f)
             remove(os.rmdir, f)
 
 def _check_missing(ui, repo, missing, force=False):
     """Abort if there is the chance of having problems with name-mangling fs
 
     In a name mangling filesystem (e.g. a case insensitive one)
     dirstate.walk() can yield filenames different from the ones
     stored in the dirstate. This already confuses the status and
     add commands, but with purge this may cause data loss.
 
     To prevent this, _check_missing will abort if there are missing
     files. The force option will let the user skip the check if he
     knows it is safe.
 
     Even with the force option this function will check if any of the
     missing files is still available in the working dir: if so there
     may be some problem with the underlying filesystem, so it
     aborts unconditionally."""
 
     found = [f for f in missing if util.lexists(repo.wjoin(f))]
 
     if found:
         if not ui.quiet:
             ui.warn(_("The following tracked files weren't listed by the "
                       "filesystem, but could still be found:\n"))
             for f in found:
                 ui.warn("%s\n" % f)
             if util.checkfolding(repo.path):
                 ui.warn(_("This is probably due to a case-insensitive "
                           "filesystem\n"))
         raise util.Abort(_("purging on name mangling filesystems is not "
                            "yet fully supported"))
 
     if missing and not force:
         raise util.Abort(_("there are missing files in the working dir and "
                            "purge still has problems with them due to name "
                            "mangling filesystems. "
                            "Use --force if you know what you are doing"))
 
 
 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 the otherwise clean source tree.
 
     This means that purge will delete:
      - Unknown files: files marked with "?" by "hg status"
      - Ignored files: files usually ignored by Mercurial because they match
        a pattern in a ".hgignore" file
      - Empty directories: in fact Mercurial ignores directories unless they
        contain files under source control managment
     But it will leave untouched:
      - Unmodified tracked files
      - Modified tracked files
      - 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, 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']
     ignored = bool(opts['all'])
     abort_on_err = bool(opts['abort_on_err'])
     eol = opts['print0'] and '\0' or '\n'
     if eol == '\0':
         # --print0 implies --print
         act = False
     force = bool(opts['force'])
     include = opts['include']
     exclude = opts['exclude']
     dopurge(ui, repo, dirs, act, ignored, abort_on_err,
             eol, force, include, exclude)
 
 
 cmdtable = {
     'purge|clean':
         (purge,
          [('a', 'abort-on-err', None, _('abort if an error occurs')),
           ('',  'all', None, _('purge ignored files too')),
           ('f', 'force', None, _('purge even when missing files are detected')),
           ('p', 'print', None, _('print the file names instead of deleting them')),
           ('0', 'print0', None, _('end filenames with NUL, for use with xargs'
                                   ' (implies -p)')),
           ('I', 'include', [], _('include names matching the given patterns')),
           ('X', 'exclude', [], _('exclude names matching the given patterns'))],
          _('hg purge [OPTION]... [DIR]...'))
 }

mercurial/archival.py

@@ -1,219 +1,220 b''
 # archival.py - revision archival 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.
 
 from i18n import _
 from node import *
 import cStringIO, os, stat, tarfile, time, util, zipfile
 import zlib, gzip
 
 def tidyprefix(dest, prefix, suffixes):
     '''choose prefix to use for names in archive.  make sure prefix is
     safe for consumers.'''
 
     if prefix:
         prefix = prefix.replace('\\', '/')
     else:
         if not isinstance(dest, str):
             raise ValueError('dest must be string if no prefix')
         prefix = os.path.basename(dest)
         lower = prefix.lower()
         for sfx in suffixes:
             if lower.endswith(sfx):
                 prefix = prefix[:-len(sfx)]
                 break
     lpfx = os.path.normpath(util.localpath(prefix))
     prefix = util.pconvert(lpfx)
     if not prefix.endswith('/'):
         prefix += '/'
     if prefix.startswith('../') or os.path.isabs(lpfx) or '/../' in prefix:
         raise util.Abort(_('archive prefix contains illegal components'))
     return prefix
 
 class tarit:
     '''write archive to tar file or stream.  can write uncompressed,
     or compress with gzip or bzip2.'''
 
     class GzipFileWithTime(gzip.GzipFile):
 
         def __init__(self, *args, **kw):
             timestamp = None
             if 'timestamp' in kw:
                 timestamp = kw.pop('timestamp')
             if timestamp == None:
                 self.timestamp = time.time()
             else:
                 self.timestamp = timestamp
             gzip.GzipFile.__init__(self, *args, **kw)
 
         def _write_gzip_header(self):
             self.fileobj.write('\037\213')             # magic header
             self.fileobj.write('\010')                 # compression method
             fname = self.filename[:-3]
             flags = 0
             if fname:
                 flags = gzip.FNAME
             self.fileobj.write(chr(flags))
             gzip.write32u(self.fileobj, long(self.timestamp))
             self.fileobj.write('\002')
             self.fileobj.write('\377')
             if fname:
                 self.fileobj.write(fname + '\000')
 
     def __init__(self, dest, prefix, mtime, kind=''):
         self.prefix = tidyprefix(dest, prefix, ['.tar', '.tar.bz2', '.tar.gz',
                                                 '.tgz', '.tbz2'])
         self.mtime = mtime
 
         def taropen(name, mode, fileobj=None):
             if kind == 'gz':
                 mode = mode[0]
                 if not fileobj:
                     fileobj = open(name, mode + 'b')
                 gzfileobj = self.GzipFileWithTime(name, mode + 'b',
                                                   zlib.Z_BEST_COMPRESSION,
                                                   fileobj, timestamp=mtime)
                 return tarfile.TarFile.taropen(name, mode, gzfileobj)
             else:
                 return tarfile.open(name, mode + kind, fileobj)
 
         if isinstance(dest, str):
             self.z = taropen(dest, mode='w:')
         else:
             # Python 2.5-2.5.1 have a regression that requires a name arg
             self.z = taropen(name='', mode='w|', fileobj=dest)
 
     def addfile(self, name, mode, islink, data):
         i = tarfile.TarInfo(self.prefix + name)
         i.mtime = self.mtime
         i.size = len(data)
         if islink:
             i.type = tarfile.SYMTYPE
             i.mode = 0777
             i.linkname = data
             data = None
         else:
             i.mode = mode
             data = cStringIO.StringIO(data)
         self.z.addfile(i, data)
 
     def done(self):
         self.z.close()
 
 class tellable:
     '''provide tell method for zipfile.ZipFile when writing to http
     response file object.'''
 
     def __init__(self, fp):
         self.fp = fp
         self.offset = 0
 
     def __getattr__(self, key):
         return getattr(self.fp, key)
 
     def write(self, s):
         self.fp.write(s)
         self.offset += len(s)
 
     def tell(self):
         return self.offset
 
 class zipit:
     '''write archive to zip file or stream.  can write uncompressed,
     or compressed with deflate.'''
 
     def __init__(self, dest, prefix, mtime, compress=True):
         self.prefix = tidyprefix(dest, prefix, ('.zip',))
         if not isinstance(dest, str):
             try:
                 dest.tell()
             except (AttributeError, IOError):
                 dest = tellable(dest)
         self.z = zipfile.ZipFile(dest, 'w',
                                  compress and zipfile.ZIP_DEFLATED or
                                  zipfile.ZIP_STORED)
         self.date_time = time.gmtime(mtime)[:6]
 
     def addfile(self, name, mode, islink, data):
         i = zipfile.ZipInfo(self.prefix + name, self.date_time)
         i.compress_type = self.z.compression
         # unzip will not honor unix file modes unless file creator is
         # set to unix (id 3).
         i.create_system = 3
         ftype = stat.S_IFREG
         if islink:
             mode = 0777
             ftype = stat.S_IFLNK
         i.external_attr = (mode | ftype) << 16L
         self.z.writestr(i, data)
 
     def done(self):
         self.z.close()
 
 class fileit:
     '''write archive as files in directory.'''
 
     def __init__(self, name, prefix, mtime):
         if prefix:
             raise util.Abort(_('cannot give prefix when archiving to files'))
         self.basedir = name
         self.opener = util.opener(self.basedir)
 
     def addfile(self, name, mode, islink, data):
         if islink:
             self.opener.symlink(data, name)
             return
         f = self.opener(name, "w", atomictemp=True)
         f.write(data)
         f.rename()
         destfile = os.path.join(self.basedir, name)
         os.chmod(destfile, mode)
 
     def done(self):
         pass
 
 archivers = {
     'files': fileit,
     'tar': tarit,
     'tbz2': lambda name, prefix, mtime: tarit(name, prefix, mtime, 'bz2'),
     'tgz': lambda name, prefix, mtime: tarit(name, prefix, mtime, 'gz'),
     'uzip': lambda name, prefix, mtime: zipit(name, prefix, mtime, False),
     'zip': zipit,
     }
 
 def archive(repo, dest, node, kind, decode=True, matchfn=None,
             prefix=None, mtime=None):
     '''create archive of repo as it was at node.
 
     dest can be name of directory, name of archive file, or file
     object to write archive to.
 
     kind is type of archive to create.
 
     decode tells whether to put files through decode filters from
     hgrc.
 
     matchfn is function to filter names of files to write to archive.
 
     prefix is name of path to put before every archive member.'''
 
-    def write(name, mode, islink, data):
+    def write(name, mode, islink, getdata):
         if matchfn and not matchfn(name): return
+        data = getdata()
         if decode:
             data = repo.wwritedata(name, data)
         archiver.addfile(name, mode, islink, data)
 
     ctx = repo.changectx(node)
     archiver = archivers[kind](dest, prefix, mtime or ctx.date()[0])
     m = ctx.manifest()
     items = m.items()
     items.sort()
     write('.hg_archival.txt', 0644, False,
-          'repo: %s\nnode: %s\n' % (hex(repo.changelog.node(0)), hex(node)))
+          lambda: 'repo: %s\nnode: %s\n' % (hex(repo.changelog.node(0)), hex(node)))
     for filename, filenode in items:
         write(filename, m.execf(filename) and 0755 or 0644, m.linkf(filename),
-              repo.file(filename).read(filenode))
+              lambda: repo.file(filename).read(filenode))
     archiver.done()

mercurial/changelog.py

@@ -1,199 +1,198 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 revlog import *
 from i18n import _
 import os, time, util
 
 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 == _string_unescape(res)
     True
     """
     # subset of the string_escape codec
     text = text.replace('\\', '\\\\').replace('\n', '\\n').replace('\r', '\\r')
     return text.replace('\0', '\\0')
 
 def _string_unescape(text):
     return text.decode('string_escape')
 
 class appender:
     '''the changelog index must be update 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):
-        close(self.fp)
+        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 = ""
-        old_offset = self.offset
         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(s)
         self.offset += len(s)
 
 class changelog(revlog):
     def __init__(self, opener):
         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 = self.count()
         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()
             del 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
             return self._realopener(name + ".a", mode)
         # otherwise, divert to memory
         return appender(fp, self._delaybuf)
 
     def checkinlinesize(self, tr, fp=None):
         if self.opener == self._delayopener:
             return
         return revlog.checkinlinesize(self, tr, fp)
 
     def decode_extra(self, text):
         extra = {}
         for l in text.split('\0'):
             if not l:
                 continue
             k, v = _string_unescape(l).split(':', 1)
             extra[k] = v
         return extra
 
     def encode_extra(self, d):
         # keys must be sorted to produce a deterministic changelog entry
         keys = d.keys()
         keys.sort()
         items = [_string_escape('%s:%s' % (k, d[k])) for k in keys]
         return "\0".join(items)
 
     def extract(self, text):
         """
         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
         """
         if not text:
             return (nullid, "", (0, 0), [], "", {'branch': 'default'})
         last = text.index("\n\n")
         desc = util.tolocal(text[last + 2:])
         l = text[:last].split('\n')
         manifest = bin(l[0])
         user = util.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 read(self, node):
         return self.extract(self.revision(node))
 
     def add(self, manifest, list, desc, transaction, p1=None, p2=None,
                   user=None, date=None, extra={}):
 
         user, desc = util.fromlocal(user), util.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)
         list.sort()
         l = [hex(manifest), user, parseddate] + list + ["", desc]
         text = "\n".join(l)
         return self.addrevision(text, transaction, self.count(), p1, p2)

mercurial/cmdutil.py

@@ -1,1277 +1,1277 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 *
 from i18n import _
 import os, sys, atexit, signal, pdb, traceback, socket, errno, shlex
 import mdiff, bdiff, util, templater, patch, commands, hg, lock, time
 import fancyopts, revlog, version, extensions, hook
 
 revrangesep = ':'
 
 class UnknownCommand(Exception):
     """Exception raised if command is not in the command table."""
 class AmbiguousCommand(Exception):
     """Exception raised if command shortcut matches more than one command."""
 class ParseError(Exception):
     """Exception raised on errors in parsing the command line."""
 
 def runcatch(ui, args, argv0=None):
     def catchterm(*args):
         raise util.SignalInterrupt
 
     for name in 'SIGBREAK', 'SIGHUP', 'SIGTERM':
         num = getattr(signal, name, None)
         if num: signal.signal(num, catchterm)
 
     try:
         try:
             # enter the debugger before command execution
             if '--debugger' in args:
                 pdb.set_trace()
             try:
                 return dispatch(ui, args, argv0=argv0)
             finally:
                 ui.flush()
         except:
             # enter the debugger when we hit an exception
             if '--debugger' in args:
                 pdb.post_mortem(sys.exc_info()[2])
             ui.print_exc()
             raise
 
     except ParseError, inst:
         if inst.args[0]:
             ui.warn(_("hg %s: %s\n") % (inst.args[0], inst.args[1]))
             commands.help_(ui, inst.args[0])
         else:
             ui.warn(_("hg: %s\n") % inst.args[1])
             commands.help_(ui, 'shortlist')
     except AmbiguousCommand, inst:
         ui.warn(_("hg: command '%s' is ambiguous:\n    %s\n") %
                 (inst.args[0], " ".join(inst.args[1])))
     except UnknownCommand, inst:
         ui.warn(_("hg: unknown command '%s'\n") % inst.args[0])
         commands.help_(ui, 'shortlist')
     except hg.RepoError, inst:
         ui.warn(_("abort: %s!\n") % inst)
     except lock.LockHeld, inst:
         if inst.errno == errno.ETIMEDOUT:
             reason = _('timed out waiting for lock held by %s') % inst.locker
         else:
             reason = _('lock held by %s') % inst.locker
         ui.warn(_("abort: %s: %s\n") % (inst.desc or inst.filename, reason))
     except lock.LockUnavailable, inst:
         ui.warn(_("abort: could not lock %s: %s\n") %
                (inst.desc or inst.filename, inst.strerror))
     except revlog.RevlogError, inst:
         ui.warn(_("abort: %s!\n") % inst)
     except util.SignalInterrupt:
         ui.warn(_("killed!\n"))
     except KeyboardInterrupt:
         try:
             ui.warn(_("interrupted!\n"))
         except IOError, inst:
             if inst.errno == errno.EPIPE:
                 if ui.debugflag:
                     ui.warn(_("\nbroken pipe\n"))
             else:
                 raise
     except socket.error, inst:
         ui.warn(_("abort: %s\n") % inst[1])
     except IOError, inst:
         if hasattr(inst, "code"):
             ui.warn(_("abort: %s\n") % inst)
         elif hasattr(inst, "reason"):
             try: # usually it is in the form (errno, strerror)
                 reason = inst.reason.args[1]
             except: # it might be anything, for example a string
                 reason = inst.reason
             ui.warn(_("abort: error: %s\n") % reason)
         elif hasattr(inst, "args") and inst[0] == errno.EPIPE:
             if ui.debugflag:
                 ui.warn(_("broken pipe\n"))
         elif getattr(inst, "strerror", None):
             if getattr(inst, "filename", None):
                 ui.warn(_("abort: %s: %s\n") % (inst.strerror, inst.filename))
             else:
                 ui.warn(_("abort: %s\n") % inst.strerror)
         else:
             raise
     except OSError, inst:
         if getattr(inst, "filename", None):
             ui.warn(_("abort: %s: %s\n") % (inst.strerror, inst.filename))
         else:
             ui.warn(_("abort: %s\n") % inst.strerror)
     except util.UnexpectedOutput, inst:
         ui.warn(_("abort: %s") % inst[0])
         if not isinstance(inst[1], basestring):
             ui.warn(" %r\n" % (inst[1],))
         elif not inst[1]:
             ui.warn(_(" empty string\n"))
         else:
             ui.warn("\n%r\n" % util.ellipsis(inst[1]))
     except ImportError, inst:
         m = str(inst).split()[-1]
         ui.warn(_("abort: could not import module %s!\n" % m))
         if m in "mpatch bdiff".split():
             ui.warn(_("(did you forget to compile extensions?)\n"))
         elif m in "zlib".split():
             ui.warn(_("(is your Python install correct?)\n"))
 
     except util.Abort, inst:
         ui.warn(_("abort: %s\n") % inst)
     except SystemExit, inst:
         # Commands shouldn't sys.exit directly, but give a return code.
         # Just in case catch this and and pass exit code to caller.
         return inst.code
     except:
         ui.warn(_("** unknown exception encountered, details follow\n"))
         ui.warn(_("** report bug details to "
                  "http://www.selenic.com/mercurial/bts\n"))
         ui.warn(_("** or [e-mail]\n"))
         ui.warn(_("** Mercurial Distributed SCM (version %s)\n")
                % version.get_version())
         raise
 
     return -1
 
 def findpossible(ui, cmd):
     """
     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 commands.table.keys():
         aliases = e.lstrip("^").split("|")
         found = None
         if cmd in aliases:
             found = cmd
         elif not ui.config("ui", "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, commands.table[e])
             else:
                 choice[found] = (aliases, commands.table[e])
 
     if not choice and debugchoice:
         choice = debugchoice
 
     return choice
 
 def findcmd(ui, cmd):
     """Return (aliases, command table entry) for command string."""
     choice = findpossible(ui, cmd)
 
     if choice.has_key(cmd):
         return choice[cmd]
 
     if len(choice) > 1:
         clist = choice.keys()
         clist.sort()
         raise AmbiguousCommand(cmd, clist)
 
     if choice:
         return choice.values()[0]
 
     raise UnknownCommand(cmd)
 
 def findrepo():
     p = os.getcwd()
     while not os.path.isdir(os.path.join(p, ".hg")):
         oldp, p = p, os.path.dirname(p)
         if p == oldp:
             return None
 
     return p
 
 def parse(ui, args):
     options = {}
     cmdoptions = {}
 
     try:
         args = fancyopts.fancyopts(args, commands.globalopts, options)
     except fancyopts.getopt.GetoptError, inst:
         raise ParseError(None, inst)
 
     if args:
         cmd, args = args[0], args[1:]
         aliases, i = findcmd(ui, cmd)
         cmd = aliases[0]
         defaults = ui.config("defaults", cmd)
         if defaults:
             args = shlex.split(defaults) + args
         c = list(i[1])
     else:
         cmd = None
         c = []
 
     # combine global options into local
     for o in commands.globalopts:
         c.append((o[0], o[1], options[o[1]], o[3]))
 
     try:
         args = fancyopts.fancyopts(args, c, cmdoptions)
     except fancyopts.getopt.GetoptError, inst:
         raise ParseError(cmd, inst)
 
     # separate global options back out
     for o in commands.globalopts:
         n = o[1]
         options[n] = cmdoptions[n]
         del cmdoptions[n]
 
     return (cmd, cmd and i[0] or None, args, options, cmdoptions)
 
 def parseconfig(config):
     """parse the --config options from the command line"""
     parsed = []
     for cfg in config:
         try:
             name, value = cfg.split('=', 1)
             section, name = name.split('.', 1)
             if not section or not name:
                 raise IndexError
             parsed.append((section, name, value))
         except (IndexError, ValueError):
             raise util.Abort(_('malformed --config option: %s') % cfg)
     return parsed
 
 def earlygetopt(aliases, args):
     """Return list of values for an option (or aliases).
 
     The values are listed in the order they appear in args.
     The options and values are removed from args.
     """
     try:
         argcount = args.index("--")
     except ValueError:
         argcount = len(args)
     shortopts = [opt for opt in aliases if len(opt) == 2]
     values = []
     pos = 0
     while pos < argcount:
         if args[pos] in aliases:
             if pos + 1 >= argcount:
                 # ignore and let getopt report an error if there is no value
                 break
             del args[pos]
             values.append(args.pop(pos))
             argcount -= 2
         elif args[pos][:2] in shortopts:
             # short option can have no following space, e.g. hg log -Rfoo
             values.append(args.pop(pos)[2:])
             argcount -= 1
         else:
             pos += 1
     return values
 
 def dispatch(ui, args, argv0=None):
     # remember how to call 'hg' before changing the working dir
     util.set_hgexecutable(argv0)
 
     # read --config before doing anything else
     # (e.g. to change trust settings for reading .hg/hgrc)
     config = earlygetopt(['--config'], args)
     if config:
         ui.updateopts(config=parseconfig(config))
 
     # check for cwd
     cwd = earlygetopt(['--cwd'], args)
     if cwd:
         os.chdir(cwd[-1])
 
     # read the local repository .hgrc into a local ui object
     path = findrepo() or ""
     if not path:
         lui = ui
     if path:
         try:
             lui = commands.ui.ui(parentui=ui)
             lui.readconfig(os.path.join(path, ".hg", "hgrc"))
         except IOError:
             pass
 
     # now we can expand paths, even ones in .hg/hgrc
     rpath = earlygetopt(["-R", "--repository", "--repo"], args)
     if rpath:
         path = lui.expandpath(rpath[-1])
         lui = commands.ui.ui(parentui=ui)
         lui.readconfig(os.path.join(path, ".hg", "hgrc"))
 
     extensions.loadall(lui)
     # check for fallback encoding
     fallback = lui.config('ui', 'fallbackencoding')
     if fallback:
         util._fallbackencoding = fallback
 
     fullargs = args
-    cmd, func, args, options, cmdoptions = parse(ui, args)
+    cmd, func, args, options, cmdoptions = parse(lui, args)
 
     if options["config"]:
         raise util.Abort(_("Option --config may not be abbreviated!"))
     if options["cwd"]:
         raise util.Abort(_("Option --cwd may not be abbreviated!"))
     if options["repository"]:
         raise util.Abort(_(
             "Option -R has to be separated from other options (i.e. not -qR) "
             "and --repository may only be abbreviated as --repo!"))
 
     if options["encoding"]:
         util._encoding = options["encoding"]
     if options["encodingmode"]:
         util._encodingmode = options["encodingmode"]
     if options["time"]:
         def get_times():
             t = os.times()
             if t[4] == 0.0: # Windows leaves this as zero, so use time.clock()
                 t = (t[0], t[1], t[2], t[3], time.clock())
             return t
         s = get_times()
         def print_time():
             t = get_times()
             ui.warn(_("Time: real %.3f secs (user %.3f+%.3f sys %.3f+%.3f)\n") %
                 (t[4]-s[4], t[0]-s[0], t[2]-s[2], t[1]-s[1], t[3]-s[3]))
         atexit.register(print_time)
 
     ui.updateopts(options["verbose"], options["debug"], options["quiet"],
                  not options["noninteractive"], options["traceback"])
 
     if options['help']:
         return commands.help_(ui, cmd, options['version'])
     elif options['version']:
         return commands.version_(ui)
     elif not cmd:
         return commands.help_(ui, 'shortlist')
 
     repo = None
     if cmd not in commands.norepo.split():
         try:
             repo = hg.repository(ui, path=path)
             ui = repo.ui
             if not repo.local():
                 raise util.Abort(_("repository '%s' is not local") % path)
         except hg.RepoError:
             if cmd not in commands.optionalrepo.split():
                 if not path:
                     raise hg.RepoError(_("There is no Mercurial repository here"
                                          " (.hg not found)"))
                 raise
         d = lambda: func(ui, repo, *args, **cmdoptions)
     else:
         d = lambda: func(ui, *args, **cmdoptions)
 
     # run pre-hook, and abort if it fails
     ret = hook.hook(ui, repo, "pre-%s" % cmd, False, args=" ".join(fullargs))
     if ret:
         return ret
     ret = runcommand(ui, options, cmd, d)
     # run post-hook, passing command result
     hook.hook(ui, repo, "post-%s" % cmd, False, args=" ".join(fullargs),
               result = ret)
     return ret
 
 def runcommand(ui, options, cmd, cmdfunc):
     def checkargs():
         try:
             return cmdfunc()
         except TypeError, inst:
             # was this an argument error?
             tb = traceback.extract_tb(sys.exc_info()[2])
             if len(tb) != 2: # no
                 raise
             raise ParseError(cmd, _("invalid arguments"))
 
     if options['profile']:
         import hotshot, hotshot.stats
         prof = hotshot.Profile("hg.prof")
         try:
             try:
                 return prof.runcall(checkargs)
             except:
                 try:
                     ui.warn(_('exception raised - generating '
                              'profile anyway\n'))
                 except:
                     pass
                 raise
         finally:
             prof.close()
             stats = hotshot.stats.load("hg.prof")
             stats.strip_dirs()
             stats.sort_stats('time', 'calls')
             stats.print_stats(40)
     elif options['lsprof']:
         try:
             from mercurial import lsprof
         except ImportError:
             raise util.Abort(_(
                 'lsprof not available - install from '
                 'http://codespeak.net/svn/user/arigo/hack/misc/lsprof/'))
         p = lsprof.Profiler()
         p.enable(subcalls=True)
         try:
             return checkargs()
         finally:
             p.disable()
             stats = lsprof.Stats(p.getstats())
             stats.sort()
             stats.pprint(top=10, file=sys.stderr, climit=5)
     else:
         return checkargs()
 
 def bail_if_changed(repo):
     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['message']
     logfile = opts['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 setremoteconfig(ui, opts):
     "copy remote options to ui tree"
     if opts.get('ssh'):
         ui.setconfig("ui", "ssh", opts['ssh'])
     if opts.get('remotecmd'):
         ui.setconfig("ui", "remotecmd", opts['remotecmd'])
 
 def parseurl(url, revs):
     '''parse url#branch, returning url, branch + revs'''
 
     if '#' not in url:
         return url, (revs or None)
 
     url, rev = url.split('#', 1)
     return url, revs + [rev]
 
 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, repo.changelog.count() - 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, repo.changelog.count() - 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):
     if not pat or pat == '-':
         return 'w' in mode and sys.stdout or sys.stdin
     if hasattr(pat, 'write') and 'w' in mode:
         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 matchpats(repo, pats=[], opts={}, globbed=False, default=None):
     cwd = repo.getcwd()
     return util.cmdmatcher(repo.root, cwd, pats or [], opts.get('include'),
                            opts.get('exclude'), globbed=globbed,
                            default=default)
 
 def walk(repo, pats=[], opts={}, node=None, badmatch=None, globbed=False,
          default=None):
     files, matchfn, anypats = matchpats(repo, pats, opts, globbed=globbed,
                                         default=default)
     exact = dict.fromkeys(files)
     cwd = repo.getcwd()
     for src, fn in repo.walk(node=node, files=files, match=matchfn,
                              badmatch=badmatch):
         yield src, fn, repo.pathto(fn, cwd), fn in exact
 
 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.changectx()
     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 = {}
     for src, abs, rel, exact in walk(repo, pats, opts):
         target = repo.wjoin(abs)
         if src == 'f' and abs not in repo.dirstate:
             add.append(abs)
             mapping[abs] = rel, exact
             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 util.lexists(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.add(add)
         repo.remove(remove)
     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 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))
         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, buffered):
         self.ui = ui
         self.repo = repo
         self.buffered = buffered
         self.patch = patch
         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, rev=0, changenode=None, copies=(), **props):
         if self.buffered:
             self.ui.pushbuffer()
             self._show(rev, changenode, copies, props)
             self.hunk[rev] = self.ui.popbuffer()
         else:
             self._show(rev, changenode, copies, props)
 
     def _show(self, rev, changenode, copies, props):
         '''show a single changeset or file revision'''
         log = self.repo.changelog
         if changenode is None:
             changenode = log.node(rev)
         elif not rev:
             rev = log.rev(changenode)
 
         if self.ui.quiet:
             self.ui.write("%d:%s\n" % (rev, short(changenode)))
             return
 
         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 = util.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:
             extraitems = extra.items()
             extraitems.sort()
             for key, value in extraitems:
                 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]
             patch.diff(self.repo, prev, node, match=self.patch, fp=self.ui,
                        opts=patch.diffopts(self.ui))
             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, mapfile, buffered):
         changeset_printer.__init__(self, ui, repo, patch, buffered)
         filters = templater.common_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 _show(self, rev, changenode, copies, props):
         '''show a single changeset or file revision'''
         log = self.repo.changelog
         if changenode is None:
             changenode = log.node(rev)
         elif not rev:
             rev = log.rev(changenode)
 
         changes = log.read(changenode)
 
         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 = changes[5].get("branch")
             if branch != 'default':
                 branch = util.tolocal(branch)
                 return showlist('branch', [branch], plural='branches', **args)
 
         def showparents(**args):
             parents = [[('rev', p), ('node', hex(log.node(p)))]
                        for p in self._meaningful_parentrevs(log, rev)]
             return showlist('parent', parents, **args)
 
         def showtags(**args):
             return showlist('tag', self.repo.nodetags(changenode), **args)
 
         def showextras(**args):
             extras = changes[5].items()
             extras.sort()
             for key, value in extras:
                 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)
 
         if self.ui.debugflag:
             files = self.repo.status(log.parents(changenode)[0], changenode)[:3]
             def showfiles(**args):
                 return showlist('file', files[0], **args)
             def showadds(**args):
                 return showlist('file_add', files[1], **args)
             def showdels(**args):
                 return showlist('file_del', files[2], **args)
             def showmanifest(**args):
                 args = args.copy()
                 args.update(dict(rev=self.repo.manifest.rev(changes[0]),
                                  node=hex(changes[0])))
                 return self.t('manifest', **args)
         else:
             def showfiles(**args):
                 return showlist('file', changes[3], **args)
             showadds = ''
             showdels = ''
             showmanifest = ''
 
         defprops = {
             'author': changes[1],
             'branches': showbranches,
             'date': changes[2],
             'desc': changes[4].strip(),
             'file_adds': showadds,
             'file_dels': showdels,
             'files': showfiles,
             'file_copies': showcopies,
             'manifest': showmanifest,
             'node': hex(changenode),
             'parents': showparents,
             'rev': rev,
             'tags': showtags,
             'extras': showextras,
             }
         props = props.copy()
         props.update(defprops)
 
         try:
             if self.ui.debugflag and 'header_debug' in self.t:
                 key = 'header_debug'
             elif self.ui.quiet and 'header_quiet' in self.t:
                 key = 'header_quiet'
             elif self.ui.verbose and 'header_verbose' in self.t:
                 key = 'header_verbose'
             elif 'header' in self.t:
                 key = 'header'
             else:
                 key = ''
             if key:
                 h = templater.stringify(self.t(key, **props))
                 if self.buffered:
                     self.header[rev] = h
                 else:
                     self.ui.write(h)
             if self.ui.debugflag and 'changeset_debug' in self.t:
                 key = 'changeset_debug'
             elif self.ui.quiet and 'changeset_quiet' in self.t:
                 key = 'changeset_quiet'
             elif self.ui.verbose and 'changeset_verbose' in self.t:
                 key = 'changeset_verbose'
             else:
                 key = 'changeset'
             self.ui.write(templater.stringify(self.t(key, **props)))
             self.showpatch(changenode)
         except KeyError, inst:
             raise util.Abort(_("%s: no key named '%s'") % (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 util.always
 
     tmpl = opts.get('template')
     mapfile = None
     if tmpl:
         tmpl = templater.parsestring(tmpl, quoted=False)
     else:
         mapfile = opts.get('style')
         # ui settings
         if not mapfile:
             tmpl = ui.config('ui', 'logtemplate')
             if tmpl:
                 tmpl = templater.parsestring(tmpl)
             else:
                 mapfile = ui.config('ui', 'style')
 
     if tmpl or mapfile:
         if mapfile:
             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, mapfile, buffered)
         except SyntaxError, inst:
             raise util.Abort(inst.args[0])
         if tmpl: t.use_template(tmpl)
         return t
     return changeset_printer(ui, repo, patch, buffered)
 
 def finddate(ui, repo, date):
     """Find the tipmost changeset that matches the given date spec"""
     df = util.matchdate(date + " to " + date)
     get = util.cachefunc(lambda r: repo.changectx(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 they changed in.
 
     Callers most commonly need to iterate backwards over the history
     it is interested in.  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
 
     files, matchfn, anypats = matchpats(repo, pats, opts)
     follow = opts.get('follow') or opts.get('follow_first')
 
     if repo.changelog.count() == 0:
         return [], matchfn
 
     if follow:
         defrange = '%s:0' % repo.changectx().rev()
     else:
         defrange = 'tip:0'
     revs = revrange(repo, opts['rev'] or [defrange])
     wanted = {}
     slowpath = anypats or opts.get('removed')
     fncache = {}
 
     if not slowpath and not files:
         # No files, no patterns.  Display all revs.
         wanted = dict.fromkeys(revs)
     copies = []
     if not slowpath:
         # Only files, no patterns.  Check the history of each file.
         def filerevgen(filelog, node):
             cl_count = repo.changelog.count()
             if node is None:
                 last = filelog.count() - 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(n),
                                  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 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_)
             # A zero count may be a directory or deleted file, so
             # try to find matching entries on the slow path.
             if filelog.count() == 0:
                 slowpath = True
                 break
             for rev, copied in filerevgen(filelog, node):
                 if rev <= maxrev:
                     if rev < minrev:
                         break
                     fncache.setdefault(rev, [])
                     fncache[rev].append(file_)
                     wanted[rev] = 1
                     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(repo.changelog.count()-1,
                                                 nullrev):
                 for j in xrange(i - window, i + 1):
                     yield j, change(j)[3]
 
         for rev, changefiles in changerevgen():
             matches = filter(matchfn, changefiles)
             if matches:
                 fncache[rev] = matches
                 wanted[rev] = 1
 
     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) and x in wanted:
                 del wanted[x]
 
     def iterate():
         if follow and not files:
             ff = followfilter(onlyfirst=opts.get('follow_first'))
             def want(rev):
                 if ff.match(rev) and rev in wanted:
                     return True
                 return False
         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)]
             srevs = list(nrevs)
             srevs.sort()
             for rev in srevs:
                 fns = fncache.get(rev)
                 if not fns:
                     def fns_generator():
                         for f in change(rev)[3]:
                             if matchfn(f):
                                 yield f
                     fns = fns_generator()
                 yield 'add', rev, fns
             for rev in nrevs:
                 yield 'iter', rev, None
     return iterate(), matchfn

mercurial/commands.py

@@ -1,3179 +1,3174 b''
 # commands.py - command processing 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.
 
 import demandimport; demandimport.enable()
 from node import *
 from i18n import _
-import bisect, os, re, sys, urllib, shlex, stat
+import bisect, os, re, sys, urllib, stat
 import ui, hg, util, revlog, bundlerepo, extensions
 import difflib, patch, time, help, mdiff, tempfile
 import errno, version, socket
 import archival, changegroup, cmdutil, hgweb.server, sshserver
 
 # Commands start here, listed alphabetically
 
 def add(ui, repo, *pats, **opts):
     """add the specified files on the next commit
 
     Schedule files to be version controlled and added to the repository.
 
     The files will be added to the repository at the next commit. To
     undo an add before that, see hg revert.
 
     If no names are given, add all files in the repository.
     """
 
     names = []
     for src, abs, rel, exact in cmdutil.walk(repo, pats, opts):
         if exact:
             if ui.verbose:
                 ui.status(_('adding %s\n') % rel)
             names.append(abs)
         elif abs not in repo.dirstate:
             ui.status(_('adding %s\n') % rel)
             names.append(abs)
     if not opts.get('dry_run'):
         repo.add(names)
 
 def addremove(ui, repo, *pats, **opts):
     """add all new files, delete all missing files
 
     Add all new files and remove all missing files from the repository.
 
     New files are ignored if they match any of the patterns in .hgignore. As
     with add, these changes take effect at the next commit.
 
     Use the -s option to detect renamed files.  With a parameter > 0,
     this compares every removed file with every added file and records
     those similar enough as renames.  This option takes a percentage
     between 0 (disabled) and 100 (files must be identical) as its
     parameter.  Detecting renamed files this way can be expensive.
     """
     sim = float(opts.get('similarity') or 0)
     if sim < 0 or sim > 100:
         raise util.Abort(_('similarity must be between 0 and 100'))
     return cmdutil.addremove(repo, pats, opts, similarity=sim/100.)
 
 def annotate(ui, repo, *pats, **opts):
     """show changeset information per file line
 
     List changes in files, showing the revision id responsible for each line
 
     This command is useful to discover who did a change or when a change took
     place.
 
     Without the -a option, annotate will avoid processing files it
     detects as binary. With -a, annotate will generate an annotation
     anyway, probably with undesirable results.
     """
     getdate = util.cachefunc(lambda x: util.datestr(x[0].date()))
 
     if not pats:
         raise util.Abort(_('at least one file name or pattern required'))
 
     opmap = [('user', lambda x: ui.shortuser(x[0].user())),
              ('number', lambda x: str(x[0].rev())),
              ('changeset', lambda x: short(x[0].node())),
              ('date', getdate),
              ('follow', lambda x: x[0].path()),
             ]
 
     if (not opts['user'] and not opts['changeset'] and not opts['date']
         and not opts['follow']):
         opts['number'] = 1
 
     linenumber = opts.get('line_number') is not None
     if (linenumber and (not opts['changeset']) and (not opts['number'])):
         raise util.Abort(_('at least one of -n/-c is required for -l'))
 
     funcmap = [func for op, func in opmap if opts.get(op)]
     if linenumber:
         lastfunc = funcmap[-1]
         funcmap[-1] = lambda x: "%s:%s" % (lastfunc(x), x[1])
 
     ctx = repo.changectx(opts['rev'])
 
     for src, abs, rel, exact in cmdutil.walk(repo, pats, opts,
                                              node=ctx.node()):
         fctx = ctx.filectx(abs)
         if not opts['text'] and util.binary(fctx.data()):
             ui.write(_("%s: binary file\n") % ((pats and rel) or abs))
             continue
 
         lines = fctx.annotate(follow=opts.get('follow'),
                               linenumber=linenumber)
         pieces = []
 
         for f in funcmap:
             l = [f(n) for n, dummy in lines]
             if l:
                 m = max(map(len, l))
                 pieces.append(["%*s" % (m, x) for x in l])
 
         if pieces:
             for p, l in zip(zip(*pieces), lines):
                 ui.write("%s: %s" % (" ".join(p), l[1]))
 
 def archive(ui, repo, dest, **opts):
     '''create unversioned archive of a repository revision
 
     By default, the revision used is the parent of the working
     directory; use "-r" to specify a different revision.
 
     To specify the type of archive to create, use "-t".  Valid
     types are:
 
     "files" (default): a directory full of files
     "tar": tar archive, uncompressed
     "tbz2": tar archive, compressed using bzip2
     "tgz": tar archive, compressed using gzip
     "uzip": zip archive, uncompressed
     "zip": zip archive, compressed using deflate
 
     The exact name of the destination archive or directory is given
     using a format string; see "hg help export" for details.
 
     Each member added to an archive file has a directory prefix
     prepended.  Use "-p" to specify a format string for the prefix.
     The default is the basename of the archive, with suffixes removed.
     '''
 
     ctx = repo.changectx(opts['rev'])
     if not ctx:
         raise util.Abort(_('repository has no revisions'))
     node = ctx.node()
     dest = cmdutil.make_filename(repo, dest, node)
     if os.path.realpath(dest) == repo.root:
         raise util.Abort(_('repository root cannot be destination'))
     dummy, matchfn, dummy = cmdutil.matchpats(repo, [], opts)
     kind = opts.get('type') or 'files'
     prefix = opts['prefix']
     if dest == '-':
         if kind == 'files':
             raise util.Abort(_('cannot archive plain files to stdout'))
         dest = sys.stdout
         if not prefix: prefix = os.path.basename(repo.root) + '-%h'
     prefix = cmdutil.make_filename(repo, prefix, node)
     archival.archive(repo, dest, node, kind, not opts['no_decode'],
                      matchfn, prefix)
 
 def backout(ui, repo, node=None, rev=None, **opts):
     '''reverse effect of earlier changeset
 
     Commit the backed out changes as a new changeset.  The new
     changeset is a child of the backed out changeset.
 
     If you back out a changeset other than the tip, a new head is
     created.  This head is the parent of the working directory.  If
     you back out an old changeset, your working directory will appear
     old after the backout.  You should merge the backout changeset
     with another head.
 
     The --merge option remembers the parent of the working directory
     before starting the backout, then merges the new head with that
     changeset afterwards.  This saves you from doing the merge by
     hand.  The result of this merge is not committed, as for a normal
     merge.'''
     if rev and node:
         raise util.Abort(_("please specify just one revision"))
 
     if not rev:
         rev = node
 
     if not rev:
         raise util.Abort(_("please specify a revision to backout"))
 
     cmdutil.bail_if_changed(repo)
     op1, op2 = repo.dirstate.parents()
     if op2 != nullid:
         raise util.Abort(_('outstanding uncommitted merge'))
     node = repo.lookup(rev)
     p1, p2 = repo.changelog.parents(node)
     if p1 == nullid:
         raise util.Abort(_('cannot back out a change with no parents'))
     if p2 != nullid:
         if not opts['parent']:
             raise util.Abort(_('cannot back out a merge changeset without '
                                '--parent'))
         p = repo.lookup(opts['parent'])
         if p not in (p1, p2):
             raise util.Abort(_('%s is not a parent of %s') %
                              (short(p), short(node)))
         parent = p
     else:
         if opts['parent']:
             raise util.Abort(_('cannot use --parent on non-merge changeset'))
         parent = p1
     hg.clean(repo, node, show_stats=False)
     revert_opts = opts.copy()
     revert_opts['date'] = None
     revert_opts['all'] = True
     revert_opts['rev'] = hex(parent)
     revert(ui, repo, **revert_opts)
     commit_opts = opts.copy()
     commit_opts['addremove'] = False
     if not commit_opts['message'] and not commit_opts['logfile']:
         commit_opts['message'] = _("Backed out changeset %s") % (short(node))
         commit_opts['force_editor'] = True
     commit(ui, repo, **commit_opts)
     def nice(node):
         return '%d:%s' % (repo.changelog.rev(node), short(node))
     ui.status(_('changeset %s backs out changeset %s\n') %
               (nice(repo.changelog.tip()), nice(node)))
     if op1 != node:
         if opts['merge']:
             ui.status(_('merging with changeset %s\n') % nice(op1))
             hg.merge(repo, hex(op1))
         else:
             ui.status(_('the backout changeset is a new head - '
                         'do not forget to merge\n'))
             ui.status(_('(use "backout --merge" '
                         'if you want to auto-merge)\n'))
 
 def branch(ui, repo, label=None, **opts):
     """set or show the current branch name
 
     With no argument, show the current branch name. With one argument,
     set the working directory branch name (the branch does not exist in
     the repository until the next commit).
 
     Unless --force is specified, branch will not let you set a
     branch name that shadows an existing branch.
     """
 
     if label:
         if not opts.get('force') and label in repo.branchtags():
             if label not in [p.branch() for p in repo.workingctx().parents()]:
                 raise util.Abort(_('a branch of the same name already exists'
                                    ' (use --force to override)'))
         repo.dirstate.setbranch(util.fromlocal(label))
         ui.status(_('marked working directory as branch %s\n') % label)
     else:
         ui.write("%s\n" % util.tolocal(repo.dirstate.branch()))
 
 def branches(ui, repo, active=False):
     """list repository named branches
 
     List the repository's named branches, indicating which ones are
     inactive.  If active is specified, only show active branches.
 
     A branch is considered active if it contains unmerged heads.
     """
     b = repo.branchtags()
     heads = dict.fromkeys(repo.heads(), 1)
     l = [((n in heads), repo.changelog.rev(n), n, t) for t, n in b.items()]
     l.sort()
     l.reverse()
     for ishead, r, n, t in l:
         if active and not ishead:
             # If we're only displaying active branches, abort the loop on
             # encountering the first inactive head
             break
         else:
             hexfunc = ui.debugflag and hex or short
             if ui.quiet:
                 ui.write("%s\n" % t)
             else:
                 spaces = " " * (30 - util.locallen(t))
                 # The code only gets here if inactive branches are being
                 # displayed or the branch is active.
                 isinactive = ((not ishead) and " (inactive)") or ''
                 ui.write("%s%s %s:%s%s\n" % (t, spaces, r, hexfunc(n), isinactive))
 
 def bundle(ui, repo, fname, dest=None, **opts):
     """create a changegroup file
 
     Generate a compressed changegroup file collecting changesets not
     found in the other repository.
 
     If no destination repository is specified the destination is assumed
     to have all the nodes specified by one or more --base parameters.
 
     The bundle file can then be transferred using conventional means and
     applied to another repository with the unbundle or pull command.
     This is useful when direct push and pull are not available or when
     exporting an entire repository is undesirable.
 
     Applying bundles preserves all changeset contents including
     permissions, copy/rename information, and revision history.
     """
     revs = opts.get('rev') or None
     if revs:
         revs = [repo.lookup(rev) for rev in revs]
     base = opts.get('base')
     if base:
         if dest:
             raise util.Abort(_("--base is incompatible with specifiying "
                                "a destination"))
         base = [repo.lookup(rev) for rev in base]
         # create the right base
         # XXX: nodesbetween / changegroup* should be "fixed" instead
         o = []
         has = {nullid: None}
         for n in base:
             has.update(repo.changelog.reachable(n))
         if revs:
             visit = list(revs)
         else:
             visit = repo.changelog.heads()
         seen = {}
         while visit:
             n = visit.pop(0)
             parents = [p for p in repo.changelog.parents(n) if p not in has]
             if len(parents) == 0:
                 o.insert(0, n)
             else:
                 for p in parents:
                     if p not in seen:
                         seen[p] = 1
                         visit.append(p)
     else:
         cmdutil.setremoteconfig(ui, opts)
         dest, revs = cmdutil.parseurl(
             ui.expandpath(dest or 'default-push', dest or 'default'), revs)
         other = hg.repository(ui, dest)
         o = repo.findoutgoing(other, force=opts['force'])
 
     if revs:
         cg = repo.changegroupsubset(o, revs, 'bundle')
     else:
         cg = repo.changegroup(o, 'bundle')
     changegroup.writebundle(cg, fname, "HG10BZ")
 
 def cat(ui, repo, file1, *pats, **opts):
     """output the current or given revision of files
 
     Print the specified files as they were at the given revision.
     If no revision is given, the parent of the working directory is used,
     or tip if no revision is checked out.
 
     Output may be to a file, in which case the name of the file is
     given using a format string.  The formatting rules are the same as
     for the export command, with the following additions:
 
     %s   basename of file being printed
     %d   dirname of file being printed, or '.' if in repo root
     %p   root-relative path name of file being printed
     """
     ctx = repo.changectx(opts['rev'])
     err = 1
     for src, abs, rel, exact in cmdutil.walk(repo, (file1,) + pats, opts,
                                              ctx.node()):
         fp = cmdutil.make_file(repo, opts['output'], ctx.node(), pathname=abs)
         fp.write(ctx.filectx(abs).data())
         err = 0
     return err
 
 def clone(ui, source, dest=None, **opts):
     """make a copy of an existing repository
 
     Create a copy of an existing repository in a new directory.
 
     If no destination directory name is specified, it defaults to the
     basename of the source.
 
     The location of the source is added to the new repository's
     .hg/hgrc file, as the default to be used for future pulls.
 
     For efficiency, hardlinks are used for cloning whenever the source
     and destination are on the same filesystem (note this applies only
     to the repository data, not to the checked out files).  Some
     filesystems, such as AFS, implement hardlinking incorrectly, but
     do not report errors.  In these cases, use the --pull option to
     avoid hardlinking.
 
     You can safely clone repositories and checked out files using full
     hardlinks with
 
       $ cp -al REPO REPOCLONE
 
     which is the fastest way to clone. However, the operation is not
     atomic (making sure REPO is not modified during the operation is
     up to you) and you have to make sure your editor breaks hardlinks
     (Emacs and most Linux Kernel tools do so).
 
     If you use the -r option to clone up to a specific revision, no
     subsequent revisions will be present in the cloned repository.
     This option implies --pull, even on local repositories.
 
     See pull for valid source format details.
 
     It is possible to specify an ssh:// URL as the destination, but no
     .hg/hgrc and working directory will be created on the remote side.
     Look at the help text for the pull command for important details
     about ssh:// URLs.
     """
     cmdutil.setremoteconfig(ui, opts)
     hg.clone(ui, source, dest,
              pull=opts['pull'],
              stream=opts['uncompressed'],
              rev=opts['rev'],
              update=not opts['noupdate'])
 
 def commit(ui, repo, *pats, **opts):
     """commit the specified files or all outstanding changes
 
     Commit changes to the given files into the repository.
 
     If a list of files is omitted, all changes reported by "hg status"
     will be committed.
 
     If no commit message is specified, the editor configured in your hgrc
     or in the EDITOR environment variable is started to enter a message.
     """
     message = cmdutil.logmessage(opts)
 
     if opts['addremove']:
         cmdutil.addremove(repo, pats, opts)
     fns, match, anypats = cmdutil.matchpats(repo, pats, opts)
     if pats:
         status = repo.status(files=fns, match=match)
         modified, added, removed, deleted, unknown = status[:5]
         files = modified + added + removed
         slist = None
         for f in fns:
             if f == '.':
                 continue
             if f not in files:
                 rf = repo.wjoin(f)
                 try:
                     mode = os.lstat(rf)[stat.ST_MODE]
                 except OSError:
                     raise util.Abort(_("file %s not found!") % rf)
                 if stat.S_ISDIR(mode):
                     name = f + '/'
                     if slist is None:
                         slist = list(files)
                         slist.sort()
                     i = bisect.bisect(slist, name)
                     if i >= len(slist) or not slist[i].startswith(name):
                         raise util.Abort(_("no match under directory %s!")
                                          % rf)
                 elif not (stat.S_ISREG(mode) or stat.S_ISLNK(mode)):
                     raise util.Abort(_("can't commit %s: "
                                        "unsupported file type!") % rf)
                 elif f not in repo.dirstate:
                     raise util.Abort(_("file %s not tracked!") % rf)
     else:
         files = []
     try:
         repo.commit(files, message, opts['user'], opts['date'], match,
                     force_editor=opts.get('force_editor'))
     except ValueError, inst:
         raise util.Abort(str(inst))
 
 def docopy(ui, repo, pats, opts):
     # 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()
     errors = 0
     copied = []
     targets = {}
 
     # abs: hgsep
     # rel: ossep
     # return: hgsep
     def okaytocopy(abs, rel, exact):
         reasons = {'?': _('is not managed'),
                    'r': _('has been marked for remove')}
         state = repo.dirstate[abs]
         reason = reasons.get(state)
         if reason:
             if exact:
                 ui.warn(_('%s: not copying - file %s\n') % (rel, reason))
         else:
             if state == 'a':
                 origsrc = repo.dirstate.copied(abs)
                 if origsrc is not None:
                     return origsrc
             return abs
 
     # origsrc: hgsep
     # abssrc: hgsep
     # relsrc: ossep
     # otarget: ossep
     def copy(origsrc, abssrc, relsrc, otarget, exact):
         abstarget = util.canonpath(repo.root, cwd, otarget)
         reltarget = repo.pathto(abstarget, cwd)
         prevsrc = targets.get(abstarget)
         src = repo.wjoin(abssrc)
         target = repo.wjoin(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
         if (not opts['after'] and os.path.exists(target) or
             opts['after'] and repo.dirstate[abstarget] in 'mn'):
             if not opts['force']:
                 ui.warn(_('%s: not overwriting - file exists\n') %
                         reltarget)
                 return
             if not opts['after'] and not opts.get('dry_run'):
                 os.unlink(target)
         if opts['after']:
             if not os.path.exists(target):
                 return
         else:
             targetdir = os.path.dirname(target) or '.'
             if not os.path.isdir(targetdir) and not opts.get('dry_run'):
                 os.makedirs(targetdir)
             try:
                 restore = repo.dirstate[abstarget] == 'r'
                 if restore and not opts.get('dry_run'):
                     repo.undelete([abstarget])
                 try:
                     if not opts.get('dry_run'):
                         util.copyfile(src, target)
                     restore = False
                 finally:
                     if restore:
                         repo.remove([abstarget])
             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))
                     errors += 1
                     return
         if ui.verbose or not exact:
             ui.status(_('copying %s to %s\n') % (relsrc, reltarget))
         targets[abstarget] = abssrc
         if abstarget != origsrc:
             if repo.dirstate[origsrc] == 'a':
                 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 abstarget not in repo.dirstate and not opts.get('dry_run'):
                     repo.add([abstarget])
             elif not opts.get('dry_run'):
                 repo.copy(origsrc, abstarget)
         copied.append((abssrc, relsrc, exact))
 
     # 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)
     if (len(pats) > 1 or util.patkind(pats[0], None)[0]) and not destdirexists:
         raise util.Abort(_('with multiple sources, destination must be an '
                          'existing directory'))
     if opts['after']:
         tfn = targetpathafterfn
     else:
         tfn = targetpathfn
     copylist = []
     for pat in pats:
         srcs = []
         for tag, abssrc, relsrc, exact in cmdutil.walk(repo, [pat], opts,
                                                        globbed=True):
             origsrc = okaytocopy(abssrc, relsrc, exact)
             if origsrc:
                 srcs.append((origsrc, abssrc, relsrc, exact))
         if not srcs:
             continue
         copylist.append((tfn(pat, dest, srcs), srcs))
     if not copylist:
         raise util.Abort(_('no files to copy'))
 
     for targetpath, srcs in copylist:
         for origsrc, abssrc, relsrc, exact in srcs:
             copy(origsrc, abssrc, relsrc, targetpath(abssrc), exact)
 
     if errors:
         ui.warn(_('(consider using --after)\n'))
     return errors, copied
 
 def copy(ui, repo, *pats, **opts):
     """mark files as copied for the next commit
 
     Mark dest as having copies of source files.  If dest is a
     directory, copies are put in that directory.  If dest is a file,
     there can only be one source.
 
     By default, this command copies the contents of files as they
     stand in the working directory.  If invoked with --after, the
     operation is recorded, but no copying is performed.
 
     This command takes effect in the next commit. To undo a copy
     before that, see hg revert.
     """
     wlock = repo.wlock(False)
     try:
         errs, copied = docopy(ui, repo, pats, opts)
     finally:
         del wlock
     return errs
 
 def debugancestor(ui, index, rev1, rev2):
     """find the ancestor revision of two revisions in a given index"""
     r = revlog.revlog(util.opener(os.getcwd(), audit=False), index)
     a = r.ancestor(r.lookup(rev1), r.lookup(rev2))
     ui.write("%d:%s\n" % (r.rev(a), hex(a)))
 
 def debugcomplete(ui, cmd='', **opts):
     """returns the completion list associated with the given command"""
 
     if opts['options']:
         options = []
         otables = [globalopts]
         if cmd:
             aliases, entry = cmdutil.findcmd(ui, cmd)
             otables.append(entry[1])
         for t in otables:
             for o in t:
                 if o[0]:
                     options.append('-%s' % o[0])
                 options.append('--%s' % o[1])
         ui.write("%s\n" % "\n".join(options))
         return
 
     clist = cmdutil.findpossible(ui, cmd).keys()
     clist.sort()
     ui.write("%s\n" % "\n".join(clist))
 
 def debugrebuildstate(ui, repo, rev=""):
     """rebuild the dirstate as it would look like for the given revision"""
     if rev == "":
         rev = repo.changelog.tip()
     ctx = repo.changectx(rev)
     files = ctx.manifest()
     wlock = repo.wlock()
     try:
         repo.dirstate.rebuild(rev, files)
     finally:
         del wlock
 
 def debugcheckstate(ui, repo):
     """validate the correctness of the current dirstate"""
     parent1, parent2 = repo.dirstate.parents()
     m1 = repo.changectx(parent1).manifest()
     m2 = repo.changectx(parent2).manifest()
     errors = 0
     for f in repo.dirstate:
         state = repo.dirstate[f]
         if state in "nr" and f not in m1:
             ui.warn(_("%s in state %s, but not in manifest1\n") % (f, state))
             errors += 1
         if state in "a" and f in m1:
             ui.warn(_("%s in state %s, but also in manifest1\n") % (f, state))
             errors += 1
         if state in "m" and f not in m1 and f not in m2:
             ui.warn(_("%s in state %s, but not in either manifest\n") %
                     (f, state))
             errors += 1
     for f in m1:
         state = repo.dirstate[f]
         if state not in "nrm":
             ui.warn(_("%s in manifest1, but listed as state %s") % (f, state))
             errors += 1
     if errors:
         error = _(".hg/dirstate inconsistent with current parent's manifest")
         raise util.Abort(error)
 
 def showconfig(ui, repo, *values, **opts):
     """show combined config settings from all hgrc files
 
     With no args, print names and values of all config items.
 
     With one arg of the form section.name, print just the value of
     that config item.
 
     With multiple args, print names and values of all config items
     with matching section names."""
 
     untrusted = bool(opts.get('untrusted'))
     if values:
         if len([v for v in values if '.' in v]) > 1:
             raise util.Abort(_('only one config item permitted'))
     for section, name, value in ui.walkconfig(untrusted=untrusted):
         sectname = section + '.' + name
         if values:
             for v in values:
                 if v == section:
                     ui.write('%s=%s\n' % (sectname, value))
                 elif v == sectname:
                     ui.write(value, '\n')
         else:
             ui.write('%s=%s\n' % (sectname, value))
 
 def debugsetparents(ui, repo, rev1, rev2=None):
     """manually set the parents of the current working directory
 
     This is useful for writing repository conversion tools, but should
     be used with care.
     """
 
     if not rev2:
         rev2 = hex(nullid)
 
     wlock = repo.wlock()
     try:
         repo.dirstate.setparents(repo.lookup(rev1), repo.lookup(rev2))
     finally:
         del wlock
 
 def debugstate(ui, repo):
     """show the contents of the current dirstate"""
     dc = repo.dirstate._map
     k = dc.keys()
     k.sort()
     for file_ in k:
         if dc[file_][3] == -1:
             # Pad or slice to locale representation
             locale_len = len(time.strftime("%x %X", time.localtime(0)))
             timestr = 'unset'
             timestr = timestr[:locale_len] + ' '*(locale_len - len(timestr))
         else:
             timestr = time.strftime("%x %X", time.localtime(dc[file_][3]))
         ui.write("%c %3o %10d %s %s\n"
                  % (dc[file_][0], dc[file_][1] & 0777, dc[file_][2],
                     timestr, file_))
     for f in repo.dirstate.copies():
         ui.write(_("copy: %s -> %s\n") % (repo.dirstate.copied(f), f))
 
 def debugdata(ui, file_, rev):
     """dump the contents of a data file revision"""
     r = revlog.revlog(util.opener(os.getcwd(), audit=False), file_[:-2] + ".i")
     try:
         ui.write(r.revision(r.lookup(rev)))
     except KeyError:
         raise util.Abort(_('invalid revision identifier %s') % rev)
 
 def debugdate(ui, date, range=None, **opts):
     """parse and display a date"""
     if opts["extended"]:
         d = util.parsedate(date, util.extendeddateformats)
     else:
         d = util.parsedate(date)
     ui.write("internal: %s %s\n" % d)
     ui.write("standard: %s\n" % util.datestr(d))
     if range:
         m = util.matchdate(range)
         ui.write("match: %s\n" % m(d[0]))
 
 def debugindex(ui, file_):
     """dump the contents of an index file"""
     r = revlog.revlog(util.opener(os.getcwd(), audit=False), file_)
     ui.write("   rev    offset  length   base linkrev" +
              " nodeid       p1           p2\n")
     for i in xrange(r.count()):
         node = r.node(i)
         pp = r.parents(node)
         ui.write("% 6d % 9d % 7d % 6d % 7d %s %s %s\n" % (
                 i, r.start(i), r.length(i), r.base(i), r.linkrev(node),
             short(node), short(pp[0]), short(pp[1])))
 
 def debugindexdot(ui, file_):
     """dump an index DAG as a .dot file"""
     r = revlog.revlog(util.opener(os.getcwd(), audit=False), file_)
     ui.write("digraph G {\n")
     for i in xrange(r.count()):
         node = r.node(i)
         pp = r.parents(node)
         ui.write("\t%d -> %d\n" % (r.rev(pp[0]), i))
         if pp[1] != nullid:
             ui.write("\t%d -> %d\n" % (r.rev(pp[1]), i))
     ui.write("}\n")
 
 def debuginstall(ui):
     '''test Mercurial installation'''
 
     def writetemp(contents):
         (fd, name) = tempfile.mkstemp(prefix="hg-debuginstall-")
         f = os.fdopen(fd, "wb")
         f.write(contents)
         f.close()
         return name
 
     problems = 0
 
     # encoding
     ui.status(_("Checking encoding (%s)...\n") % util._encoding)
     try:
         util.fromlocal("test")
     except util.Abort, inst:
         ui.write(" %s\n" % inst)
         ui.write(_(" (check that your locale is properly set)\n"))
         problems += 1
 
     # compiled modules
     ui.status(_("Checking extensions...\n"))
     try:
         import bdiff, mpatch, base85
     except Exception, inst:
         ui.write(" %s\n" % inst)
         ui.write(_(" One or more extensions could not be found"))
         ui.write(_(" (check that you compiled the extensions)\n"))
         problems += 1
 
     # templates
     ui.status(_("Checking templates...\n"))
     try:
         import templater
         t = templater.templater(templater.templatepath("map-cmdline.default"))
     except Exception, inst:
         ui.write(" %s\n" % inst)
         ui.write(_(" (templates seem to have been installed incorrectly)\n"))
         problems += 1
 
     # patch
     ui.status(_("Checking patch...\n"))
     patcher = ui.config('ui', 'patch')
     patcher = ((patcher and util.find_exe(patcher)) or
                util.find_exe('gpatch') or
                util.find_exe('patch'))
     if not patcher:
         ui.write(_(" Can't find patch or gpatch in PATH\n"))
         ui.write(_(" (specify a patch utility in your .hgrc file)\n"))
         problems += 1
     else:
         # actually attempt a patch here
         a = "1\n2\n3\n4\n"
         b = "1\n2\n3\ninsert\n4\n"
         fa = writetemp(a)
         d = mdiff.unidiff(a, None, b, None, os.path.basename(fa))
         fd = writetemp(d)
 
         files = {}
         try:
             patch.patch(fd, ui, cwd=os.path.dirname(fa), files=files)
         except util.Abort, e:
             ui.write(_(" patch call failed:\n"))
             ui.write(" " + str(e) + "\n")
             problems += 1
         else:
             if list(files) != [os.path.basename(fa)]:
                 ui.write(_(" unexpected patch output!"))
                 ui.write(_(" (you may have an incompatible version of patch)\n"))
                 problems += 1
             a = file(fa).read()
             if a != b:
                 ui.write(_(" patch test failed!"))
                 ui.write(_(" (you may have an incompatible version of patch)\n"))
                 problems += 1
 
         os.unlink(fa)
         os.unlink(fd)
 
     # merge helper
     ui.status(_("Checking merge helper...\n"))
     cmd = (os.environ.get("HGMERGE") or ui.config("ui", "merge")
            or "hgmerge")
     cmdpath = util.find_exe(cmd) or util.find_exe(cmd.split()[0])
     if not cmdpath:
         if cmd == 'hgmerge':
             ui.write(_(" No merge helper set and can't find default"
                        " hgmerge script in PATH\n"))
             ui.write(_(" (specify a merge helper in your .hgrc file)\n"))
         else:
             ui.write(_(" Can't find merge helper '%s' in PATH\n") % cmd)
             ui.write(_(" (specify a merge helper in your .hgrc file)\n"))
             problems += 1
     else:
         # actually attempt a patch here
         fa = writetemp("1\n2\n3\n4\n")
         fl = writetemp("1\n2\n3\ninsert\n4\n")
         fr = writetemp("begin\n1\n2\n3\n4\n")
         r = util.system('%s "%s" "%s" "%s"' % (cmd, fl, fa, fr))
         if r:
             ui.write(_(" Got unexpected merge error %d!\n") % r)
             problems += 1
         m = file(fl).read()
         if m != "begin\n1\n2\n3\ninsert\n4\n":
             ui.write(_(" Got unexpected merge results!\n"))
             ui.write(_(" (your merge helper may have the"
                        " wrong argument order)\n"))
             ui.write(_(" Result: %r\n") % m)
             problems += 1
         os.unlink(fa)
         os.unlink(fl)
         os.unlink(fr)
 
     # editor
     ui.status(_("Checking commit editor...\n"))
     editor = (os.environ.get("HGEDITOR") or
               ui.config("ui", "editor") or
               os.environ.get("EDITOR", "vi"))
     cmdpath = util.find_exe(editor) or util.find_exe(editor.split()[0])
     if not cmdpath:
         if editor == 'vi':
             ui.write(_(" No commit editor set and can't find vi in PATH\n"))
             ui.write(_(" (specify a commit editor in your .hgrc file)\n"))
         else:
             ui.write(_(" Can't find editor '%s' in PATH\n") % editor)
             ui.write(_(" (specify a commit editor in your .hgrc file)\n"))
             problems += 1
 
     # check username
     ui.status(_("Checking username...\n"))
     user = os.environ.get("HGUSER")
     if user is None:
         user = ui.config("ui", "username")
     if user is None:
         user = os.environ.get("EMAIL")
     if not user:
         ui.warn(" ")
         ui.username()
         ui.write(_(" (specify a username in your .hgrc file)\n"))
 
     if not problems:
         ui.status(_("No problems detected\n"))
     else:
         ui.write(_("%s problems detected,"
                    " please check your install!\n") % problems)
 
     return problems
 
 def debugrename(ui, repo, file1, *pats, **opts):
     """dump rename information"""
 
     ctx = repo.changectx(opts.get('rev', 'tip'))
     for src, abs, rel, exact in cmdutil.walk(repo, (file1,) + pats, opts,
                                              ctx.node()):
         m = ctx.filectx(abs).renamed()
         if m:
             ui.write(_("%s renamed from %s:%s\n") % (rel, m[0], hex(m[1])))
         else:
             ui.write(_("%s not renamed\n") % rel)
 
 def debugwalk(ui, repo, *pats, **opts):
     """show how files match on given patterns"""
     items = list(cmdutil.walk(repo, pats, opts))
     if not items:
         return
     fmt = '%%s  %%-%ds  %%-%ds  %%s' % (
         max([len(abs) for (src, abs, rel, exact) in items]),
         max([len(rel) for (src, abs, rel, exact) in items]))
     for src, abs, rel, exact in items:
         line = fmt % (src, abs, rel, exact and 'exact' or '')
         ui.write("%s\n" % line.rstrip())
 
 def diff(ui, repo, *pats, **opts):
     """diff repository (or selected files)
 
     Show differences between revisions for the specified files.
 
     Differences between files are shown using the unified diff format.
 
     NOTE: diff may generate unexpected results for merges, as it will
     default to comparing against the working directory's first parent
     changeset if no revisions are specified.
 
     When two revision arguments are given, then changes are shown
     between those revisions. If only one revision is specified then
     that revision is compared to the working directory, and, when no
     revisions are specified, the working directory files are compared
     to its parent.
 
     Without the -a option, diff will avoid generating diffs of files
     it detects as binary. With -a, diff will generate a diff anyway,
     probably with undesirable results.
     """
     node1, node2 = cmdutil.revpair(repo, opts['rev'])
 
     fns, matchfn, anypats = cmdutil.matchpats(repo, pats, opts)
 
     patch.diff(repo, node1, node2, fns, match=matchfn,
                opts=patch.diffopts(ui, opts))
 
 def export(ui, repo, *changesets, **opts):
     """dump the header and diffs for one or more changesets
 
     Print the changeset header and diffs for one or more revisions.
 
     The information shown in the changeset header is: author,
     changeset hash, parent(s) and commit comment.
 
     NOTE: export may generate unexpected diff output for merge changesets,
     as it will compare the merge changeset against its first parent only.
 
     Output may be to a file, in which case the name of the file is
     given using a format string.  The formatting rules are as follows:
 
     %%   literal "%" character
     %H   changeset hash (40 bytes of hexadecimal)
     %N   number of patches being generated
     %R   changeset revision number
     %b   basename of the exporting repository
     %h   short-form changeset hash (12 bytes of hexadecimal)
     %n   zero-padded sequence number, starting at 1
     %r   zero-padded changeset revision number
 
     Without the -a option, export will avoid generating diffs of files
     it detects as binary. With -a, export will generate a diff anyway,
     probably with undesirable results.
 
     With the --switch-parent option, the diff will be against the second
     parent. It can be useful to review a merge.
     """
     if not changesets:
         raise util.Abort(_("export requires at least one changeset"))
     revs = cmdutil.revrange(repo, changesets)
     if len(revs) > 1:
         ui.note(_('exporting patches:\n'))
     else:
         ui.note(_('exporting patch:\n'))
     patch.export(repo, revs, template=opts['output'],
                  switch_parent=opts['switch_parent'],
                  opts=patch.diffopts(ui, opts))
 
 def grep(ui, repo, pattern, *pats, **opts):
     """search for a pattern in specified files and revisions
 
     Search revisions of files for a regular expression.
 
     This command behaves differently than Unix grep.  It only accepts
     Python/Perl regexps.  It searches repository history, not the
     working directory.  It always prints the revision number in which
     a match appears.
 
     By default, grep only prints output for the first revision of a
     file in which it finds a match.  To get it to print every revision
     that contains a change in match status ("-" for a match that
     becomes a non-match, or "+" for a non-match that becomes a match),
     use the --all flag.
     """
     reflags = 0
     if opts['ignore_case']:
         reflags |= re.I
     try:
         regexp = re.compile(pattern, reflags)
     except Exception, inst:
         ui.warn(_("grep: invalid match pattern: %s!\n") % inst)
         return None
     sep, eol = ':', '\n'
     if opts['print0']:
         sep = eol = '\0'
 
     fcache = {}
     def getfile(fn):
         if fn not in fcache:
             fcache[fn] = repo.file(fn)
         return fcache[fn]
 
     def matchlines(body):
         begin = 0
         linenum = 0
         while True:
             match = regexp.search(body, begin)
             if not match:
                 break
             mstart, mend = match.span()
             linenum += body.count('\n', begin, mstart) + 1
             lstart = body.rfind('\n', begin, mstart) + 1 or begin
             lend = body.find('\n', mend)
             yield linenum, mstart - lstart, mend - lstart, body[lstart:lend]
             begin = lend + 1
 
     class linestate(object):
         def __init__(self, line, linenum, colstart, colend):
             self.line = line
             self.linenum = linenum
             self.colstart = colstart
             self.colend = colend
 
         def __eq__(self, other):
             return self.line == other.line
 
     matches = {}
     copies = {}
     def grepbody(fn, rev, body):
         matches[rev].setdefault(fn, [])
         m = matches[rev][fn]
         for lnum, cstart, cend, line in matchlines(body):
             s = linestate(line, lnum, cstart, cend)
             m.append(s)
 
     def difflinestates(a, b):
         sm = difflib.SequenceMatcher(None, a, b)
         for tag, alo, ahi, blo, bhi in sm.get_opcodes():
             if tag == 'insert':
                 for i in xrange(blo, bhi):
                     yield ('+', b[i])
             elif tag == 'delete':
                 for i in xrange(alo, ahi):
                     yield ('-', a[i])
             elif tag == 'replace':
                 for i in xrange(alo, ahi):
                     yield ('-', a[i])
                 for i in xrange(blo, bhi):
                     yield ('+', b[i])
 
     prev = {}
     def display(fn, rev, states, prevstates):
         found = False
         filerevmatches = {}
         r = prev.get(fn, -1)
         if opts['all']:
             iter = difflinestates(states, prevstates)
         else:
             iter = [('', l) for l in prevstates]
         for change, l in iter:
             cols = [fn, str(r)]
             if opts['line_number']:
                 cols.append(str(l.linenum))
             if opts['all']:
                 cols.append(change)
             if opts['user']:
                 cols.append(ui.shortuser(get(r)[1]))
             if opts['files_with_matches']:
                 c = (fn, r)
                 if c in filerevmatches:
                     continue
                 filerevmatches[c] = 1
             else:
                 cols.append(l.line)
             ui.write(sep.join(cols), eol)
             found = True
         return found
 
     fstate = {}
     skip = {}
     get = util.cachefunc(lambda r: repo.changectx(r).changeset())
     changeiter, matchfn = cmdutil.walkchangerevs(ui, repo, pats, get, opts)
     found = False
     follow = opts.get('follow')
     for st, rev, fns in changeiter:
         if st == 'window':
             matches.clear()
         elif st == 'add':
             mf = repo.changectx(rev).manifest()
             matches[rev] = {}
             for fn in fns:
                 if fn in skip:
                     continue
                 fstate.setdefault(fn, {})
                 try:
                     grepbody(fn, rev, getfile(fn).read(mf[fn]))
                     if follow:
                         copied = getfile(fn).renamed(mf[fn])
                         if copied:
                             copies.setdefault(rev, {})[fn] = copied[0]
                 except KeyError:
                     pass
         elif st == 'iter':
             states = matches[rev].items()
             states.sort()
             for fn, m in states:
                 copy = copies.get(rev, {}).get(fn)
                 if fn in skip:
                     if copy:
                         skip[copy] = True
                     continue
                 if fn in prev or fstate[fn]:
                     r = display(fn, rev, m, fstate[fn])
                     found = found or r
                     if r and not opts['all']:
                         skip[fn] = True
                         if copy:
                             skip[copy] = True
                 fstate[fn] = m
                 if copy:
                     fstate[copy] = m
                 prev[fn] = rev
 
     fstate = fstate.items()
     fstate.sort()
     for fn, state in fstate:
         if fn in skip:
             continue
         if fn not in copies.get(prev[fn], {}):
             found = display(fn, rev, {}, state) or found
     return (not found and 1) or 0
 
 def heads(ui, repo, *branchrevs, **opts):
     """show current repository heads or show branch heads
 
     With no arguments, show all repository head changesets.
 
     If branch or revisions names are given this will show the heads of
     the specified branches or the branches those revisions are tagged
     with.
 
     Repository "heads" are changesets that don't have child
     changesets. They are where development generally takes place and
     are the usual targets for update and merge operations.
 
     Branch heads are changesets that have a given branch tag, but have
     no child changesets with that tag.  They are usually where
     development on the given branch takes place.
     """
     if opts['rev']:
         start = repo.lookup(opts['rev'])
     else:
         start = None
     if not branchrevs:
         # Assume we're looking repo-wide heads if no revs were specified.
         heads = repo.heads(start)
     else:
         heads = []
         visitedset = util.set()
         for branchrev in branchrevs:
             branch = repo.changectx(branchrev).branch()
             if branch in visitedset:
                 continue
             visitedset.add(branch)
             bheads = repo.branchheads(branch, start)
             if not bheads:
                 if branch != branchrev:
                     ui.warn(_("no changes on branch %s containing %s are "
                               "reachable from %s\n")
                             % (branch, branchrev, opts['rev']))
                 else:
                     ui.warn(_("no changes on branch %s are reachable from %s\n")
                             % (branch, opts['rev']))
             heads.extend(bheads)
     if not heads:
         return 1
     displayer = cmdutil.show_changeset(ui, repo, opts)
     for n in heads:
         displayer.show(changenode=n)
 
 def help_(ui, name=None, with_version=False):
     """show help for a command, extension, or list of commands
 
     With no arguments, print a list of commands and short help.
 
     Given a command name, print help for that command.
 
     Given an extension name, print help for that extension, and the
     commands it provides."""
     option_lists = []
 
     def addglobalopts(aliases):
         if ui.verbose:
             option_lists.append((_("global options:"), globalopts))
             if name == 'shortlist':
                 option_lists.append((_('use "hg help" for the full list '
                                        'of commands'), ()))
         else:
             if name == 'shortlist':
                 msg = _('use "hg help" for the full list of commands '
                         'or "hg -v" for details')
             elif aliases:
                 msg = _('use "hg -v help%s" to show aliases and '
                         'global options') % (name and " " + name or "")
             else:
                 msg = _('use "hg -v help %s" to show global options') % name
             option_lists.append((msg, ()))
 
     def helpcmd(name):
         if with_version:
             version_(ui)
             ui.write('\n')
         aliases, i = cmdutil.findcmd(ui, name)
         # synopsis
         ui.write("%s\n\n" % i[2])
 
         # description
         doc = i[0].__doc__
         if not doc:
             doc = _("(No help text available)")
         if ui.quiet:
             doc = doc.splitlines(0)[0]
         ui.write("%s\n" % doc.rstrip())
 
         if not ui.quiet:
             # aliases
             if len(aliases) > 1:
                 ui.write(_("\naliases: %s\n") % ', '.join(aliases[1:]))
 
             # options
             if i[1]:
                 option_lists.append((_("options:\n"), i[1]))
 
             addglobalopts(False)
 
-    def helplist(select=None):
+    def helplist(header, select=None):
         h = {}
         cmds = {}
         for c, e in table.items():
             f = c.split("|", 1)[0]
             if select and not select(f):
                 continue
             if name == "shortlist" and not f.startswith("^"):
                 continue
             f = f.lstrip("^")
             if not ui.debugflag and f.startswith("debug"):
                 continue
             doc = e[0].__doc__
             if not doc:
                 doc = _("(No help text available)")
             h[f] = doc.splitlines(0)[0].rstrip()
             cmds[f] = c.lstrip("^")
 
+        if not h:
+            ui.status(_('no commands defined\n'))
+            return
+
+        ui.status(header)
         fns = h.keys()
         fns.sort()
         m = max(map(len, fns))
         for f in fns:
             if ui.verbose:
                 commands = cmds[f].replace("|",", ")
                 ui.write(" %s:\n      %s\n"%(commands, h[f]))
             else:
                 ui.write(' %-*s   %s\n' % (m, f, h[f]))
 
         if not ui.quiet:
             addglobalopts(True)
 
     def helptopic(name):
         v = None
         for i in help.helptable:
             l = i.split('|')
             if name in l:
                 v = i
                 header = l[-1]
         if not v:
             raise cmdutil.UnknownCommand(name)
 
         # description
         doc = help.helptable[v]
         if not doc:
             doc = _("(No help text available)")
         if callable(doc):
             doc = doc()
 
         ui.write("%s\n" % header)
         ui.write("%s\n" % doc.rstrip())
 
     def helpext(name):
         try:
             mod = extensions.find(name)
         except KeyError:
             raise cmdutil.UnknownCommand(name)
 
         doc = (mod.__doc__ or _('No help text available')).splitlines(0)
         ui.write(_('%s extension - %s\n') % (name.split('.')[-1], doc[0]))
         for d in doc[1:]:
             ui.write(d, '\n')
 
         ui.status('\n')
 
         try:
             ct = mod.cmdtable
         except AttributeError:
-            ct = None
-        if not ct:
-            ui.status(_('no commands defined\n'))
-            return
-
-        ui.status(_('list of commands:\n\n'))
+            ct = {}
+
         modcmds = dict.fromkeys([c.split('|', 1)[0] for c in ct])
-        helplist(modcmds.has_key)
+        helplist(_('list of commands:\n\n'), modcmds.has_key)
 
     if name and name != 'shortlist':
         i = None
         for f in (helpcmd, helptopic, helpext):
             try:
                 f(name)
                 i = None
                 break
             except cmdutil.UnknownCommand, inst:
                 i = inst
         if i:
             raise i
 
     else:
         # program name
         if ui.verbose or with_version:
             version_(ui)
         else:
             ui.status(_("Mercurial Distributed SCM\n"))
         ui.status('\n')
 
         # list of commands
         if name == "shortlist":
-            ui.status(_('basic commands:\n\n'))
+            header = _('basic commands:\n\n')
         else:
-            ui.status(_('list of commands:\n\n'))
-
-        helplist()
+            header = _('list of commands:\n\n')
+
+        helplist(header)
 
     # list all option lists
     opt_output = []
     for title, options in option_lists:
         opt_output.append(("\n%s" % title, None))
         for shortopt, longopt, default, desc in options:
             if "DEPRECATED" in desc and not ui.verbose: continue
             opt_output.append(("%2s%s" % (shortopt and "-%s" % shortopt,
                                           longopt and " --%s" % longopt),
                                "%s%s" % (desc,
                                          default
                                          and _(" (default: %s)") % default
                                          or "")))
 
     if opt_output:
         opts_len = max([len(line[0]) for line in opt_output if line[1]] or [0])
         for first, second in opt_output:
             if second:
                 ui.write(" %-*s  %s\n" % (opts_len, first, second))
             else:
                 ui.write("%s\n" % first)
 
 def identify(ui, repo, source=None,
              rev=None, num=None, id=None, branch=None, tags=None):
     """identify the working copy or specified revision
 
     With no revision, print a summary of the current state of the repo.
 
     With a path, do a lookup in another repository.
 
     This summary identifies the repository state using one or two parent
     hash identifiers, followed by a "+" if there are uncommitted changes
     in the working directory, a list of tags for this revision and a branch
     name for non-default branches.
     """
 
     hexfunc = ui.debugflag and hex or short
     default = not (num or id or branch or tags)
     output = []
 
     if source:
         source, revs = cmdutil.parseurl(ui.expandpath(source), [])
         srepo = hg.repository(ui, source)
         if not rev and revs:
             rev = revs[0]
         if not rev:
             rev = "tip"
         if num or branch or tags:
             raise util.Abort(
                 "can't query remote revision number, branch, or tags")
         output = [hexfunc(srepo.lookup(rev))]
     elif not rev:
         ctx = repo.workingctx()
         parents = ctx.parents()
         changed = False
         if default or id or num:
             changed = ctx.files() + ctx.deleted()
         if default or id:
             output = ["%s%s" % ('+'.join([hexfunc(p.node()) for p in parents]),
                                 (changed) and "+" or "")]
         if num:
             output.append("%s%s" % ('+'.join([str(p.rev()) for p in parents]),
                                     (changed) and "+" or ""))
     else:
         ctx = repo.changectx(rev)
         if default or id:
             output = [hexfunc(ctx.node())]
         if num:
             output.append(str(ctx.rev()))
 
     if not source and default and not ui.quiet:
         b = util.tolocal(ctx.branch())
         if b != 'default':
             output.append("(%s)" % b)
 
         # multiple tags for a single parent separated by '/'
         t = "/".join(ctx.tags())
         if t:
             output.append(t)
 
     if branch:
         output.append(util.tolocal(ctx.branch()))
 
     if tags:
         output.extend(ctx.tags())
 
     ui.write("%s\n" % ' '.join(output))
 
 def import_(ui, repo, patch1, *patches, **opts):
     """import an ordered set of patches
 
     Import a list of patches and commit them individually.
 
     If there are outstanding changes in the working directory, import
     will abort unless given the -f flag.
 
     You can import a patch straight from a mail message.  Even patches
     as attachments work (body part must be type text/plain or
     text/x-patch to be used).  From and Subject headers of email
     message are used as default committer and commit message.  All
     text/plain body parts before first diff are added to commit
     message.
 
     If the imported patch was generated by hg export, user and description
     from patch override values from message headers and body.  Values
     given on command line with -m and -u override these.
 
     If --exact is specified, import will set the working directory
     to the parent of each patch before applying it, and will abort
     if the resulting changeset has a different ID than the one
     recorded in the patch. This may happen due to character set
     problems or other deficiencies in the text patch format.
 
     To read a patch from standard input, use patch name "-".
     """
     patches = (patch1,) + patches
 
     if opts.get('exact') or not opts['force']:
         cmdutil.bail_if_changed(repo)
 
     d = opts["base"]
     strip = opts["strip"]
     wlock = lock = None
     try:
         wlock = repo.wlock()
         lock = repo.lock()
         for p in patches:
             pf = os.path.join(d, p)
 
             if pf == '-':
                 ui.status(_("applying patch from stdin\n"))
                 data = patch.extract(ui, sys.stdin)
             else:
                 ui.status(_("applying %s\n") % p)
                 data = patch.extract(ui, file(pf, 'rb'))
 
             tmpname, message, user, date, branch, nodeid, p1, p2 = data
 
             if tmpname is None:
                 raise util.Abort(_('no diffs found'))
 
             try:
                 cmdline_message = cmdutil.logmessage(opts)
                 if cmdline_message:
                     # pickup the cmdline msg
                     message = cmdline_message
                 elif message:
                     # pickup the patch msg
                     message = message.strip()
                 else:
                     # launch the editor
                     message = None
                 ui.debug(_('message:\n%s\n') % message)
 
                 wp = repo.workingctx().parents()
                 if opts.get('exact'):
                     if not nodeid or not p1:
                         raise util.Abort(_('not a mercurial patch'))
                     p1 = repo.lookup(p1)
                     p2 = repo.lookup(p2 or hex(nullid))
 
                     if p1 != wp[0].node():
                         hg.clean(repo, p1)
                     repo.dirstate.setparents(p1, p2)
                 elif p2:
                     try:
                         p1 = repo.lookup(p1)
                         p2 = repo.lookup(p2)
                         if p1 == wp[0].node():
                             repo.dirstate.setparents(p1, p2)
                     except hg.RepoError:
                         pass
                 if opts.get('exact') or opts.get('import_branch'):
                     repo.dirstate.setbranch(branch or 'default')
 
                 files = {}
                 try:
                     fuzz = patch.patch(tmpname, ui, strip=strip, cwd=repo.root,
                                        files=files)
                 finally:
                     files = patch.updatedir(ui, repo, files)
                 n = repo.commit(files, message, user, date)
                 if opts.get('exact'):
                     if hex(n) != nodeid:
                         repo.rollback()
                         raise util.Abort(_('patch is damaged' +
                                            ' or loses information'))
             finally:
                 os.unlink(tmpname)
     finally:
         del wlock, lock
 
 def incoming(ui, repo, source="default", **opts):
     """show new changesets found in source
 
     Show new changesets found in the specified path/URL or the default
     pull location. These are the changesets that would be pulled if a pull
     was requested.
 
     For remote repository, using --bundle avoids downloading the changesets
     twice if the incoming is followed by a pull.
 
     See pull for valid source format details.
     """
     source, revs = cmdutil.parseurl(ui.expandpath(source), opts['rev'])
     cmdutil.setremoteconfig(ui, opts)
 
     other = hg.repository(ui, source)
     ui.status(_('comparing with %s\n') % source)
     if revs:
         if 'lookup' in other.capabilities:
             revs = [other.lookup(rev) for rev in revs]
         else:
             error = _("Other repository doesn't support revision lookup, so a rev cannot be specified.")
             raise util.Abort(error)
     incoming = repo.findincoming(other, heads=revs, force=opts["force"])
     if not incoming:
         try:
             os.unlink(opts["bundle"])
         except:
             pass
         ui.status(_("no changes found\n"))
         return 1
 
     cleanup = None
     try:
         fname = opts["bundle"]
         if fname or not other.local():
             # create a bundle (uncompressed if other repo is not local)
             if revs is None:
                 cg = other.changegroup(incoming, "incoming")
             else:
                 if 'changegroupsubset' not in other.capabilities:
                     raise util.Abort(_("Partial incoming cannot be done because other repository doesn't support changegroupsubset."))
                 cg = other.changegroupsubset(incoming, revs, 'incoming')
             bundletype = other.local() and "HG10BZ" or "HG10UN"
             fname = cleanup = changegroup.writebundle(cg, fname, bundletype)
             # keep written bundle?
             if opts["bundle"]:
                 cleanup = None
             if not other.local():
                 # use the created uncompressed bundlerepo
                 other = bundlerepo.bundlerepository(ui, repo.root, fname)
 
         o = other.changelog.nodesbetween(incoming, revs)[0]
         if opts['newest_first']:
             o.reverse()
         displayer = cmdutil.show_changeset(ui, other, opts)
         for n in o:
             parents = [p for p in other.changelog.parents(n) if p != nullid]
             if opts['no_merges'] and len(parents) == 2:
                 continue
             displayer.show(changenode=n)
     finally:
         if hasattr(other, 'close'):
             other.close()
         if cleanup:
             os.unlink(cleanup)
 
 def init(ui, dest=".", **opts):
     """create a new repository in the given directory
 
     Initialize a new repository in the given directory.  If the given
     directory does not exist, it is created.
 
     If no directory is given, the current directory is used.
 
     It is possible to specify an ssh:// URL as the destination.
     Look at the help text for the pull command for important details
     about ssh:// URLs.
     """
     cmdutil.setremoteconfig(ui, opts)
     hg.repository(ui, dest, create=1)
 
 def locate(ui, repo, *pats, **opts):
     """locate files matching specific patterns
 
     Print all files under Mercurial control whose names match the
     given patterns.
 
     This command searches the entire repository by default.  To search
     just the current directory and its subdirectories, use
     "--include .".
 
     If no patterns are given to match, this command prints all file
     names.
 
     If you want to feed the output of this command into the "xargs"
     command, use the "-0" option to both this command and "xargs".
     This will avoid the problem of "xargs" treating single filenames
     that contain white space as multiple filenames.
     """
     end = opts['print0'] and '\0' or '\n'
     rev = opts['rev']
     if rev:
         node = repo.lookup(rev)
     else:
         node = None
 
     ret = 1
     for src, abs, rel, exact in cmdutil.walk(repo, pats, opts, node=node,
                                              badmatch=util.always,
                                              default='relglob'):
         if src == 'b':
             continue
         if not node and abs not in repo.dirstate:
             continue
         if opts['fullpath']:
             ui.write(os.path.join(repo.root, abs), end)
         else:
             ui.write(((pats and rel) or abs), end)
         ret = 0
 
     return ret
 
 def log(ui, repo, *pats, **opts):
     """show revision history of entire repository or files
 
     Print the revision history of the specified files or the entire
     project.
 
     File history is shown without following rename or copy history of
     files.  Use -f/--follow with a file name to follow history across
     renames and copies. --follow without a file name will only show
     ancestors or descendants of the starting revision. --follow-first
     only follows the first parent of merge revisions.
 
     If no revision range is specified, the default is tip:0 unless
     --follow is set, in which case the working directory parent is
     used as the starting revision.
 
     By default this command outputs: changeset id and hash, tags,
     non-trivial parents, user, date and time, and a summary for each
     commit. When the -v/--verbose switch is used, the list of changed
     files and full commit message is shown.
 
     NOTE: log -p may generate unexpected diff output for merge
     changesets, as it will compare the merge changeset against its
     first parent only. Also, the files: list will only reflect files
     that are different from BOTH parents.
 
     """
 
     get = util.cachefunc(lambda r: repo.changectx(r).changeset())
     changeiter, matchfn = cmdutil.walkchangerevs(ui, repo, pats, get, opts)
 
     if opts['limit']:
         try:
             limit = int(opts['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
     count = 0
 
     if opts['copies'] and opts['rev']:
         endrev = max(cmdutil.revrange(repo, opts['rev'])) + 1
     else:
         endrev = repo.changelog.count()
     rcache = {}
     ncache = {}
     dcache = []
     def getrenamed(fn, rev, man):
         '''looks up all renames for a file (up to endrev) the first
         time the file is given. It indexes on the changerev and only
         parses the manifest if linkrev != changerev.
         Returns rename info for fn at changerev rev.'''
         if fn not in rcache:
             rcache[fn] = {}
             ncache[fn] = {}
             fl = repo.file(fn)
             for i in xrange(fl.count()):
                 node = fl.node(i)
                 lr = fl.linkrev(node)
                 renamed = fl.renamed(node)
                 rcache[fn][lr] = renamed
                 if renamed:
                     ncache[fn][node] = renamed
                 if lr >= endrev:
                     break
         if rev in rcache[fn]:
             return rcache[fn][rev]
         mr = repo.manifest.rev(man)
         if repo.manifest.parentrevs(mr) != (mr - 1, nullrev):
             return ncache[fn].get(repo.manifest.find(man, fn)[0])
         if not dcache or dcache[0] != man:
             dcache[:] = [man, repo.manifest.readdelta(man)]
         if fn in dcache[1]:
             return ncache[fn].get(dcache[1][fn])
         return None
 
     df = False
     if opts["date"]:
         df = util.matchdate(opts["date"])
 
     displayer = cmdutil.show_changeset(ui, repo, opts, True, matchfn)
     for st, rev, fns in changeiter:
         if st == 'add':
             changenode = repo.changelog.node(rev)
             parents = [p for p in repo.changelog.parentrevs(rev)
                        if p != nullrev]
             if opts['no_merges'] and len(parents) == 2:
                 continue
             if opts['only_merges'] and len(parents) != 2:
                 continue
 
             if df:
                 changes = get(rev)
                 if not df(changes[2][0]):
                     continue
 
             if opts['keyword']:
                 changes = get(rev)
                 miss = 0
                 for k in [kw.lower() for kw in opts['keyword']]:
                     if not (k in changes[1].lower() or
                             k in changes[4].lower() or
                             k in " ".join(changes[3]).lower()):
                         miss = 1
                         break
                 if miss:
                     continue
 
             copies = []
             if opts.get('copies') and rev:
                 mf = get(rev)[0]
                 for fn in get(rev)[3]:
                     rename = getrenamed(fn, rev, mf)
                     if rename:
                         copies.append((fn, rename[0]))
             displayer.show(rev, changenode, copies=copies)
         elif st == 'iter':
             if count == limit: break
             if displayer.flush(rev):
                 count += 1
 
 def manifest(ui, repo, rev=None):
     """output the current or given revision of the project manifest
 
     Print a list of version controlled files for the given revision.
     If no revision is given, the parent of the working directory is used,
     or tip if no revision is checked out.
 
     The manifest is the list of files being version controlled. If no revision
     is given then the first parent of the working directory is used.
 
     With -v flag, print file permissions. With --debug flag, print
     file revision hashes.
     """
 
     m = repo.changectx(rev).manifest()
     files = m.keys()
     files.sort()
 
     for f in files:
         if ui.debugflag:
             ui.write("%40s " % hex(m[f]))
         if ui.verbose:
             ui.write("%3s " % (m.execf(f) and "755" or "644"))
         ui.write("%s\n" % f)
 
 def merge(ui, repo, node=None, force=None, rev=None):
     """merge working directory with another revision
 
     Merge the contents of the current working directory and the
     requested revision. Files that changed between either parent are
     marked as changed for the next commit and a commit must be
     performed before any further updates are allowed.
 
     If no revision is specified, the working directory's parent is a
     head revision, and the repository contains exactly one other head,
     the other head is merged with by default.  Otherwise, an explicit
     revision to merge with must be provided.
     """
 
     if rev and node:
         raise util.Abort(_("please specify just one revision"))
 
     if not node:
         node = rev
 
     if not node:
         heads = repo.heads()
         if len(heads) > 2:
             raise util.Abort(_('repo has %d heads - '
                                'please merge with an explicit rev') %
                              len(heads))
         if len(heads) == 1:
             raise util.Abort(_('there is nothing to merge - '
                                'use "hg update" instead'))
         parent = repo.dirstate.parents()[0]
         if parent not in heads:
             raise util.Abort(_('working dir not at a head rev - '
                                'use "hg update" or merge with an explicit rev'))
         node = parent == heads[0] and heads[-1] or heads[0]
     return hg.merge(repo, node, force=force)
 
 def outgoing(ui, repo, dest=None, **opts):
     """show changesets not found in destination
 
     Show changesets not found in the specified destination repository or
     the default push location. These are the changesets that would be pushed
     if a push was requested.
 
     See pull for valid destination format details.
     """
     dest, revs = cmdutil.parseurl(
         ui.expandpath(dest or 'default-push', dest or 'default'), opts['rev'])
     cmdutil.setremoteconfig(ui, opts)
     if revs:
         revs = [repo.lookup(rev) for rev in revs]
 
     other = hg.repository(ui, dest)
     ui.status(_('comparing with %s\n') % dest)
     o = repo.findoutgoing(other, force=opts['force'])
     if not o:
         ui.status(_("no changes found\n"))
         return 1
     o = repo.changelog.nodesbetween(o, revs)[0]
     if opts['newest_first']:
         o.reverse()
     displayer = cmdutil.show_changeset(ui, repo, opts)
     for n in o:
         parents = [p for p in repo.changelog.parents(n) if p != nullid]
         if opts['no_merges'] and len(parents) == 2:
             continue
         displayer.show(changenode=n)
 
 def parents(ui, repo, file_=None, **opts):
     """show the parents of the working dir or revision
 
     Print the working directory's parent revisions. If a
     revision is given via --rev, the parent of that revision
     will be printed. If a file argument is given, revision in
     which the file was last changed (before the working directory
     revision or the argument to --rev if given) is printed.
     """
     rev = opts.get('rev')
     if file_:
         files, match, anypats = cmdutil.matchpats(repo, (file_,), opts)
         if anypats or len(files) != 1:
             raise util.Abort(_('can only specify an explicit file name'))
         ctx = repo.filectx(files[0], changeid=rev)
     elif rev:
         ctx = repo.changectx(rev)
     else:
         ctx = repo.workingctx()
     p = [cp.node() for cp in ctx.parents()]
 
     displayer = cmdutil.show_changeset(ui, repo, opts)
     for n in p:
         if n != nullid:
             displayer.show(changenode=n)
 
 def paths(ui, repo, search=None):
     """show definition of symbolic path names
 
     Show definition of symbolic path name NAME. If no name is given, show
     definition of available names.
 
     Path names are defined in the [paths] section of /etc/mercurial/hgrc
     and $HOME/.hgrc.  If run inside a repository, .hg/hgrc is used, too.
     """
     if search:
         for name, path in ui.configitems("paths"):
             if name == search:
                 ui.write("%s\n" % path)
                 return
         ui.warn(_("not found!\n"))
         return 1
     else:
         for name, path in ui.configitems("paths"):
             ui.write("%s = %s\n" % (name, path))
 
-def postincoming(ui, repo, modheads, optupdate, wasempty):
+def postincoming(ui, repo, modheads, optupdate):
     if modheads == 0:
         return
     if optupdate:
-        if wasempty:
-            return hg.update(repo, repo.lookup('default'))
-        elif modheads == 1:
-            return hg.update(repo, repo.changelog.tip()) # update
+        if modheads == 1:
+            return hg.update(repo, None)
         else:
             ui.status(_("not updating, since new heads added\n"))
     if modheads > 1:
         ui.status(_("(run 'hg heads' to see heads, 'hg merge' to merge)\n"))
     else:
         ui.status(_("(run 'hg update' to get a working copy)\n"))
 
 def pull(ui, repo, source="default", **opts):
     """pull changes from the specified source
 
     Pull changes from a remote repository to a local one.
 
     This finds all changes from the repository at the specified path
     or URL and adds them to the local repository. By default, this
     does not update the copy of the project in the working directory.
 
     Valid URLs are of the form:
 
       local/filesystem/path (or file://local/filesystem/path)
       http://[user@]host[:port]/[path]
       https://[user@]host[:port]/[path]
       ssh://[user@]host[:port]/[path]
       static-http://host[:port]/[path]
 
     Paths in the local filesystem can either point to Mercurial
     repositories or to bundle files (as created by 'hg bundle' or
     'hg incoming --bundle'). The static-http:// protocol, albeit slow,
     allows access to a Mercurial repository where you simply use a web
     server to publish the .hg directory as static content.
 
     An optional identifier after # indicates a particular branch, tag,
     or changeset to pull.
 
     Some notes about using SSH with Mercurial:
     - SSH requires an accessible shell account on the destination machine
       and a copy of hg in the remote path or specified with as remotecmd.
     - path is relative to the remote user's home directory by default.
       Use an extra slash at the start of a path to specify an absolute path:
         ssh://example.com//tmp/repository
     - Mercurial doesn't use its own compression via SSH; the right thing
       to do is to configure it in your ~/.ssh/config, e.g.:
         Host *.mylocalnetwork.example.com
           Compression no
         Host *
           Compression yes
       Alternatively specify "ssh -C" as your ssh command in your hgrc or
       with the --ssh command line option.
     """
     source, revs = cmdutil.parseurl(ui.expandpath(source), opts['rev'])
     cmdutil.setremoteconfig(ui, opts)
 
     other = hg.repository(ui, source)
     ui.status(_('pulling from %s\n') % (source))
     if revs:
         if 'lookup' in other.capabilities:
             revs = [other.lookup(rev) for rev in revs]
         else:
             error = _("Other repository doesn't support revision lookup, so a rev cannot be specified.")
             raise util.Abort(error)
 
-    wasempty = repo.changelog.count() == 0
     modheads = repo.pull(other, heads=revs, force=opts['force'])
-    return postincoming(ui, repo, modheads, opts['update'], wasempty)
+    return postincoming(ui, repo, modheads, opts['update'])
 
 def push(ui, repo, dest=None, **opts):
     """push changes to the specified destination
 
     Push changes from the local repository to the given destination.
 
     This is the symmetrical operation for pull. It helps to move
     changes from the current repository to a different one. If the
     destination is local this is identical to a pull in that directory
     from the current one.
 
     By default, push will refuse to run if it detects the result would
     increase the number of remote heads. This generally indicates the
     the client has forgotten to sync and merge before pushing.
 
     Valid URLs are of the form:
 
       local/filesystem/path (or file://local/filesystem/path)
       ssh://[user@]host[:port]/[path]
       http://[user@]host[:port]/[path]
       https://[user@]host[:port]/[path]
 
     An optional identifier after # indicates a particular branch, tag,
     or changeset to push.
 
     Look at the help text for the pull command for important details
     about ssh:// URLs.
 
     Pushing to http:// and https:// URLs is only possible, if this
     feature is explicitly enabled on the remote Mercurial server.
     """
     dest, revs = cmdutil.parseurl(
         ui.expandpath(dest or 'default-push', dest or 'default'), opts['rev'])
     cmdutil.setremoteconfig(ui, opts)
 
     other = hg.repository(ui, dest)
     ui.status('pushing to %s\n' % (dest))
     if revs:
         revs = [repo.lookup(rev) for rev in revs]
     r = repo.push(other, opts['force'], revs=revs)
     return r == 0
 
 def rawcommit(ui, repo, *pats, **opts):
     """raw commit interface (DEPRECATED)
 
     (DEPRECATED)
     Lowlevel commit, for use in helper scripts.
 
     This command is not intended to be used by normal users, as it is
     primarily useful for importing from other SCMs.
 
     This command is now deprecated and will be removed in a future
     release, please use debugsetparents and commit instead.
     """
 
     ui.warn(_("(the rawcommit command is deprecated)\n"))
 
     message = cmdutil.logmessage(opts)
 
     files, match, anypats = cmdutil.matchpats(repo, pats, opts)
     if opts['files']:
         files += open(opts['files']).read().splitlines()
 
     parents = [repo.lookup(p) for p in opts['parent']]
 
     try:
         repo.rawcommit(files, message, opts['user'], opts['date'], *parents)
     except ValueError, inst:
         raise util.Abort(str(inst))
 
 def recover(ui, repo):
     """roll back an interrupted transaction
 
     Recover from an interrupted commit or pull.
 
     This command tries to fix the repository status after an interrupted
     operation. It should only be necessary when Mercurial suggests it.
     """
     if repo.recover():
         return hg.verify(repo)
     return 1
 
 def remove(ui, repo, *pats, **opts):
     """remove the specified files on the next commit
 
     Schedule the indicated files for removal from the repository.
 
     This only removes files from the current branch, not from the
     entire project history.  If the files still exist in the working
     directory, they will be deleted from it.  If invoked with --after,
     files are marked as removed, but not actually unlinked unless --force
     is also given. Without exact file names, --after will only mark
     files as removed if they are no longer in the working directory.
 
     This command schedules the files to be removed at the next commit.
     To undo a remove before that, see hg revert.
 
     Modified files and added files are not removed by default.  To
     remove them, use the -f/--force option.
     """
-    names = []
     if not opts['after'] and not pats:
         raise util.Abort(_('no files specified'))
     files, matchfn, anypats = cmdutil.matchpats(repo, pats, opts)
     exact = dict.fromkeys(files)
     mardu = map(dict.fromkeys, repo.status(files=files, match=matchfn))[:5]
     modified, added, removed, deleted, unknown = mardu
     remove, forget = [], []
     for src, abs, rel, exact in cmdutil.walk(repo, pats, opts):
         reason = None
         if abs in modified and not opts['force']:
             reason = _('is modified (use -f to force removal)')
         elif abs in added:
             if opts['force']:
                 forget.append(abs)
                 continue
             reason = _('has been marked for add (use -f to force removal)')
         elif abs not in repo.dirstate:
             reason = _('is not managed')
         elif opts['after'] and not exact and abs not in deleted:
             continue
         elif abs in removed:
             continue
         if reason:
             if exact:
                 ui.warn(_('not removing %s: file %s\n') % (rel, reason))
         else:
             if ui.verbose or not exact:
                 ui.status(_('removing %s\n') % rel)
             remove.append(abs)
     repo.forget(forget)
     repo.remove(remove, unlink=opts['force'] or not opts['after'])
 
 def rename(ui, repo, *pats, **opts):
     """rename files; equivalent of copy + remove
 
     Mark dest as copies of sources; mark sources for deletion.  If
     dest is a directory, copies are put in that directory.  If dest is
     a file, there can only be one source.
 
     By default, this command copies the contents of files as they
     stand in the working directory.  If invoked with --after, the
     operation is recorded, but no copying is performed.
 
     This command takes effect in the next commit. To undo a rename
     before that, see hg revert.
     """
     wlock = repo.wlock(False)
     try:
         errs, copied = docopy(ui, repo, pats, opts)
         names = []
         for abs, rel, exact in copied:
             if ui.verbose or not exact:
                 ui.status(_('removing %s\n') % rel)
             names.append(abs)
         if not opts.get('dry_run'):
             repo.remove(names, True)
         return errs
     finally:
         del wlock
 
 def revert(ui, repo, *pats, **opts):
     """revert files or dirs to their states as of some revision
 
     With no revision specified, revert the named files or directories
     to the contents they had in the parent of the working directory.
     This restores the contents of the affected files to an unmodified
     state and unschedules adds, removes, copies, and renames. If the
     working directory has two parents, you must explicitly specify the
     revision to revert to.
 
     Modified files are saved with a .orig suffix before reverting.
     To disable these backups, use --no-backup.
 
     Using the -r option, revert the given files or directories to their
     contents as of a specific revision. This can be helpful to "roll
     back" some or all of a change that should not have been committed.
 
     Revert modifies the working directory.  It does not commit any
     changes, or change the parent of the working directory.  If you
     revert to a revision other than the parent of the working
     directory, the reverted files will thus appear modified
     afterwards.
 
     If a file has been deleted, it is restored.  If the executable
     mode of a file was changed, it is reset.
 
     If names are given, all files matching the names are reverted.
 
     If no arguments are given, no files are reverted.
     """
 
     if opts["date"]:
         if opts["rev"]:
             raise util.Abort(_("you can't specify a revision and a date"))
         opts["rev"] = cmdutil.finddate(ui, repo, opts["date"])
 
     if not pats and not opts['all']:
         raise util.Abort(_('no files or directories specified; '
                            'use --all to revert the whole repo'))
 
     parent, p2 = repo.dirstate.parents()
     if not opts['rev'] and p2 != nullid:
         raise util.Abort(_('uncommitted merge - please provide a '
                            'specific revision'))
     ctx = repo.changectx(opts['rev'])
     node = ctx.node()
     mf = ctx.manifest()
     if node == parent:
         pmf = mf
     else:
         pmf = None
 
     # need all matching names in dirstate and manifest of target rev,
     # so have to walk both. do not print errors if files exist in one
     # but not other.
 
     names = {}
     target_only = {}
 
     wlock = repo.wlock()
     try:
         # walk dirstate.
         for src, abs, rel, exact in cmdutil.walk(repo, pats, opts,
                                                  badmatch=mf.has_key):
             names[abs] = (rel, exact)
             if src == 'b':
                 target_only[abs] = True
 
         # walk target manifest.
 
         def badmatch(path):
             if path in names:
                 return True
             path_ = path + '/'
             for f in names:
                 if f.startswith(path_):
                     return True
             return False
 
         for src, abs, rel, exact in cmdutil.walk(repo, pats, opts, node=node,
                                                  badmatch=badmatch):
             if abs in names or src == 'b':
                 continue
             names[abs] = (rel, exact)
             target_only[abs] = True
 
         changes = repo.status(match=names.has_key)[:5]
         modified, added, removed, deleted, unknown = map(dict.fromkeys, changes)
 
         revert = ([], _('reverting %s\n'))
         add = ([], _('adding %s\n'))
         remove = ([], _('removing %s\n'))
         forget = ([], _('forgetting %s\n'))
         undelete = ([], _('undeleting %s\n'))
         update = {}
 
         disptable = (
             # dispatch table:
             #   file state
             #   action if in target manifest
             #   action if not in target manifest
             #   make backup if in target manifest
             #   make backup if not in target manifest
             (modified, revert, remove, True, True),
             (added, revert, forget, True, False),
             (removed, undelete, None, False, False),
             (deleted, revert, remove, False, False),
             (unknown, add, None, True, False),
             (target_only, add, None, False, False),
             )
 
         entries = names.items()
         entries.sort()
 
         for abs, (rel, exact) in entries:
             mfentry = mf.get(abs)
             target = repo.wjoin(abs)
             def handle(xlist, dobackup):
                 xlist[0].append(abs)
                 update[abs] = 1
                 if dobackup and not opts['no_backup'] and util.lexists(target):
                     bakname = "%s.orig" % rel
                     ui.note(_('saving current version of %s as %s\n') %
                             (rel, bakname))
                     if not opts.get('dry_run'):
                         util.copyfile(target, bakname)
                 if ui.verbose or not exact:
                     ui.status(xlist[1] % rel)
             for table, hitlist, misslist, backuphit, backupmiss in disptable:
                 if abs not in table: continue
                 # file has changed in dirstate
                 if mfentry:
                     handle(hitlist, backuphit)
                 elif misslist is not None:
                     handle(misslist, backupmiss)
                 else:
                     if exact: ui.warn(_('file not managed: %s\n') % rel)
                 break
             else:
                 # file has not changed in dirstate
                 if node == parent:
                     if exact: ui.warn(_('no changes needed to %s\n') % rel)
                     continue
                 if pmf is None:
                     # only need parent manifest in this unlikely case,
                     # so do not read by default
                     pmf = repo.changectx(parent).manifest()
                 if abs in pmf:
                     if mfentry:
                         # if version of file is same in parent and target
                         # manifests, do nothing
                         if pmf[abs] != mfentry:
                             handle(revert, False)
                     else:
                         handle(remove, False)
 
         if not opts.get('dry_run'):
             for f in forget[0]:
                 repo.dirstate.forget(f)
             r = hg.revert(repo, node, update.has_key)
             for f in add[0]:
                 repo.dirstate.add(f)
             for f in undelete[0]:
                 repo.dirstate.normal(f)
             for f in remove[0]:
                 repo.dirstate.remove(f)
             return r
     finally:
         del wlock
 
 def rollback(ui, repo):
     """roll back the last transaction in this repository
 
     Roll back the last transaction in this repository, restoring the
     project to its state prior to the transaction.
 
     Transactions are used to encapsulate the effects of all commands
     that create new changesets or propagate existing changesets into a
     repository. For example, the following commands are transactional,
     and their effects can be rolled back:
 
       commit
       import
       pull
       push (with this repository as destination)
       unbundle
 
     This command should be used with care. There is only one level of
     rollback, and there is no way to undo a rollback. It will also
     restore the dirstate at the time of the last transaction, which
     may lose subsequent dirstate changes.
 
     This command is not intended for use on public repositories. Once
     changes are visible for pull by other users, rolling a transaction
     back locally is ineffective (someone else may already have pulled
     the changes). Furthermore, a race is possible with readers of the
     repository; for example an in-progress pull from the repository
     may fail if a rollback is performed.
     """
     repo.rollback()
 
 def root(ui, repo):
     """print the root (top) of the current working dir
 
     Print the root directory of the current repository.
     """
     ui.write(repo.root + "\n")
 
 def serve(ui, repo, **opts):
     """export the repository via HTTP
 
     Start a local HTTP repository browser and pull server.
 
     By default, the server logs accesses to stdout and errors to
     stderr.  Use the "-A" and "-E" options to log to files.
     """
 
     if opts["stdio"]:
         if repo is None:
             raise hg.RepoError(_("There is no Mercurial repository here"
                                  " (.hg not found)"))
         s = sshserver.sshserver(ui, repo)
         s.serve_forever()
 
     parentui = ui.parentui or ui
     optlist = ("name templates style address port ipv6"
                " accesslog errorlog webdir_conf certificate")
     for o in optlist.split():
         if opts[o]:
             parentui.setconfig("web", o, str(opts[o]))
             if repo.ui != parentui:
                 repo.ui.setconfig("web", o, str(opts[o]))
 
     if repo is None and not ui.config("web", "webdir_conf"):
         raise hg.RepoError(_("There is no Mercurial repository here"
                              " (.hg not found)"))
 
     class service:
         def init(self):
             util.set_signal_handler()
             try:
                 self.httpd = hgweb.server.create_server(parentui, repo)
             except socket.error, inst:
                 raise util.Abort(_('cannot start server: ') + inst.args[1])
 
             if not ui.verbose: return
 
             if self.httpd.port != 80:
                 ui.status(_('listening at http://%s:%d/\n') %
                           (self.httpd.addr, self.httpd.port))
             else:
                 ui.status(_('listening at http://%s/\n') % self.httpd.addr)
 
         def run(self):
             self.httpd.serve_forever()
 
     service = service()
 
     cmdutil.service(opts, initfn=service.init, runfn=service.run)
 
 def status(ui, repo, *pats, **opts):
     """show changed files in the working directory
 
     Show status of files in the repository.  If names are given, only
     files that match are shown.  Files that are clean or ignored, are
     not listed unless -c (clean), -i (ignored) or -A is given.
 
     NOTE: status may appear to disagree with diff if permissions have
     changed or a merge has occurred. The standard diff format does not
     report permission changes and diff only reports changes relative
     to one merge parent.
 
     If one revision is given, it is used as the base revision.
     If two revisions are given, the difference between them is shown.
 
     The codes used to show the status of files are:
     M = modified
     A = added
     R = removed
     C = clean
     ! = deleted, but still tracked
     ? = not tracked
     I = ignored (not shown by default)
       = the previous added file was copied from here
     """
 
     all = opts['all']
     node1, node2 = cmdutil.revpair(repo, opts.get('rev'))
 
     files, matchfn, anypats = cmdutil.matchpats(repo, pats, opts)
     cwd = (pats and repo.getcwd()) or ''
     modified, added, removed, deleted, unknown, ignored, clean = [
         n for n in repo.status(node1=node1, node2=node2, files=files,
                              match=matchfn,
                              list_ignored=all or opts['ignored'],
                              list_clean=all or opts['clean'])]
 
     changetypes = (('modified', 'M', modified),
                    ('added', 'A', added),
                    ('removed', 'R', removed),
                    ('deleted', '!', deleted),
                    ('unknown', '?', unknown),
                    ('ignored', 'I', ignored))
 
     explicit_changetypes = changetypes + (('clean', 'C', clean),)
 
     end = opts['print0'] and '\0' or '\n'
 
     for opt, char, changes in ([ct for ct in explicit_changetypes
                                 if all or opts[ct[0]]]
                                or changetypes):
         if opts['no_status']:
             format = "%%s%s" % end
         else:
             format = "%s %%s%s" % (char, end)
 
         for f in changes:
             ui.write(format % repo.pathto(f, cwd))
             if ((all or opts.get('copies')) and not opts.get('no_status')):
                 copied = repo.dirstate.copied(f)
                 if copied:
                     ui.write('  %s%s' % (repo.pathto(copied, cwd), end))
 
 def tag(ui, repo, name, rev_=None, **opts):
     """add a tag for the current or given revision
 
     Name a particular revision using <name>.
 
     Tags are used to name particular revisions of the repository and are
     very useful to compare different revision, to go back to significant
     earlier versions or to mark branch points as releases, etc.
 
     If no revision is given, the parent of the working directory is used,
     or tip if no revision is checked out.
 
     To facilitate version control, distribution, and merging of tags,
     they are stored as a file named ".hgtags" which is managed
     similarly to other project files and can be hand-edited if
     necessary.  The file '.hg/localtags' is used for local tags (not
     shared among repositories).
     """
     if name in ['tip', '.', 'null']:
         raise util.Abort(_("the name '%s' is reserved") % name)
     if rev_ is not None:
         ui.warn(_("use of 'hg tag NAME [REV]' is deprecated, "
                   "please use 'hg tag [-r REV] NAME' instead\n"))
         if opts['rev']:
             raise util.Abort(_("use only one form to specify the revision"))
     if opts['rev'] and opts['remove']:
         raise util.Abort(_("--rev and --remove are incompatible"))
     if opts['rev']:
         rev_ = opts['rev']
     message = opts['message']
     if opts['remove']:
         if not name in repo.tags():
             raise util.Abort(_('tag %s does not exist') % name)
         rev_ = nullid
         if not message:
             message = _('Removed tag %s') % name
     elif name in repo.tags() and not opts['force']:
         raise util.Abort(_('a tag named %s already exists (use -f to force)')
                          % name)
     if not rev_ and repo.dirstate.parents()[1] != nullid:
         raise util.Abort(_('uncommitted merge - please provide a '
                            'specific revision'))
     r = repo.changectx(rev_).node()
 
     if not message:
         message = _('Added tag %s for changeset %s') % (name, short(r))
 
     repo.tag(name, r, message, opts['local'], opts['user'], opts['date'])
 
 def tags(ui, repo):
     """list repository tags
 
     List the repository tags.
 
     This lists both regular and local tags.
     """
 
     l = repo.tagslist()
     l.reverse()
     hexfunc = ui.debugflag and hex or short
     for t, n in l:
         try:
             hn = hexfunc(n)
             r = "%5d:%s" % (repo.changelog.rev(n), hexfunc(n))
         except revlog.LookupError:
             r = "    ?:%s" % hn
         if ui.quiet:
             ui.write("%s\n" % t)
         else:
             spaces = " " * (30 - util.locallen(t))
             ui.write("%s%s %s\n" % (t, spaces, r))
 
 def tip(ui, repo, **opts):
     """show the tip revision
 
     Show the tip revision.
     """
     cmdutil.show_changeset(ui, repo, opts).show(nullrev+repo.changelog.count())
 
 def unbundle(ui, repo, fname1, *fnames, **opts):
     """apply one or more changegroup files
 
     Apply one or more compressed changegroup files generated by the
     bundle command.
     """
     fnames = (fname1,) + fnames
-    result = None
-    wasempty = repo.changelog.count() == 0
     for fname in fnames:
         if os.path.exists(fname):
             f = open(fname, "rb")
         else:
             f = urllib.urlopen(fname)
         gen = changegroup.readbundle(f, fname)
         modheads = repo.addchangegroup(gen, 'unbundle', 'bundle:' + fname)
 
-    return postincoming(ui, repo, modheads, opts['update'], wasempty)
+    return postincoming(ui, repo, modheads, opts['update'])
 
 def update(ui, repo, node=None, rev=None, clean=False, date=None):
     """update working directory
 
     Update the working directory to the specified revision, or the
     tip of the current branch if none is specified.
 
     If there are no outstanding changes in the working directory and
     there is a linear relationship between the current version and the
     requested version, the result is the requested version.
 
     To merge the working directory with another revision, use the
     merge command.
 
     By default, update will refuse to run if doing so would require
     discarding local changes.
     """
     if rev and node:
         raise util.Abort(_("please specify just one revision"))
 
     if not rev:
         rev = node
 
     if date:
         if rev:
             raise util.Abort(_("you can't specify a revision and a date"))
         rev = cmdutil.finddate(ui, repo, date)
 
     if clean:
         return hg.clean(repo, rev)
     else:
         return hg.update(repo, rev)
 
 def verify(ui, repo):
     """verify the integrity of the repository
 
     Verify the integrity of the current repository.
 
     This will perform an extensive check of the repository's
     integrity, validating the hashes and checksums of each entry in
     the changelog, manifest, and tracked files, as well as the
     integrity of their crosslinks and indices.
     """
     return hg.verify(repo)
 
 def version_(ui):
     """output version and copyright information"""
     ui.write(_("Mercurial Distributed SCM (version %s)\n")
              % version.get_version())
     ui.status(_(
         "\nCopyright (C) 2005-2007 Matt Mackall <[e-mail]> and others\n"
         "This is free software; see the source for copying conditions. "
         "There is NO\nwarranty; "
         "not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n"
     ))
 
 # Command options and aliases are listed here, alphabetically
 
 globalopts = [
     ('R', 'repository', '',
      _('repository root directory or symbolic path name')),
     ('', 'cwd', '', _('change working directory')),
     ('y', 'noninteractive', None,
      _('do not prompt, assume \'yes\' for any required answers')),
     ('q', 'quiet', None, _('suppress output')),
     ('v', 'verbose', None, _('enable additional output')),
     ('', 'config', [], _('set/override config option')),
     ('', 'debug', None, _('enable debugging output')),
     ('', 'debugger', None, _('start debugger')),
     ('', 'encoding', util._encoding, _('set the charset encoding')),
     ('', 'encodingmode', util._encodingmode, _('set the charset encoding mode')),
     ('', 'lsprof', None, _('print improved command execution profile')),
     ('', 'traceback', None, _('print traceback on exception')),
     ('', 'time', None, _('time how long the command takes')),
     ('', 'profile', None, _('print command execution profile')),
     ('', 'version', None, _('output version information and exit')),
     ('h', 'help', None, _('display help and exit')),
 ]
 
 dryrunopts = [('n', 'dry-run', None,
                _('do not perform actions, just print output'))]
 
 remoteopts = [
     ('e', 'ssh', '', _('specify ssh command to use')),
     ('', 'remotecmd', '', _('specify hg command to run on the remote side')),
 ]
 
 walkopts = [
     ('I', 'include', [], _('include names matching the given patterns')),
     ('X', 'exclude', [], _('exclude names matching the given patterns')),
 ]
 
 commitopts = [
     ('m', 'message', '', _('use <text> as commit message')),
     ('l', 'logfile', '', _('read commit message from <file>')),
 ]
 
 table = {
     "^add": (add, walkopts + dryrunopts, _('hg add [OPTION]... [FILE]...')),
     "addremove":
         (addremove,
          [('s', 'similarity', '',
            _('guess renamed files by similarity (0<=s<=100)')),
          ] + walkopts + dryrunopts,
          _('hg addremove [OPTION]... [FILE]...')),
     "^annotate":
         (annotate,
          [('r', 'rev', '', _('annotate the specified revision')),
           ('f', 'follow', None, _('follow file copies and renames')),
           ('a', 'text', None, _('treat all files as text')),
           ('u', 'user', None, _('list the author')),
           ('d', 'date', None, _('list the date')),
           ('n', 'number', None, _('list the revision number (default)')),
           ('c', 'changeset', None, _('list the changeset')),
           ('l', 'line-number', None,
            _('show line number at the first appearance'))
          ] + walkopts,
          _('hg annotate [-r REV] [-f] [-a] [-u] [-d] [-n] [-c] [-l] FILE...')),
     "archive":
         (archive,
          [('', 'no-decode', None, _('do not pass files through decoders')),
           ('p', 'prefix', '', _('directory prefix for files in archive')),
           ('r', 'rev', '', _('revision to distribute')),
           ('t', 'type', '', _('type of distribution to create')),
          ] + walkopts,
          _('hg archive [OPTION]... DEST')),
     "backout":
         (backout,
          [('', 'merge', None,
            _('merge with old dirstate parent after backout')),
           ('d', 'date', '', _('record datecode as commit date')),
           ('', 'parent', '', _('parent to choose when backing out merge')),
           ('u', 'user', '', _('record user as committer')),
           ('r', 'rev', '', _('revision to backout')),
          ] + walkopts + commitopts,
          _('hg backout [OPTION]... [-r] REV')),
     "branch":
         (branch,
          [('f', 'force', None,
            _('set branch name even if it shadows an existing branch'))],
          _('hg branch [NAME]')),
     "branches":
         (branches,
          [('a', 'active', False,
            _('show only branches that have unmerged heads'))],
          _('hg branches [-a]')),
     "bundle":
         (bundle,
          [('f', 'force', None,
            _('run even when remote repository is unrelated')),
           ('r', 'rev', [],
            _('a changeset you would like to bundle')),
           ('', 'base', [],
            _('a base changeset to specify instead of a destination')),
          ] + remoteopts,
          _('hg bundle [-f] [-r REV]... [--base REV]... FILE [DEST]')),
     "cat":
         (cat,
          [('o', 'output', '', _('print output to file with formatted name')),
           ('r', 'rev', '', _('print the given revision')),
          ] + walkopts,
          _('hg cat [OPTION]... FILE...')),
     "^clone":
         (clone,
          [('U', 'noupdate', None, _('do not update the new working directory')),
           ('r', 'rev', [],
            _('a changeset you would like to have after cloning')),
           ('', 'pull', None, _('use pull protocol to copy metadata')),
           ('', 'uncompressed', None,
            _('use uncompressed transfer (fast over LAN)')),
          ] + remoteopts,
          _('hg clone [OPTION]... SOURCE [DEST]')),
     "^commit|ci":
         (commit,
          [('A', 'addremove', None,
            _('mark new/missing files as added/removed before committing')),
           ('d', 'date', '', _('record datecode as commit date')),
           ('u', 'user', '', _('record user as commiter')),
          ] + walkopts + commitopts,
          _('hg commit [OPTION]... [FILE]...')),
     "copy|cp":
         (copy,
          [('A', 'after', None, _('record a copy that has already occurred')),
           ('f', 'force', None,
            _('forcibly copy over an existing managed file')),
          ] + walkopts + dryrunopts,
          _('hg copy [OPTION]... [SOURCE]... DEST')),
     "debugancestor": (debugancestor, [], _('debugancestor INDEX REV1 REV2')),
     "debugcomplete":
         (debugcomplete,
          [('o', 'options', None, _('show the command options'))],
          _('debugcomplete [-o] CMD')),
     "debuginstall": (debuginstall, [], _('debuginstall')),
     "debugrebuildstate":
         (debugrebuildstate,
          [('r', 'rev', '', _('revision to rebuild to'))],
          _('debugrebuildstate [-r REV] [REV]')),
     "debugcheckstate": (debugcheckstate, [], _('debugcheckstate')),
     "debugsetparents": (debugsetparents, [], _('debugsetparents REV1 [REV2]')),
     "debugstate": (debugstate, [], _('debugstate')),
     "debugdate":
         (debugdate,
          [('e', 'extended', None, _('try extended date formats'))],
          _('debugdate [-e] DATE [RANGE]')),
     "debugdata": (debugdata, [], _('debugdata FILE REV')),
     "debugindex": (debugindex, [], _('debugindex FILE')),
     "debugindexdot": (debugindexdot, [], _('debugindexdot FILE')),
     "debugrename":
         (debugrename,
          [('r', 'rev', '', _('revision to debug'))],
          _('debugrename [-r REV] FILE')),
     "debugwalk": (debugwalk, walkopts, _('debugwalk [OPTION]... [FILE]...')),
     "^diff":
         (diff,
          [('r', 'rev', [], _('revision')),
           ('a', 'text', None, _('treat all files as text')),
           ('p', 'show-function', None,
            _('show which function each change is in')),
           ('g', 'git', None, _('use git extended diff format')),
           ('', 'nodates', None, _("don't include dates in diff headers")),
           ('w', 'ignore-all-space', None,
            _('ignore white space when comparing lines')),
           ('b', 'ignore-space-change', None,
            _('ignore changes in the amount of white space')),
           ('B', 'ignore-blank-lines', None,
            _('ignore changes whose lines are all blank')),
          ] + walkopts,
          _('hg diff [OPTION]... [-r REV1 [-r REV2]] [FILE]...')),
     "^export":
         (export,
          [('o', 'output', '', _('print output to file with formatted name')),
           ('a', 'text', None, _('treat all files as text')),
           ('g', 'git', None, _('use git extended diff format')),
           ('', 'nodates', None, _("don't include dates in diff headers")),
           ('', 'switch-parent', None, _('diff against the second parent'))],
          _('hg export [OPTION]... [-o OUTFILESPEC] REV...')),
     "grep":
         (grep,
          [('0', 'print0', None, _('end fields with NUL')),
           ('', 'all', None, _('print all revisions that match')),
           ('f', 'follow', None,
            _('follow changeset history, or file history across copies and renames')),
           ('i', 'ignore-case', None, _('ignore case when matching')),
           ('l', 'files-with-matches', None,
            _('print only filenames and revs that match')),
           ('n', 'line-number', None, _('print matching line numbers')),
           ('r', 'rev', [], _('search in given revision range')),
           ('u', 'user', None, _('print user who committed change')),
          ] + walkopts,
          _('hg grep [OPTION]... PATTERN [FILE]...')),
     "heads":
         (heads,
          [('', 'style', '', _('display using template map file')),
           ('r', 'rev', '', _('show only heads which are descendants of rev')),
           ('', 'template', '', _('display with template'))],
          _('hg heads [-r REV] [REV]...')),
     "help": (help_, [], _('hg help [COMMAND]')),
     "identify|id":
         (identify,
          [('r', 'rev', '', _('identify the specified rev')),
           ('n', 'num', None, _('show local revision number')),
           ('i', 'id', None, _('show global revision id')),
           ('b', 'branch', None, _('show branch')),
           ('t', 'tags', None, _('show tags'))],
          _('hg identify [-nibt] [-r REV] [SOURCE]')),
     "import|patch":
         (import_,
          [('p', 'strip', 1,
            _('directory strip option for patch. This has the same\n'
              'meaning as the corresponding patch option')),
           ('b', 'base', '', _('base path')),
           ('f', 'force', None,
            _('skip check for outstanding uncommitted changes')),
           ('', 'exact', None,
            _('apply patch to the nodes from which it was generated')),
           ('', 'import-branch', None,
            _('Use any branch information in patch (implied by --exact)'))] + commitopts,
          _('hg import [-p NUM] [-m MESSAGE] [-f] PATCH...')),
     "incoming|in": (incoming,
          [('M', 'no-merges', None, _('do not show merges')),
           ('f', 'force', None,
            _('run even when remote repository is unrelated')),
           ('', 'style', '', _('display using template map file')),
           ('n', 'newest-first', None, _('show newest record first')),
           ('', 'bundle', '', _('file to store the bundles into')),
           ('p', 'patch', None, _('show patch')),
           ('r', 'rev', [], _('a specific revision up to which you would like to pull')),
           ('', 'template', '', _('display with template')),
          ] + remoteopts,
          _('hg incoming [-p] [-n] [-M] [-f] [-r REV]...'
            ' [--bundle FILENAME] [SOURCE]')),
     "^init":
         (init,
          remoteopts,
          _('hg init [-e CMD] [--remotecmd CMD] [DEST]')),
     "locate":
         (locate,
          [('r', 'rev', '', _('search the repository as it stood at rev')),
           ('0', 'print0', None,
            _('end filenames with NUL, for use with xargs')),
           ('f', 'fullpath', None,
            _('print complete paths from the filesystem root')),
          ] + walkopts,
          _('hg locate [OPTION]... [PATTERN]...')),
     "^log|history":
         (log,
          [('f', 'follow', None,
            _('follow changeset history, or file history across copies and renames')),
           ('', 'follow-first', None,
            _('only follow the first parent of merge changesets')),
           ('d', 'date', '', _('show revs matching date spec')),
           ('C', 'copies', None, _('show copied files')),
           ('k', 'keyword', [], _('do case-insensitive search for a keyword')),
           ('l', 'limit', '', _('limit number of changes displayed')),
           ('r', 'rev', [], _('show the specified revision or range')),
           ('', 'removed', None, _('include revs where files were removed')),
           ('M', 'no-merges', None, _('do not show merges')),
           ('', 'style', '', _('display using template map file')),
           ('m', 'only-merges', None, _('show only merges')),
           ('p', 'patch', None, _('show patch')),
           ('P', 'prune', [], _('do not display revision or any of its ancestors')),
           ('', 'template', '', _('display with template')),
          ] + walkopts,
          _('hg log [OPTION]... [FILE]')),
     "manifest": (manifest, [], _('hg manifest [REV]')),
     "^merge":
         (merge,
          [('f', 'force', None, _('force a merge with outstanding changes')),
           ('r', 'rev', '', _('revision to merge')),
              ],
          _('hg merge [-f] [[-r] REV]')),
     "outgoing|out": (outgoing,
          [('M', 'no-merges', None, _('do not show merges')),
           ('f', 'force', None,
            _('run even when remote repository is unrelated')),
           ('p', 'patch', None, _('show patch')),
           ('', 'style', '', _('display using template map file')),
           ('r', 'rev', [], _('a specific revision you would like to push')),
           ('n', 'newest-first', None, _('show newest record first')),
           ('', 'template', '', _('display with template')),
          ] + remoteopts,
          _('hg outgoing [-M] [-p] [-n] [-f] [-r REV]... [DEST]')),
     "^parents":
         (parents,
          [('r', 'rev', '', _('show parents from the specified rev')),
           ('', 'style', '', _('display using template map file')),
           ('', 'template', '', _('display with template'))],
          _('hg parents [-r REV] [FILE]')),
     "paths": (paths, [], _('hg paths [NAME]')),
     "^pull":
         (pull,
          [('u', 'update', None,
            _('update to new tip if changesets were pulled')),
           ('f', 'force', None,
            _('run even when remote repository is unrelated')),
           ('r', 'rev', [],
            _('a specific revision up to which you would like to pull')),
          ] + remoteopts,
          _('hg pull [-u] [-f] [-r REV]... [-e CMD] [--remotecmd CMD] [SOURCE]')),
     "^push":
         (push,
          [('f', 'force', None, _('force push')),
           ('r', 'rev', [], _('a specific revision you would like to push')),
          ] + remoteopts,
          _('hg push [-f] [-r REV]... [-e CMD] [--remotecmd CMD] [DEST]')),
     "debugrawcommit|rawcommit":
         (rawcommit,
          [('p', 'parent', [], _('parent')),
           ('d', 'date', '', _('date code')),
           ('u', 'user', '', _('user')),
           ('F', 'files', '', _('file list'))
           ] + commitopts,
          _('hg debugrawcommit [OPTION]... [FILE]...')),
     "recover": (recover, [], _('hg recover')),
     "^remove|rm":
         (remove,
          [('A', 'after', None, _('record remove that has already occurred')),
           ('f', 'force', None, _('remove file even if modified')),
          ] + walkopts,
          _('hg remove [OPTION]... FILE...')),
     "rename|mv":
         (rename,
          [('A', 'after', None, _('record a rename that has already occurred')),
           ('f', 'force', None,
            _('forcibly copy over an existing managed file')),
          ] + walkopts + dryrunopts,
          _('hg rename [OPTION]... SOURCE... DEST')),
     "^revert":
         (revert,
          [('a', 'all', None, _('revert all changes when no arguments given')),
           ('d', 'date', '', _('tipmost revision matching date')),
           ('r', 'rev', '', _('revision to revert to')),
           ('', 'no-backup', None, _('do not save backup copies of files')),
          ] + walkopts + dryrunopts,
          _('hg revert [OPTION]... [-r REV] [NAME]...')),
     "rollback": (rollback, [], _('hg rollback')),
     "root": (root, [], _('hg root')),
     "showconfig|debugconfig":
         (showconfig,
          [('u', 'untrusted', None, _('show untrusted configuration options'))],
          _('showconfig [-u] [NAME]...')),
     "^serve":
         (serve,
          [('A', 'accesslog', '', _('name of access log file to write to')),
           ('d', 'daemon', None, _('run server in background')),
           ('', 'daemon-pipefds', '', _('used internally by daemon mode')),
           ('E', 'errorlog', '', _('name of error log file to write to')),
           ('p', 'port', 0, _('port to use (default: 8000)')),
           ('a', 'address', '', _('address to use')),
           ('n', 'name', '',
            _('name to show in web pages (default: working dir)')),
           ('', 'webdir-conf', '', _('name of the webdir config file'
                                     ' (serve more than one repo)')),
           ('', 'pid-file', '', _('name of file to write process ID to')),
           ('', 'stdio', None, _('for remote clients')),
           ('t', 'templates', '', _('web templates to use')),
           ('', 'style', '', _('template style to use')),
           ('6', 'ipv6', None, _('use IPv6 in addition to IPv4')),
           ('', 'certificate', '', _('SSL certificate file'))],
          _('hg serve [OPTION]...')),
     "^status|st":
         (status,
          [('A', 'all', None, _('show status of all files')),
           ('m', 'modified', None, _('show only modified files')),
           ('a', 'added', None, _('show only added files')),
           ('r', 'removed', None, _('show only removed files')),
           ('d', 'deleted', None, _('show only deleted (but tracked) files')),
           ('c', 'clean', None, _('show only files without changes')),
           ('u', 'unknown', None, _('show only unknown (not tracked) files')),
           ('i', 'ignored', None, _('show only ignored files')),
           ('n', 'no-status', None, _('hide status prefix')),
           ('C', 'copies', None, _('show source of copied files')),
           ('0', 'print0', None,
            _('end filenames with NUL, for use with xargs')),
           ('', 'rev', [], _('show difference from revision')),
          ] + walkopts,
          _('hg status [OPTION]... [FILE]...')),
     "tag":
         (tag,
          [('f', 'force', None, _('replace existing tag')),
           ('l', 'local', None, _('make the tag local')),
           ('m', 'message', '', _('message for tag commit log entry')),
           ('d', 'date', '', _('record datecode as commit date')),
           ('u', 'user', '', _('record user as commiter')),
           ('r', 'rev', '', _('revision to tag')),
           ('', 'remove', None, _('remove a tag'))],
          _('hg tag [-l] [-m TEXT] [-d DATE] [-u USER] [-r REV] NAME')),
     "tags": (tags, [], _('hg tags')),
     "tip":
         (tip,
          [('', 'style', '', _('display using template map file')),
           ('p', 'patch', None, _('show patch')),
           ('', 'template', '', _('display with template'))],
          _('hg tip [-p]')),
     "unbundle":
         (unbundle,
          [('u', 'update', None,
            _('update to new tip if changesets were unbundled'))],
          _('hg unbundle [-u] FILE...')),
     "^update|up|checkout|co":
         (update,
          [('C', 'clean', None, _('overwrite locally modified files')),
           ('d', 'date', '', _('tipmost revision matching date')),
           ('r', 'rev', '', _('revision'))],
          _('hg update [-C] [-d DATE] [[-r] REV]')),
     "verify": (verify, [], _('hg verify')),
     "version": (version_, [], _('hg version')),
 }
 
 extensions.commandtable = table
 
 norepo = ("clone init version help debugancestor debugcomplete debugdata"
           " debugindex debugindexdot debugdate debuginstall")
 optionalrepo = ("paths serve showconfig")
 
 def dispatch(args, argv0=None):
     try:
         u = ui.ui(traceback='--traceback' in args)
     except util.Abort, inst:
         sys.stderr.write(_("abort: %s\n") % inst)
         return -1
     return cmdutil.runcatch(u, args, argv0=argv0)
 
 def run():
     sys.exit(dispatch(sys.argv[1:], argv0=sys.argv[0]))

mercurial/dirstate.py

@@ -1,500 +1,503 b''
 """
 dirstate.py - working directory tracking 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 *
 from i18n import _
 import struct, os, time, bisect, stat, strutil, util, re, errno, ignore
 import cStringIO
 
 _unknown = ('?', 0, 0, 0)
 _format = ">cllll"
 
 class dirstate(object):
 
     def __init__(self, opener, ui, root):
         self._opener = opener
         self._root = root
         self._dirty = False
+        self._dirtypl = False
         self._ui = ui
 
     def __getattr__(self, name):
         if name == '_map':
             self._read()
             return self._map
         elif name == '_copymap':
             self._read()
             return self._copymap
         elif name == '_branch':
             try:
                 self._branch = (self._opener("branch").read().strip()
                                 or "default")
             except IOError:
                 self._branch = "default"
             return self._branch
         elif name == '_pl':
             self._pl = [nullid, nullid]
             try:
                 st = self._opener("dirstate").read(40)
                 if len(st) == 40:
                     self._pl = st[:20], st[20:40]
             except IOError, err:
                 if err.errno != errno.ENOENT: raise
             return self._pl
         elif name == '_dirs':
             self._dirs = {}
             for f in self._map:
                 self._incpath(f)
             return self._dirs
         elif name == '_ignore':
             files = [self._join('.hgignore')]
             for name, path in self._ui.configitems("ui"):
                 if name == 'ignore' or name.startswith('ignore.'):
                     files.append(os.path.expanduser(path))
             self._ignore = ignore.ignore(self._root, files, self._ui.warn)
             return self._ignore
         elif name == '_slash':
             self._slash = self._ui.configbool('ui', 'slash') and os.sep != '/'
             return self._slash
         else:
             raise AttributeError, name
 
     def _join(self, f):
         return os.path.join(self._root, f)
 
     def getcwd(self):
         cwd = os.getcwd()
         if cwd == self._root: return ''
         # self._root ends with a path separator if self._root is '/' or 'C:\'
         rootsep = self._root
         if not rootsep.endswith(os.sep):
             rootsep += os.sep
         if cwd.startswith(rootsep):
             return cwd[len(rootsep):]
         else:
             # we're outside the repo. return an absolute path.
             return cwd
 
     def pathto(self, f, cwd=None):
         if cwd is None:
             cwd = self.getcwd()
         path = util.pathto(self._root, cwd, f)
         if self._slash:
             return path.replace(os.sep, '/')
         return path
 
     def __getitem__(self, key):
         ''' current states:
         n  normal
         m  needs merging
         r  marked for removal
         a  marked for addition
         ?  not tracked'''
         return self._map.get(key, ("?",))[0]
 
     def __contains__(self, key):
         return key in self._map
 
     def __iter__(self):
         a = self._map.keys()
         a.sort()
         for x in a:
             yield x
 
     def parents(self):
         return self._pl
 
     def branch(self):
         return self._branch
 
     def setparents(self, p1, p2=nullid):
-        self._dirty = True
+        self._dirty = self._dirtypl = True
         self._pl = p1, p2
 
     def setbranch(self, branch):
         self._branch = branch
         self._opener("branch", "w").write(branch + '\n')
 
     def _read(self):
         self._map = {}
         self._copymap = {}
-        self._pl = [nullid, nullid]
+        if not self._dirtypl:
+            self._pl = [nullid, nullid]
         try:
             st = self._opener("dirstate").read()
         except IOError, err:
             if err.errno != errno.ENOENT: raise
             return
         if not st:
             return
 
-        self._pl = [st[:20], st[20: 40]]
+        if not self._dirtypl:
+            self._pl = [st[:20], st[20: 40]]
 
         # deref fields so they will be local in loop
         dmap = self._map
         copymap = self._copymap
         unpack = struct.unpack
 
         pos = 40
         e_size = struct.calcsize(_format)
 
         while pos < len(st):
             newpos = pos + e_size
             e = unpack(_format, st[pos:newpos])
             l = e[4]
             pos = newpos
             newpos = pos + l
             f = st[pos:newpos]
             if '\0' in f:
                 f, c = f.split('\0')
                 copymap[f] = c
             dmap[f] = e[:4]
             pos = newpos
 
     def invalidate(self):
         for a in "_map _copymap _branch _pl _dirs _ignore".split():
-            if hasattr(self, a):
-                self.__delattr__(a)
+            if a in self.__dict__:
+                delattr(self, a)
         self._dirty = False
 
     def copy(self, source, dest):
         self._dirty = True
         self._copymap[dest] = source
 
     def copied(self, file):
         return self._copymap.get(file, None)
 
     def copies(self):
         return self._copymap
 
     def _incpath(self, path):
         for c in strutil.findall(path, '/'):
             pc = path[:c]
             self._dirs.setdefault(pc, 0)
             self._dirs[pc] += 1
 
     def _decpath(self, path):
         for c in strutil.findall(path, '/'):
             pc = path[:c]
             self._dirs.setdefault(pc, 0)
             self._dirs[pc] -= 1
 
     def _incpathcheck(self, f):
         if '\r' in f or '\n' in f:
             raise util.Abort(_("'\\n' and '\\r' disallowed in filenames"))
         # shadows
         if f in self._dirs:
             raise util.Abort(_('directory named %r already in dirstate') % f)
         for c in strutil.rfindall(f, '/'):
             d = f[:c]
             if d in self._dirs:
                 break
             if d in self._map:
                 raise util.Abort(_('file named %r already in dirstate') % d)
         self._incpath(f)
 
     def normal(self, f):
         'mark a file normal'
         self._dirty = True
         s = os.lstat(self._join(f))
         self._map[f] = ('n', s.st_mode, s.st_size, s.st_mtime)
         if self._copymap.has_key(f):
             del self._copymap[f]
 
     def normaldirty(self, f):
         'mark a file normal, but possibly dirty'
         self._dirty = True
         s = os.lstat(self._join(f))
         self._map[f] = ('n', s.st_mode, -1, -1)
         if f in self._copymap:
             del self._copymap[f]
 
     def add(self, f):
         'mark a file added'
         self._dirty = True
         self._incpathcheck(f)
         self._map[f] = ('a', 0, -1, -1)
         if f in self._copymap:
             del self._copymap[f]
 
     def remove(self, f):
         'mark a file removed'
         self._dirty = True
         self._map[f] = ('r', 0, 0, 0)
         self._decpath(f)
         if f in self._copymap:
             del self._copymap[f]
 
     def merge(self, f):
         'mark a file merged'
         self._dirty = True
         s = os.lstat(self._join(f))
         self._map[f] = ('m', s.st_mode, s.st_size, s.st_mtime)
         if f in self._copymap:
             del self._copymap[f]
 
     def forget(self, f):
         'forget a file'
         self._dirty = True
         try:
             del self._map[f]
             self._decpath(f)
         except KeyError:
             self._ui.warn(_("not in dirstate: %s!\n") % f)
 
     def rebuild(self, parent, files):
         self.invalidate()
         for f in files:
             if files.execf(f):
                 self._map[f] = ('n', 0777, -1, 0)
             else:
                 self._map[f] = ('n', 0666, -1, 0)
         self._pl = (parent, nullid)
         self._dirty = True
 
     def write(self):
         if not self._dirty:
             return
         cs = cStringIO.StringIO()
         cs.write("".join(self._pl))
         for f, e in self._map.iteritems():
             c = self.copied(f)
             if c:
                 f = f + "\0" + c
             e = struct.pack(_format, e[0], e[1], e[2], e[3], len(f))
             cs.write(e)
             cs.write(f)
         st = self._opener("dirstate", "w", atomictemp=True)
         st.write(cs.getvalue())
         st.rename()
-        self._dirty = False
+        self._dirty = self._dirtypl = False
 
     def _filter(self, files):
         ret = {}
         unknown = []
 
         for x in files:
             if x == '.':
                 return self._map.copy()
             if x not in self._map:
                 unknown.append(x)
             else:
                 ret[x] = self._map[x]
 
         if not unknown:
             return ret
 
         b = self._map.keys()
         b.sort()
         blen = len(b)
 
         for x in unknown:
             bs = bisect.bisect(b, "%s%s" % (x, '/'))
             while bs < blen:
                 s = b[bs]
                 if len(s) > len(x) and s.startswith(x):
                     ret[s] = self._map[s]
                 else:
                     break
                 bs += 1
         return ret
 
     def _supported(self, f, st, verbose=False):
         if stat.S_ISREG(st.st_mode) or stat.S_ISLNK(st.st_mode):
             return True
         if verbose:
             kind = 'unknown'
             if stat.S_ISCHR(st.st_mode): kind = _('character device')
             elif stat.S_ISBLK(st.st_mode): kind = _('block device')
             elif stat.S_ISFIFO(st.st_mode): kind = _('fifo')
             elif stat.S_ISSOCK(st.st_mode): kind = _('socket')
             elif stat.S_ISDIR(st.st_mode): kind = _('directory')
             self._ui.warn(_('%s: unsupported file type (type is %s)\n')
                           % (self.pathto(f), kind))
         return False
 
     def walk(self, files=None, match=util.always, badmatch=None):
         # filter out the stat
         for src, f, st in self.statwalk(files, match, badmatch=badmatch):
             yield src, f
 
     def statwalk(self, files=None, match=util.always, ignored=False,
                  badmatch=None, directories=False):
         '''
         walk recursively through the directory tree, finding all files
         matched by the match function
 
         results are yielded in a tuple (src, filename, st), where src
         is one of:
         'f' the file was found in the directory tree
         'd' the file is a directory of the tree
         'm' the file was only in the dirstate and not in the tree
         'b' file was not found and matched badmatch
 
         and st is the stat result if the file was found in the directory.
         '''
 
         # walk all files by default
         if not files:
             files = ['.']
             dc = self._map.copy()
         else:
             files = util.unique(files)
             dc = self._filter(files)
 
         def imatch(file_):
             if file_ not in dc and self._ignore(file_):
                 return False
             return match(file_)
 
         ignore = self._ignore
         if ignored:
             imatch = match
             ignore = util.never
 
         # self._root may end with a path separator when self._root == '/'
         common_prefix_len = len(self._root)
         if not self._root.endswith(os.sep):
             common_prefix_len += 1
         # recursion free walker, faster than os.walk.
         def findfiles(s):
             work = [s]
             if directories:
                 yield 'd', util.normpath(s[common_prefix_len:]), os.lstat(s)
             while work:
                 top = work.pop()
                 names = os.listdir(top)
                 names.sort()
                 # nd is the top of the repository dir tree
                 nd = util.normpath(top[common_prefix_len:])
                 if nd == '.':
                     nd = ''
                 else:
                     # do not recurse into a repo contained in this
                     # one. use bisect to find .hg directory so speed
                     # is good on big directory.
                     hg = bisect.bisect_left(names, '.hg')
                     if hg < len(names) and names[hg] == '.hg':
                         if os.path.isdir(os.path.join(top, '.hg')):
                             continue
                 for f in names:
                     np = util.pconvert(os.path.join(nd, f))
                     if seen(np):
                         continue
                     p = os.path.join(top, f)
                     # don't trip over symlinks
                     st = os.lstat(p)
                     if stat.S_ISDIR(st.st_mode):
                         if not ignore(np):
                             work.append(p)
                             if directories:
                                 yield 'd', np, st
                         if imatch(np) and np in dc:
                             yield 'm', np, st
                     elif imatch(np):
                         if self._supported(np, st):
                             yield 'f', np, st
                         elif np in dc:
                             yield 'm', np, st
 
         known = {'.hg': 1}
         def seen(fn):
             if fn in known: return True
             known[fn] = 1
 
         # step one, find all files that match our criteria
         files.sort()
         for ff in files:
             nf = util.normpath(ff)
             f = self._join(ff)
             try:
                 st = os.lstat(f)
             except OSError, inst:
                 found = False
                 for fn in dc:
                     if nf == fn or (fn.startswith(nf) and fn[len(nf)] == '/'):
                         found = True
                         break
                 if not found:
                     if inst.errno != errno.ENOENT or not badmatch:
                         self._ui.warn('%s: %s\n' %
                                       (self.pathto(ff), inst.strerror))
                     elif badmatch and badmatch(ff) and imatch(nf):
                         yield 'b', ff, None
                 continue
             if stat.S_ISDIR(st.st_mode):
                 cmp1 = (lambda x, y: cmp(x[1], y[1]))
                 sorted_ = [ x for x in findfiles(f) ]
                 sorted_.sort(cmp1)
                 for e in sorted_:
                     yield e
             else:
                 if not seen(nf) and match(nf):
                     if self._supported(ff, st, verbose=True):
                         yield 'f', nf, st
                     elif ff in dc:
                         yield 'm', nf, st
 
         # step two run through anything left in the dc hash and yield
         # if we haven't already seen it
         ks = dc.keys()
         ks.sort()
         for k in ks:
             if not seen(k) and imatch(k):
                 yield 'm', k, None
 
     def status(self, files, match, list_ignored, list_clean):
         lookup, modified, added, unknown, ignored = [], [], [], [], []
         removed, deleted, clean = [], [], []
 
         for src, fn, st in self.statwalk(files, match, ignored=list_ignored):
             try:
                 type_, mode, size, time = self._map[fn]
             except KeyError:
                 if list_ignored and self._ignore(fn):
                     ignored.append(fn)
                 else:
                     unknown.append(fn)
                 continue
             if src == 'm':
                 nonexistent = True
                 if not st:
                     try:
                         st = os.lstat(self._join(fn))
                     except OSError, inst:
                         if inst.errno != errno.ENOENT:
                             raise
                         st = None
                     # We need to re-check that it is a valid file
                     if st and self._supported(fn, st):
                         nonexistent = False
                 # XXX: what to do with file no longer present in the fs
                 # who are not removed in the dirstate ?
                 if nonexistent and type_ in "nm":
                     deleted.append(fn)
                     continue
             # check the common case first
             if type_ == 'n':
                 if not st:
                     st = os.lstat(self._join(fn))
                 if (size >= 0 and (size != st.st_size
                                    or (mode ^ st.st_mode) & 0100)
                     or fn in self._copymap):
                     modified.append(fn)
                 elif time != int(st.st_mtime):
                     lookup.append(fn)
                 elif list_clean:
                     clean.append(fn)
             elif type_ == 'm':
                 modified.append(fn)
             elif type_ == 'a':
                 added.append(fn)
             elif type_ == 'r':
                 removed.append(fn)
 
         return (lookup, modified, added, removed, deleted, unknown, ignored,
                 clean)

mercurial/hgweb/hgwebdir_mod.py

@@ -1,258 +1,258 b''
 # hgweb/hgwebdir_mod.py - Web interface for a directory of repositories.
 #
 # Copyright 21 May 2005 - (c) 2005 Jake Edge <[e-mail]>
 # Copyright 2005, 2006 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 mercurial import demandimport; demandimport.enable()
 import os, mimetools, cStringIO
 from mercurial.i18n import gettext as _
 from mercurial import ui, hg, util, templater
 from common import get_mtime, staticfile, style_map, paritygen
 from hgweb_mod import hgweb
 
 # This is a stopgap
 class hgwebdir(object):
     def __init__(self, config, parentui=None):
         def cleannames(items):
             return [(name.strip(os.sep), path) for name, path in items]
 
         self.parentui = parentui
         self.motd = None
         self.style = None
         self.stripecount = None
         self.repos_sorted = ('name', False)
         if isinstance(config, (list, tuple)):
             self.repos = cleannames(config)
             self.repos_sorted = ('', False)
         elif isinstance(config, dict):
             self.repos = cleannames(config.items())
             self.repos.sort()
         else:
             if isinstance(config, util.configparser):
                 cp = config
             else:
                 cp = util.configparser()
                 cp.read(config)
             self.repos = []
             if cp.has_section('web'):
                 if cp.has_option('web', 'motd'):
                     self.motd = cp.get('web', 'motd')
                 if cp.has_option('web', 'style'):
                     self.style = cp.get('web', 'style')
                 if cp.has_option('web', 'stripes'):
                     self.stripecount = int(cp.get('web', 'stripes'))
             if cp.has_section('paths'):
                 self.repos.extend(cleannames(cp.items('paths')))
             if cp.has_section('collections'):
                 for prefix, root in cp.items('collections'):
                     for path in util.walkrepos(root):
                         repo = os.path.normpath(path)
                         name = repo
                         if name.startswith(prefix):
                             name = name[len(prefix):]
                         self.repos.append((name.lstrip(os.sep), repo))
             self.repos.sort()
 
     def run(self):
         if not os.environ.get('GATEWAY_INTERFACE', '').startswith("CGI/1."):
             raise RuntimeError("This function is only intended to be called while running as a CGI script.")
         import mercurial.hgweb.wsgicgi as wsgicgi
         from request import wsgiapplication
         def make_web_app():
             return self
         wsgicgi.launch(wsgiapplication(make_web_app))
 
     def run_wsgi(self, req):
         def header(**map):
             header_file = cStringIO.StringIO(
                 ''.join(tmpl("header", encoding=util._encoding, **map)))
             msg = mimetools.Message(header_file, 0)
             req.header(msg.items())
             yield header_file.read()
 
         def footer(**map):
             yield tmpl("footer", **map)
 
         def motd(**map):
             if self.motd is not None:
                 yield self.motd
             else:
                 yield config('web', 'motd', '')
 
         parentui = self.parentui or ui.ui(report_untrusted=False)
 
         def config(section, name, default=None, untrusted=True):
             return parentui.config(section, name, default, untrusted)
 
         url = req.env['REQUEST_URI'].split('?')[0]
         if not url.endswith('/'):
             url += '/'
         pathinfo = req.env.get('PATH_INFO', '').strip('/') + '/'
         base = url[:len(url) - len(pathinfo)]
         if not base.endswith('/'):
             base += '/'
 
         staticurl = config('web', 'staticurl') or base + 'static/'
         if not staticurl.endswith('/'):
             staticurl += '/'
 
         style = self.style
         if style is None:
             style = config('web', 'style', '')
         if req.form.has_key('style'):
             style = req.form['style'][0]
         if self.stripecount is None:
             self.stripecount = int(config('web', 'stripes', 1))
         mapfile = style_map(templater.templatepath(), style)
         tmpl = templater.templater(mapfile, templater.common_filters,
                                    defaults={"header": header,
                                              "footer": footer,
                                              "motd": motd,
                                              "url": url,
                                              "staticurl": staticurl})
 
         def archivelist(ui, nodeid, url):
             allowed = ui.configlist("web", "allow_archive", untrusted=True)
             for i in [('zip', '.zip'), ('gz', '.tar.gz'), ('bz2', '.tar.bz2')]:
                 if i[0] in allowed or ui.configbool("web", "allow" + i[0],
                                                     untrusted=True):
                     yield {"type" : i[0], "extension": i[1],
                            "node": nodeid, "url": url}
 
         def entries(sortcolumn="", descending=False, subdir="", **map):
             def sessionvars(**map):
                 fields = []
                 if req.form.has_key('style'):
                     style = req.form['style'][0]
                     if style != get('web', 'style', ''):
                         fields.append(('style', style))
 
                 separator = url[-1] == '?' and ';' or '?'
                 for name, value in fields:
                     yield dict(name=name, value=value, separator=separator)
                     separator = ';'
 
             rows = []
             parity = paritygen(self.stripecount)
             for name, path in self.repos:
                 if not name.startswith(subdir):
                     continue
                 name = name[len(subdir):]
 
                 u = ui.ui(parentui=parentui)
                 try:
                     u.readconfig(os.path.join(path, '.hg', 'hgrc'))
                 except IOError:
                     pass
                 def get(section, name, default=None):
                     return u.config(section, name, default, untrusted=True)
 
                 if u.configbool("web", "hidden", untrusted=True):
                     continue
 
                 url = ('/'.join([req.env["REQUEST_URI"].split('?')[0], name])
                        .replace("//", "/")) + '/'
 
                 # update time with local timezone
                 try:
                     d = (get_mtime(path), util.makedate()[1])
                 except OSError:
                     continue
 
                 contact = (get("ui", "username") or # preferred
                            get("web", "contact") or # deprecated
                            get("web", "author", "")) # also
                 description = get("web", "description", "")
                 name = get("web", "name", name)
                 row = dict(contact=contact or "unknown",
                            contact_sort=contact.upper() or "unknown",
                            name=name,
                            name_sort=name,
                            url=url,
                            description=description or "unknown",
                            description_sort=description.upper() or "unknown",
                            lastchange=d,
                            lastchange_sort=d[1]-d[0],
                            sessionvars=sessionvars,
                            archives=archivelist(u, "tip", url))
                 if (not sortcolumn
                     or (sortcolumn, descending) == self.repos_sorted):
                     # fast path for unsorted output
                     row['parity'] = parity.next()
                     yield row
                 else:
                     rows.append((row["%s_sort" % sortcolumn], row))
             if rows:
                 rows.sort()
                 if descending:
                     rows.reverse()
                 for key, row in rows:
                     row['parity'] = parity.next()
                     yield row
 
         def makeindex(req, subdir=""):
             sortable = ["name", "description", "contact", "lastchange"]
             sortcolumn, descending = self.repos_sorted
             if req.form.has_key('sort'):
                 sortcolumn = req.form['sort'][0]
                 descending = sortcolumn.startswith('-')
                 if descending:
                     sortcolumn = sortcolumn[1:]
                 if sortcolumn not in sortable:
                     sortcolumn = ""
 
             sort = [("sort_%s" % column,
                      "%s%s" % ((not descending and column == sortcolumn)
                                and "-" or "", column))
                     for column in sortable]
             req.write(tmpl("index", entries=entries, subdir=subdir,
                            sortcolumn=sortcolumn, descending=descending,
                            **dict(sort)))
 
         try:
             virtual = req.env.get("PATH_INFO", "").strip('/')
             if virtual.startswith('static/'):
                 static = os.path.join(templater.templatepath(), 'static')
                 fname = virtual[7:]
                 req.write(staticfile(static, fname, req) or
                           tmpl('error', error='%r not found' % fname))
             elif virtual:
                 repos = dict(self.repos)
                 while virtual:
                     real = repos.get(virtual)
                     if real:
                         req.env['REPO_NAME'] = virtual
                         try:
                             repo = hg.repository(parentui, real)
                             hgweb(repo).run_wsgi(req)
                         except IOError, inst:
                             req.write(tmpl("error", error=inst.strerror))
                         except hg.RepoError, inst:
                             req.write(tmpl("error", error=str(inst)))
                         return
 
                     # browse subdirectories
                     subdir = virtual + '/'
                     if [r for r in repos if r.startswith(subdir)]:
                         makeindex(req, subdir)
                         return
 
                     up = virtual.rfind('/')
                     if up < 0:
                         break
                     virtual = virtual[:up]
-                
+
                 req.write(tmpl("notfound", repo=virtual))
             else:
                 if req.form.has_key('static'):
                     static = os.path.join(templater.templatepath(), "static")
                     fname = req.form['static'][0]
                     req.write(staticfile(static, fname, req)
                               or tmpl("error", error="%r not found" % fname))
                 else:
                     makeindex(req)
         finally:
             tmpl = None

mercurial/hgweb/server.py

@@ -1,289 +1,289 b''
 # hgweb/server.py - The standalone hg web server.
 #
 # Copyright 21 May 2005 - (c) 2005 Jake Edge <[e-mail]>
 # 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.
 
 import os, sys, errno, urllib, BaseHTTPServer, socket, SocketServer, traceback
 from mercurial import ui, hg, util, templater
 from hgweb_mod import hgweb
 from hgwebdir_mod import hgwebdir
 from request import wsgiapplication
 from mercurial.i18n import gettext as _
 
 def _splitURI(uri):
     """ Return path and query splited from uri
 
     Just like CGI environment, the path is unquoted, the query is
     not.
     """
     if '?' in uri:
         path, query = uri.split('?', 1)
     else:
         path, query = uri, ''
     return urllib.unquote(path), query
 
 class _error_logger(object):
     def __init__(self, handler):
         self.handler = handler
     def flush(self):
         pass
     def write(self, str):
         self.writelines(str.split('\n'))
     def writelines(self, seq):
         for msg in seq:
             self.handler.log_error("HG error:  %s", msg)
 
 class _hgwebhandler(object, BaseHTTPServer.BaseHTTPRequestHandler):
 
     url_scheme = 'http'
-    
+
     def __init__(self, *args, **kargs):
         self.protocol_version = 'HTTP/1.1'
         BaseHTTPServer.BaseHTTPRequestHandler.__init__(self, *args, **kargs)
 
     def log_error(self, format, *args):
         errorlog = self.server.errorlog
         errorlog.write("%s - - [%s] %s\n" % (self.client_address[0],
                                              self.log_date_time_string(),
                                              format % args))
 
     def log_message(self, format, *args):
         accesslog = self.server.accesslog
         accesslog.write("%s - - [%s] %s\n" % (self.client_address[0],
                                               self.log_date_time_string(),
                                               format % args))
 
     def do_write(self):
         try:
             self.do_hgweb()
         except socket.error, inst:
             if inst[0] != errno.EPIPE:
                 raise
 
     def do_POST(self):
         try:
             self.do_write()
         except StandardError, inst:
             self._start_response("500 Internal Server Error", [])
             self._write("Internal Server Error")
             tb = "".join(traceback.format_exception(*sys.exc_info()))
             self.log_error("Exception happened during processing request '%s':\n%s",
                            self.path, tb)
 
     def do_GET(self):
         self.do_POST()
 
     def do_hgweb(self):
         path_info, query = _splitURI(self.path)
 
         env = {}
         env['GATEWAY_INTERFACE'] = 'CGI/1.1'
         env['REQUEST_METHOD'] = self.command
         env['SERVER_NAME'] = self.server.server_name
         env['SERVER_PORT'] = str(self.server.server_port)
         env['REQUEST_URI'] = self.path
         env['PATH_INFO'] = path_info
         env['REMOTE_HOST'] = self.client_address[0]
         env['REMOTE_ADDR'] = self.client_address[0]
         if query:
             env['QUERY_STRING'] = query
 
         if self.headers.typeheader is None:
             env['CONTENT_TYPE'] = self.headers.type
         else:
             env['CONTENT_TYPE'] = self.headers.typeheader
         length = self.headers.getheader('content-length')
         if length:
             env['CONTENT_LENGTH'] = length
         for header in [h for h in self.headers.keys()
                        if h not in ('content-type', 'content-length')]:
             hkey = 'HTTP_' + header.replace('-', '_').upper()
             hval = self.headers.getheader(header)
             hval = hval.replace('\n', '').strip()
             if hval:
                 env[hkey] = hval
         env['SERVER_PROTOCOL'] = self.request_version
         env['wsgi.version'] = (1, 0)
         env['wsgi.url_scheme'] = self.url_scheme
         env['wsgi.input'] = self.rfile
         env['wsgi.errors'] = _error_logger(self)
         env['wsgi.multithread'] = isinstance(self.server,
                                              SocketServer.ThreadingMixIn)
         env['wsgi.multiprocess'] = isinstance(self.server,
                                               SocketServer.ForkingMixIn)
         env['wsgi.run_once'] = 0
 
         self.close_connection = True
         self.saved_status = None
         self.saved_headers = []
         self.sent_headers = False
         self.length = None
         req = self.server.reqmaker(env, self._start_response)
         for data in req:
             if data:
                 self._write(data)
 
     def send_headers(self):
         if not self.saved_status:
             raise AssertionError("Sending headers before start_response() called")
         saved_status = self.saved_status.split(None, 1)
         saved_status[0] = int(saved_status[0])
         self.send_response(*saved_status)
         should_close = True
         for h in self.saved_headers:
             self.send_header(*h)
             if h[0].lower() == 'content-length':
                 should_close = False
                 self.length = int(h[1])
         # The value of the Connection header is a list of case-insensitive
         # tokens separated by commas and optional whitespace.
         if 'close' in [token.strip().lower() for token in
                        self.headers.get('connection', '').split(',')]:
             should_close = True
         if should_close:
             self.send_header('Connection', 'close')
         self.close_connection = should_close
         self.end_headers()
         self.sent_headers = True
 
     def _start_response(self, http_status, headers, exc_info=None):
         code, msg = http_status.split(None, 1)
         code = int(code)
         self.saved_status = http_status
         bad_headers = ('connection', 'transfer-encoding')
         self.saved_headers = [h for h in headers
                               if h[0].lower() not in bad_headers]
         return self._write
 
     def _write(self, data):
         if not self.saved_status:
             raise AssertionError("data written before start_response() called")
         elif not self.sent_headers:
             self.send_headers()
         if self.length is not None:
             if len(data) > self.length:
                 raise AssertionError("Content-length header sent, but more bytes than specified are being written.")
             self.length = self.length - len(data)
         self.wfile.write(data)
         self.wfile.flush()
 
 class _shgwebhandler(_hgwebhandler):
 
     url_scheme = 'https'
-    
+
     def setup(self):
         self.connection = self.request
         self.rfile = socket._fileobject(self.request, "rb", self.rbufsize)
         self.wfile = socket._fileobject(self.request, "wb", self.wbufsize)
 
     def do_write(self):
         from OpenSSL.SSL import SysCallError
         try:
             super(_shgwebhandler, self).do_write()
         except SysCallError, inst:
             if inst.args[0] != errno.EPIPE:
                 raise
 
     def handle_one_request(self):
         from OpenSSL.SSL import SysCallError, ZeroReturnError
         try:
             super(_shgwebhandler, self).handle_one_request()
         except (SysCallError, ZeroReturnError):
             self.close_connection = True
             pass
 
 def create_server(ui, repo):
     use_threads = True
 
     def openlog(opt, default):
         if opt and opt != '-':
             return open(opt, 'w')
         return default
 
     address = repo.ui.config("web", "address", "")
     port = int(repo.ui.config("web", "port", 8000))
     use_ipv6 = repo.ui.configbool("web", "ipv6")
     webdir_conf = repo.ui.config("web", "webdir_conf")
     ssl_cert = repo.ui.config("web", "certificate")
     accesslog = openlog(repo.ui.config("web", "accesslog", "-"), sys.stdout)
     errorlog = openlog(repo.ui.config("web", "errorlog", "-"), sys.stderr)
 
     if use_threads:
         try:
             from threading import activeCount
         except ImportError:
             use_threads = False
 
     if use_threads:
         _mixin = SocketServer.ThreadingMixIn
     else:
         if hasattr(os, "fork"):
             _mixin = SocketServer.ForkingMixIn
         else:
             class _mixin:
                 pass
 
     class MercurialHTTPServer(object, _mixin, BaseHTTPServer.HTTPServer):
 
         # SO_REUSEADDR has broken semantics on windows
         if os.name == 'nt':
             allow_reuse_address = 0
 
         def __init__(self, *args, **kargs):
             BaseHTTPServer.HTTPServer.__init__(self, *args, **kargs)
             self.accesslog = accesslog
             self.errorlog = errorlog
             self.daemon_threads = True
             def make_handler():
                 if webdir_conf:
                     hgwebobj = hgwebdir(webdir_conf, ui)
                 elif repo is not None:
                     hgwebobj = hgweb(hg.repository(repo.ui, repo.root))
                 else:
                     raise hg.RepoError(_("There is no Mercurial repository here"
                                          " (.hg not found)"))
                 return hgwebobj
             self.reqmaker = wsgiapplication(make_handler)
 
             addr = address
             if addr in ('', '::'):
                 addr = socket.gethostname()
 
             self.addr, self.port = addr, port
 
             if ssl_cert:
                 try:
                     from OpenSSL import SSL
                     ctx = SSL.Context(SSL.SSLv23_METHOD)
                 except ImportError:
                     raise util.Abort("SSL support is unavailable")
                 ctx.use_privatekey_file(ssl_cert)
                 ctx.use_certificate_file(ssl_cert)
                 sock = socket.socket(self.address_family, self.socket_type)
                 self.socket = SSL.Connection(ctx, sock)
                 self.server_bind()
                 self.server_activate()
 
     class IPv6HTTPServer(MercurialHTTPServer):
         address_family = getattr(socket, 'AF_INET6', None)
 
         def __init__(self, *args, **kwargs):
             if self.address_family is None:
                 raise hg.RepoError(_('IPv6 not available on this system'))
             super(IPv6HTTPServer, self).__init__(*args, **kwargs)
 
     if ssl_cert:
         handler = _shgwebhandler
     else:
         handler = _hgwebhandler
 
     try:
         if use_ipv6:
             return IPv6HTTPServer((address, port), handler)
         else:
             return MercurialHTTPServer((address, port), handler)
     except socket.error, inst:
         raise util.Abort(_('cannot start server: %s') % inst.args[1])

mercurial/lock.py

@@ -1,122 +1,120 b''
 # lock.py - simple locking scheme for mercurial
 #
 # Copyright 2005, 2006 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.
 
 import errno, os, socket, time, util
 
 class LockException(IOError):
     def __init__(self, errno, strerror, filename, desc):
         IOError.__init__(self, errno, strerror, filename)
         self.desc = desc
 
 class LockHeld(LockException):
     def __init__(self, errno, filename, desc, locker):
         LockException.__init__(self, errno, 'Lock held', filename, desc)
         self.locker = locker
 
 class LockUnavailable(LockException):
     pass
 
 class lock(object):
     # lock is symlink on platforms that support it, file on others.
 
     # symlink is used because create of directory entry and contents
     # are atomic even over nfs.
 
     # old-style lock: symlink to pid
     # new-style lock: symlink to hostname:pid
 
+    _host = None
+
     def __init__(self, file, timeout=-1, releasefn=None, desc=None):
         self.f = file
         self.held = 0
         self.timeout = timeout
         self.releasefn = releasefn
-        self.id = None
-        self.host = None
-        self.pid = None
         self.desc = desc
         self.lock()
 
     def __del__(self):
         self.release()
 
     def lock(self):
         timeout = self.timeout
         while 1:
             try:
                 self.trylock()
                 return 1
             except LockHeld, inst:
                 if timeout != 0:
                     time.sleep(1)
                     if timeout > 0:
                         timeout -= 1
                     continue
                 raise LockHeld(errno.ETIMEDOUT, inst.filename, self.desc,
                                inst.locker)
 
     def trylock(self):
-        if self.id is None:
-            self.host = socket.gethostname()
-            self.pid = os.getpid()
-            self.id = '%s:%s' % (self.host, self.pid)
+        if lock._host is None:
+            lock._host = socket.gethostname()
+        lockname = '%s:%s' % (lock._host, os.getpid())
         while not self.held:
             try:
-                util.makelock(self.id, self.f)
+                util.makelock(lockname, self.f)
                 self.held = 1
             except (OSError, IOError), why:
                 if why.errno == errno.EEXIST:
                     locker = self.testlock()
                     if locker is not None:
                         raise LockHeld(errno.EAGAIN, self.f, self.desc,
                                        locker)
                 else:
                     raise LockUnavailable(why.errno, why.strerror,
                                           why.filename, self.desc)
 
     def testlock(self):
         """return id of locker if lock is valid, else None.
 
         If old-style lock, we cannot tell what machine locker is on.
         with new-style lock, if locker is on this machine, we can
         see if locker is alive.  If locker is on this machine but
         not alive, we can safely break lock.
 
         The lock file is only deleted when None is returned.
 
         """
         locker = util.readlock(self.f)
         try:
             host, pid = locker.split(":", 1)
         except ValueError:
             return locker
-        if host != self.host:
+        if host != lock._host:
             return locker
         try:
             pid = int(pid)
         except:
             return locker
         if util.testpid(pid):
             return locker
         # if locker dead, break lock.  must do this with another lock
         # held, or can race and break valid lock.
         try:
             l = lock(self.f + '.break')
             l.trylock()
             os.unlink(self.f)
             l.release()
         except (LockHeld, LockUnavailable):
             return locker
 
     def release(self):
         if self.held:
             self.held = 0
             if self.releasefn:
                 self.releasefn()
             try:
                 os.unlink(self.f)
             except: pass
 

mercurial/patch.py

@@ -1,1319 +1,1319 b''
 # patch.py - patch file parsing routines
 #
 # Copyright 2006 Brendan Cully <[e-mail]>
 # Copyright 2007 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.
 
 from i18n import _
 from node import *
 import base85, cmdutil, mdiff, util, context, revlog, diffhelpers
 import cStringIO, email.Parser, os, popen2, re, sha
 import sys, tempfile, zlib
 
 class PatchError(Exception):
     pass
 
 class NoHunks(PatchError):
     pass
 
 # helper functions
 
 def copyfile(src, dst, basedir=None):
     if not basedir:
         basedir = os.getcwd()
 
     abssrc, absdst = [os.path.join(basedir, n) for n in (src, dst)]
     if os.path.exists(absdst):
         raise util.Abort(_("cannot create %s: destination already exists") %
                          dst)
 
     targetdir = os.path.dirname(absdst)
     if not os.path.isdir(targetdir):
         os.makedirs(targetdir)
 
     util.copyfile(abssrc, absdst)
 
 # public functions
 
 def extract(ui, fileobj):
     '''extract patch from data read from fileobj.
 
     patch can be a normal patch or contained in an email message.
 
     return tuple (filename, message, user, date, node, p1, p2).
     Any item in the returned tuple can be None. If filename is None,
     fileobj did not contain a patch. Caller must unlink filename when done.'''
 
     # attempt to detect the start of a patch
     # (this heuristic is borrowed from quilt)
     diffre = re.compile(r'^(?:Index:[ \t]|diff[ \t]|RCS file: |' +
                         'retrieving revision [0-9]+(\.[0-9]+)*$|' +
                         '(---|\*\*\*)[ \t])', re.MULTILINE)
 
     fd, tmpname = tempfile.mkstemp(prefix='hg-patch-')
     tmpfp = os.fdopen(fd, 'w')
     try:
         msg = email.Parser.Parser().parse(fileobj)
 
         subject = msg['Subject']
         user = msg['From']
         # should try to parse msg['Date']
         date = None
         nodeid = None
         branch = None
         parents = []
 
         if subject:
             if subject.startswith('[PATCH'):
                 pend = subject.find(']')
                 if pend >= 0:
                     subject = subject[pend+1:].lstrip()
             subject = subject.replace('\n\t', ' ')
             ui.debug('Subject: %s\n' % subject)
         if user:
             ui.debug('From: %s\n' % user)
         diffs_seen = 0
         ok_types = ('text/plain', 'text/x-diff', 'text/x-patch')
         message = ''
         for part in msg.walk():
             content_type = part.get_content_type()
             ui.debug('Content-Type: %s\n' % content_type)
             if content_type not in ok_types:
                 continue
             payload = part.get_payload(decode=True)
             m = diffre.search(payload)
             if m:
                 hgpatch = False
                 ignoretext = False
 
                 ui.debug(_('found patch at byte %d\n') % m.start(0))
                 diffs_seen += 1
                 cfp = cStringIO.StringIO()
                 for line in payload[:m.start(0)].splitlines():
                     if line.startswith('# HG changeset patch'):
                         ui.debug(_('patch generated by hg export\n'))
                         hgpatch = True
                         # drop earlier commit message content
                         cfp.seek(0)
                         cfp.truncate()
                         subject = None
                     elif hgpatch:
                         if line.startswith('# User '):
                             user = line[7:]
                             ui.debug('From: %s\n' % user)
                         elif line.startswith("# Date "):
                             date = line[7:]
                         elif line.startswith("# Branch "):
                             branch = line[9:]
                         elif line.startswith("# Node ID "):
                             nodeid = line[10:]
                         elif line.startswith("# Parent "):
                             parents.append(line[10:])
                     elif line == '---' and 'git-send-email' in msg['X-Mailer']:
                         ignoretext = True
                     if not line.startswith('# ') and not ignoretext:
                         cfp.write(line)
                         cfp.write('\n')
                 message = cfp.getvalue()
                 if tmpfp:
                     tmpfp.write(payload)
                     if not payload.endswith('\n'):
                         tmpfp.write('\n')
             elif not diffs_seen and message and content_type == 'text/plain':
                 message += '\n' + payload
     except:
         tmpfp.close()
         os.unlink(tmpname)
         raise
 
     if subject and not message.startswith(subject):
         message = '%s\n%s' % (subject, message)
     tmpfp.close()
     if not diffs_seen:
         os.unlink(tmpname)
         return None, message, user, date, branch, None, None, None
     p1 = parents and parents.pop(0) or None
     p2 = parents and parents.pop(0) or None
     return tmpname, message, user, date, branch, nodeid, p1, p2
 
 GP_PATCH  = 1 << 0  # we have to run patch
 GP_FILTER = 1 << 1  # there's some copy/rename operation
 GP_BINARY = 1 << 2  # there's a binary patch
 
 def readgitpatch(fp, firstline):
     """extract git-style metadata about patches from <patchname>"""
     class gitpatch:
         "op is one of ADD, DELETE, RENAME, MODIFY or COPY"
         def __init__(self, path):
             self.path = path
             self.oldpath = None
             self.mode = None
             self.op = 'MODIFY'
             self.copymod = False
             self.lineno = 0
             self.binary = False
 
     def reader(fp, firstline):
         yield firstline
         for line in fp:
             yield line
 
     # Filter patch for git information
     gitre = re.compile('diff --git a/(.*) b/(.*)')
     gp = None
     gitpatches = []
     # Can have a git patch with only metadata, causing patch to complain
     dopatch = 0
 
     lineno = 0
     for line in reader(fp, firstline):
         lineno += 1
         if line.startswith('diff --git'):
             m = gitre.match(line)
             if m:
                 if gp:
                     gitpatches.append(gp)
                 src, dst = m.group(1, 2)
                 gp = gitpatch(dst)
                 gp.lineno = lineno
         elif gp:
             if line.startswith('--- '):
                 if gp.op in ('COPY', 'RENAME'):
                     gp.copymod = True
                     dopatch |= GP_FILTER
                 gitpatches.append(gp)
                 gp = None
                 dopatch |= GP_PATCH
                 continue
             if line.startswith('rename from '):
                 gp.op = 'RENAME'
                 gp.oldpath = line[12:].rstrip()
             elif line.startswith('rename to '):
                 gp.path = line[10:].rstrip()
             elif line.startswith('copy from '):
                 gp.op = 'COPY'
                 gp.oldpath = line[10:].rstrip()
             elif line.startswith('copy to '):
                 gp.path = line[8:].rstrip()
             elif line.startswith('deleted file'):
                 gp.op = 'DELETE'
             elif line.startswith('new file mode '):
                 gp.op = 'ADD'
                 gp.mode = int(line.rstrip()[-3:], 8)
             elif line.startswith('new mode '):
                 gp.mode = int(line.rstrip()[-3:], 8)
             elif line.startswith('GIT binary patch'):
                 dopatch |= GP_BINARY
                 gp.binary = True
     if gp:
         gitpatches.append(gp)
 
     if not gitpatches:
         dopatch = GP_PATCH
 
     return (dopatch, gitpatches)
 
 def patch(patchname, ui, strip=1, cwd=None, files={}):
     """apply <patchname> to the working directory.
     returns whether patch was applied with fuzz factor."""
     patcher = ui.config('ui', 'patch')
     args = []
     try:
         if patcher:
             return externalpatch(patcher, args, patchname, ui, strip, cwd,
                                  files)
         else:
             try:
                 return internalpatch(patchname, ui, strip, cwd, files)
             except NoHunks:
                 patcher = util.find_exe('gpatch') or util.find_exe('patch')
                 ui.debug('no valid hunks found; trying with %r instead\n' %
                          patcher)
                 if util.needbinarypatch():
                     args.append('--binary')
                 return externalpatch(patcher, args, patchname, ui, strip, cwd,
                                      files)
     except PatchError, err:
         s = str(err)
         if s:
             raise util.Abort(s)
         else:
             raise util.Abort(_('patch failed to apply'))
 
 def externalpatch(patcher, args, patchname, ui, strip, cwd, files):
     """use <patcher> to apply <patchname> to the working directory.
     returns whether patch was applied with fuzz factor."""
 
     fuzz = False
     if cwd:
         args.append('-d %s' % util.shellquote(cwd))
     fp = os.popen('%s %s -p%d < %s' % (patcher, ' '.join(args), strip,
                                        util.shellquote(patchname)))
 
     for line in fp:
         line = line.rstrip()
         ui.note(line + '\n')
         if line.startswith('patching file '):
             pf = util.parse_patch_output(line)
             printed_file = False
             files.setdefault(pf, (None, None))
         elif line.find('with fuzz') >= 0:
             fuzz = True
             if not printed_file:
                 ui.warn(pf + '\n')
                 printed_file = True
             ui.warn(line + '\n')
         elif line.find('saving rejects to file') >= 0:
             ui.warn(line + '\n')
         elif line.find('FAILED') >= 0:
             if not printed_file:
                 ui.warn(pf + '\n')
                 printed_file = True
             ui.warn(line + '\n')
     code = fp.close()
     if code:
         raise PatchError(_("patch command failed: %s") %
                          util.explain_exit(code)[0])
     return fuzz
 
 def internalpatch(patchname, ui, strip, cwd, files):
     """use builtin patch to apply <patchname> to the working directory.
     returns whether patch was applied with fuzz factor."""
-    fp = file(patchname)
+    fp = file(patchname, 'rb')
     if cwd:
         curdir = os.getcwd()
         os.chdir(cwd)
     try:
         ret = applydiff(ui, fp, files, strip=strip)
     finally:
         if cwd:
             os.chdir(curdir)
     if ret < 0:
         raise PatchError
     return ret > 0
 
 # @@ -start,len +start,len @@ or @@ -start +start @@ if len is 1
 unidesc = re.compile('@@ -(\d+)(,(\d+))? \+(\d+)(,(\d+))? @@')
 contextdesc = re.compile('(---|\*\*\*) (\d+)(,(\d+))? (---|\*\*\*)')
 
 class patchfile:
     def __init__(self, ui, fname):
         self.fname = fname
         self.ui = ui
         try:
-            fp = file(fname, 'r')
+            fp = file(fname, 'rb')
             self.lines = fp.readlines()
             self.exists = True
         except IOError:
             dirname = os.path.dirname(fname)
             if dirname and not os.path.isdir(dirname):
                 dirs = dirname.split(os.path.sep)
                 d = ""
                 for x in dirs:
                     d = os.path.join(d, x)
                     if not os.path.isdir(d):
                         os.mkdir(d)
             self.lines = []
             self.exists = False
             
         self.hash = {}
         self.dirty = 0
         self.offset = 0
         self.rej = []
         self.fileprinted = False
         self.printfile(False)
         self.hunks = 0
 
     def printfile(self, warn):
         if self.fileprinted:
             return
         if warn or self.ui.verbose:
             self.fileprinted = True
         s = _("patching file %s\n") % self.fname
         if warn:
             self.ui.warn(s)
         else:
             self.ui.note(s)
 
 
     def findlines(self, l, linenum):
         # looks through the hash and finds candidate lines.  The
         # result is a list of line numbers sorted based on distance
         # from linenum
         def sorter(a, b):
             vala = abs(a - linenum)
             valb = abs(b - linenum)
             return cmp(vala, valb)
             
         try:
             cand = self.hash[l]
         except:
             return []
 
         if len(cand) > 1:
             # resort our list of potentials forward then back.
             cand.sort(cmp=sorter)
         return cand
 
     def hashlines(self):
         self.hash = {}
         for x in xrange(len(self.lines)):
             s = self.lines[x]
             self.hash.setdefault(s, []).append(x)
 
     def write_rej(self):
         # our rejects are a little different from patch(1).  This always
         # creates rejects in the same form as the original patch.  A file
         # header is inserted so that you can run the reject through patch again
         # without having to type the filename.
 
         if not self.rej:
             return
         if self.hunks != 1:
             hunkstr = "s"
         else:
             hunkstr = ""
 
         fname = self.fname + ".rej"
         self.ui.warn(
             _("%d out of %d hunk%s FAILED -- saving rejects to file %s\n") %
             (len(self.rej), self.hunks, hunkstr, fname))
         try: os.unlink(fname)
         except:
             pass
-        fp = file(fname, 'w')
+        fp = file(fname, 'wb')
         base = os.path.basename(self.fname)
         fp.write("--- %s\n+++ %s\n" % (base, base))
         for x in self.rej:
             for l in x.hunk:
                 fp.write(l)
                 if l[-1] != '\n':
                     fp.write("\n\ No newline at end of file\n")
 
     def write(self, dest=None):
         if self.dirty:
             if not dest:
                 dest = self.fname
             st = None
             try:
                 st = os.lstat(dest)
                 if st.st_nlink > 1:
                     os.unlink(dest)
             except: pass
-            fp = file(dest, 'w')
+            fp = file(dest, 'wb')
             if st:
                 os.chmod(dest, st.st_mode)
             fp.writelines(self.lines)
             fp.close()
 
     def close(self):
         self.write()
         self.write_rej()
 
     def apply(self, h, reverse):
         if not h.complete():
             raise PatchError(_("bad hunk #%d %s (%d %d %d %d)") %
                             (h.number, h.desc, len(h.a), h.lena, len(h.b),
                             h.lenb))
 
         self.hunks += 1
         if reverse:
             h.reverse()
 
         if self.exists and h.createfile():
             self.ui.warn(_("file %s already exists\n") % self.fname)
             self.rej.append(h)
             return -1
 
         if isinstance(h, binhunk):
             if h.rmfile():
                 os.unlink(self.fname)
             else:
                 self.lines[:] = h.new()
                 self.offset += len(h.new())
                 self.dirty = 1
             return 0
 
         # fast case first, no offsets, no fuzz
         old = h.old()
         # patch starts counting at 1 unless we are adding the file
         if h.starta == 0:
             start = 0
         else:
             start = h.starta + self.offset - 1
         orig_start = start
         if diffhelpers.testhunk(old, self.lines, start) == 0:
             if h.rmfile():
                 os.unlink(self.fname)
             else:
                 self.lines[start : start + h.lena] = h.new()
                 self.offset += h.lenb - h.lena
                 self.dirty = 1
             return 0
 
         # ok, we couldn't match the hunk.  Lets look for offsets and fuzz it
         self.hashlines()
         if h.hunk[-1][0] != ' ':
             # if the hunk tried to put something at the bottom of the file
             # override the start line and use eof here
             search_start = len(self.lines)
         else:
             search_start = orig_start
 
         for fuzzlen in xrange(3):
             for toponly in [ True, False ]:
                 old = h.old(fuzzlen, toponly)
 
                 cand = self.findlines(old[0][1:], search_start)
                 for l in cand:
                     if diffhelpers.testhunk(old, self.lines, l) == 0:
                         newlines = h.new(fuzzlen, toponly)
                         self.lines[l : l + len(old)] = newlines
                         self.offset += len(newlines) - len(old)
                         self.dirty = 1
                         if fuzzlen:
                             fuzzstr = "with fuzz %d " % fuzzlen
                             f = self.ui.warn
                             self.printfile(True)
                         else:
                             fuzzstr = ""
                             f = self.ui.note
                         offset = l - orig_start - fuzzlen
                         if offset == 1:
                             linestr = "line"
                         else:
                             linestr = "lines"
                         f(_("Hunk #%d succeeded at %d %s(offset %d %s).\n") %
                           (h.number, l+1, fuzzstr, offset, linestr))
                         return fuzzlen
         self.printfile(True)
         self.ui.warn(_("Hunk #%d FAILED at %d\n") % (h.number, orig_start))
         self.rej.append(h)
         return -1
 
 class hunk:
     def __init__(self, desc, num, lr, context):
         self.number = num
         self.desc = desc
         self.hunk = [ desc ]
         self.a = []
         self.b = []
         if context:
             self.read_context_hunk(lr)
         else:
             self.read_unified_hunk(lr)
 
     def read_unified_hunk(self, lr):
         m = unidesc.match(self.desc)
         if not m:
             raise PatchError(_("bad hunk #%d") % self.number)
         self.starta, foo, self.lena, self.startb, foo2, self.lenb = m.groups()
         if self.lena == None:
             self.lena = 1
         else:
             self.lena = int(self.lena)
         if self.lenb == None:
             self.lenb = 1
         else:
             self.lenb = int(self.lenb)
         self.starta = int(self.starta)
         self.startb = int(self.startb)
         diffhelpers.addlines(lr.fp, self.hunk, self.lena, self.lenb, self.a, self.b)
         # if we hit eof before finishing out the hunk, the last line will
         # be zero length.  Lets try to fix it up.
         while len(self.hunk[-1]) == 0:
                 del self.hunk[-1]
                 del self.a[-1]
                 del self.b[-1]
                 self.lena -= 1
                 self.lenb -= 1
 
     def read_context_hunk(self, lr):
         self.desc = lr.readline()
         m = contextdesc.match(self.desc)
         if not m:
             raise PatchError(_("bad hunk #%d") % self.number)
         foo, self.starta, foo2, aend, foo3 = m.groups()
         self.starta = int(self.starta)
         if aend == None:
             aend = self.starta
         self.lena = int(aend) - self.starta
         if self.starta:
             self.lena += 1
         for x in xrange(self.lena):
             l = lr.readline()
             if l.startswith('---'):
                 lr.push(l)
                 break
             s = l[2:]
             if l.startswith('- ') or l.startswith('! '):
                 u = '-' + s
             elif l.startswith('  '):
                 u = ' ' + s
             else:
                 raise PatchError(_("bad hunk #%d old text line %d") %
                                  (self.number, x))
             self.a.append(u)
             self.hunk.append(u)
 
         l = lr.readline()
         if l.startswith('\ '):
             s = self.a[-1][:-1]
             self.a[-1] = s
             self.hunk[-1] = s
             l = lr.readline()
         m = contextdesc.match(l)
         if not m:
             raise PatchError(_("bad hunk #%d") % self.number)
         foo, self.startb, foo2, bend, foo3 = m.groups()
         self.startb = int(self.startb)
         if bend == None:
             bend = self.startb
         self.lenb = int(bend) - self.startb
         if self.startb:
             self.lenb += 1
         hunki = 1
         for x in xrange(self.lenb):
             l = lr.readline()
             if l.startswith('\ '):
                 s = self.b[-1][:-1]
                 self.b[-1] = s
                 self.hunk[hunki-1] = s
                 continue
             if not l:
                 lr.push(l)
                 break
             s = l[2:]
             if l.startswith('+ ') or l.startswith('! '):
                 u = '+' + s
             elif l.startswith('  '):
                 u = ' ' + s
             elif len(self.b) == 0:
                 # this can happen when the hunk does not add any lines
                 lr.push(l)
                 break
             else:
                 raise PatchError(_("bad hunk #%d old text line %d") %
                                  (self.number, x))
             self.b.append(s)
             while True:
                 if hunki >= len(self.hunk):
                     h = ""
                 else:
                     h = self.hunk[hunki]
                 hunki += 1
                 if h == u:
                     break
                 elif h.startswith('-'):
                     continue
                 else:
                     self.hunk.insert(hunki-1, u)
                     break
 
         if not self.a:
             # this happens when lines were only added to the hunk
             for x in self.hunk:
                 if x.startswith('-') or x.startswith(' '):
                     self.a.append(x)
         if not self.b:
             # this happens when lines were only deleted from the hunk
             for x in self.hunk:
                 if x.startswith('+') or x.startswith(' '):
                     self.b.append(x[1:])
         # @@ -start,len +start,len @@
         self.desc = "@@ -%d,%d +%d,%d @@\n" % (self.starta, self.lena,
                                              self.startb, self.lenb)
         self.hunk[0] = self.desc
 
     def reverse(self):
         origlena = self.lena
         origstarta = self.starta
         self.lena = self.lenb
         self.starta = self.startb
         self.lenb = origlena
         self.startb = origstarta
         self.a = []
         self.b = []
         # self.hunk[0] is the @@ description
         for x in xrange(1, len(self.hunk)):
             o = self.hunk[x]
             if o.startswith('-'):
                 n = '+' + o[1:]
                 self.b.append(o[1:])
             elif o.startswith('+'):
                 n = '-' + o[1:]
                 self.a.append(n)
             else:
                 n = o
                 self.b.append(o[1:])
                 self.a.append(o)
             self.hunk[x] = o
 
     def fix_newline(self):
         diffhelpers.fix_newline(self.hunk, self.a, self.b)
 
     def complete(self):
         return len(self.a) == self.lena and len(self.b) == self.lenb
 
     def createfile(self):
         return self.starta == 0 and self.lena == 0
 
     def rmfile(self):
         return self.startb == 0 and self.lenb == 0
 
     def fuzzit(self, l, fuzz, toponly):
         # this removes context lines from the top and bottom of list 'l'.  It
         # checks the hunk to make sure only context lines are removed, and then
         # returns a new shortened list of lines.
         fuzz = min(fuzz, len(l)-1)
         if fuzz:
             top = 0
             bot = 0
             hlen = len(self.hunk)
             for x in xrange(hlen-1):
                 # the hunk starts with the @@ line, so use x+1
                 if self.hunk[x+1][0] == ' ':
                     top += 1
                 else:
                     break
             if not toponly:
                 for x in xrange(hlen-1):
                     if self.hunk[hlen-bot-1][0] == ' ':
                         bot += 1
                     else:
                         break
 
             # top and bot now count context in the hunk
             # adjust them if either one is short
             context = max(top, bot, 3)
             if bot < context:
                 bot = max(0, fuzz - (context - bot))
             else:
                 bot = min(fuzz, bot)
             if top < context:
                 top = max(0, fuzz - (context - top))
             else:
                 top = min(fuzz, top)
 
             return l[top:len(l)-bot]
         return l
 
     def old(self, fuzz=0, toponly=False):
         return self.fuzzit(self.a, fuzz, toponly)
         
     def newctrl(self):
         res = []
         for x in self.hunk:
             c = x[0]
             if c == ' ' or c == '+':
                 res.append(x)
         return res
 
     def new(self, fuzz=0, toponly=False):
         return self.fuzzit(self.b, fuzz, toponly)
 
 class binhunk:
     'A binary patch file. Only understands literals so far.'
     def __init__(self, gitpatch):
         self.gitpatch = gitpatch
         self.text = None
         self.hunk = ['GIT binary patch\n']
 
     def createfile(self):
         return self.gitpatch.op in ('ADD', 'RENAME', 'COPY')
 
     def rmfile(self):
         return self.gitpatch.op == 'DELETE'
 
     def complete(self):
         return self.text is not None
 
     def new(self):
         return [self.text]
 
     def extract(self, fp):
         line = fp.readline()
         self.hunk.append(line)
         while line and not line.startswith('literal '):
             line = fp.readline()
             self.hunk.append(line)
         if not line:
             raise PatchError(_('could not extract binary patch'))
         size = int(line[8:].rstrip())
         dec = []
         line = fp.readline()
         self.hunk.append(line)
         while len(line) > 1:
             l = line[0]
             if l <= 'Z' and l >= 'A':
                 l = ord(l) - ord('A') + 1
             else:
                 l = ord(l) - ord('a') + 27
             dec.append(base85.b85decode(line[1:-1])[:l])
             line = fp.readline()
             self.hunk.append(line)
         text = zlib.decompress(''.join(dec))
         if len(text) != size:
             raise PatchError(_('binary patch is %d bytes, not %d') %
                              len(text), size)
         self.text = text
 
 def parsefilename(str):
     # --- filename \t|space stuff
     s = str[4:]
     i = s.find('\t')
     if i < 0:
         i = s.find(' ')
         if i < 0:
             return s
     return s[:i]
 
 def selectfile(afile_orig, bfile_orig, hunk, strip, reverse):
     def pathstrip(path, count=1):
         pathlen = len(path)
         i = 0
         if count == 0:
             return path.rstrip()
         while count > 0:
-            i = path.find(os.sep, i)
+            i = path.find('/', i)
             if i == -1:
                 raise PatchError(_("unable to strip away %d dirs from %s") %
                                  (count, path))
             i += 1
             # consume '//' in the path
-            while i < pathlen - 1 and path[i] == os.sep:
+            while i < pathlen - 1 and path[i] == '/':
                 i += 1
             count -= 1
         return path[i:].rstrip()
 
     nulla = afile_orig == "/dev/null"
     nullb = bfile_orig == "/dev/null"
     afile = pathstrip(afile_orig, strip)
     gooda = os.path.exists(afile) and not nulla
     bfile = pathstrip(bfile_orig, strip)
     if afile == bfile:
         goodb = gooda
     else:
         goodb = os.path.exists(bfile) and not nullb
     createfunc = hunk.createfile
     if reverse:
         createfunc = hunk.rmfile
     if not goodb and not gooda and not createfunc():
         raise PatchError(_("unable to find %s or %s for patching") %
                          (afile, bfile))
     if gooda and goodb:
         fname = bfile
         if afile in bfile:
             fname = afile
     elif gooda:
         fname = afile
     elif not nullb:
         fname = bfile
         if afile in bfile:
             fname = afile
     elif not nulla:
         fname = afile
     return fname
 
 class linereader:
     # simple class to allow pushing lines back into the input stream
     def __init__(self, fp):
         self.fp = fp
         self.buf = []
 
     def push(self, line):
         self.buf.append(line)
 
     def readline(self):
         if self.buf:
             l = self.buf[0]
             del self.buf[0]
             return l
         return self.fp.readline()
 
 def applydiff(ui, fp, changed, strip=1, sourcefile=None, reverse=False,
               rejmerge=None, updatedir=None):
     """reads a patch from fp and tries to apply it.  The dict 'changed' is
        filled in with all of the filenames changed by the patch.  Returns 0
        for a clean patch, -1 if any rejects were found and 1 if there was
        any fuzz.""" 
 
     def scangitpatch(fp, firstline, cwd=None):
         '''git patches can modify a file, then copy that file to
         a new file, but expect the source to be the unmodified form.
         So we scan the patch looking for that case so we can do
         the copies ahead of time.'''
 
         pos = 0
         try:
             pos = fp.tell()
         except IOError:
             fp = cStringIO.StringIO(fp.read())
 
         (dopatch, gitpatches) = readgitpatch(fp, firstline)
         for gp in gitpatches:
             if gp.copymod:
                 copyfile(gp.oldpath, gp.path, basedir=cwd)
 
         fp.seek(pos)
 
         return fp, dopatch, gitpatches
 
     current_hunk = None
     current_file = None
     afile = ""
     bfile = ""
     state = None
     hunknum = 0
     rejects = 0
 
     git = False
     gitre = re.compile('diff --git (a/.*) (b/.*)')
 
     # our states
     BFILE = 1
     err = 0
     context = None
     lr = linereader(fp)
     dopatch = True
     gitworkdone = False
 
     while True:
         newfile = False
         x = lr.readline()
         if not x:
             break
         if current_hunk:
             if x.startswith('\ '):
                 current_hunk.fix_newline()
             ret = current_file.apply(current_hunk, reverse)
             if ret >= 0:
                 changed.setdefault(current_file.fname, (None, None))
                 if ret > 0:
                     err = 1
             current_hunk = None
             gitworkdone = False
         if ((sourcefile or state == BFILE) and ((not context and x[0] == '@') or
             ((context or context == None) and x.startswith('***************')))):
             try:
                 if context == None and x.startswith('***************'):
                     context = True
                 current_hunk = hunk(x, hunknum + 1, lr, context)
             except PatchError, err:
                 ui.debug(err)
                 current_hunk = None
                 continue
             hunknum += 1
             if not current_file:
                 if sourcefile:
                     current_file = patchfile(ui, sourcefile)
                 else:
                     current_file = selectfile(afile, bfile, current_hunk,
                                               strip, reverse)
                     current_file = patchfile(ui, current_file)
         elif state == BFILE and x.startswith('GIT binary patch'):
             current_hunk = binhunk(changed[bfile[2:]][1])
             if not current_file:
                 if sourcefile:
                     current_file = patchfile(ui, sourcefile)
                 else:
                     current_file = selectfile(afile, bfile, current_hunk,
                                               strip, reverse)
                     current_file = patchfile(ui, current_file)
             hunknum += 1
             current_hunk.extract(fp)
         elif x.startswith('diff --git'):
             # check for git diff, scanning the whole patch file if needed
             m = gitre.match(x)
             if m:
                 afile, bfile = m.group(1, 2)
                 if not git:
                     git = True
                     fp, dopatch, gitpatches = scangitpatch(fp, x)
                     for gp in gitpatches:
                         changed[gp.path] = (gp.op, gp)
                 # else error?
                 # copy/rename + modify should modify target, not source
                 if changed.get(bfile[2:], (None, None))[0] in ('COPY',
                                                                'RENAME'):
                     afile = bfile
                     gitworkdone = True
             newfile = True
         elif x.startswith('---'):
             # check for a unified diff
             l2 = lr.readline()
             if not l2.startswith('+++'):
                 lr.push(l2)
                 continue
             newfile = True
             context = False
             afile = parsefilename(x)
             bfile = parsefilename(l2)
         elif x.startswith('***'):
             # check for a context diff
             l2 = lr.readline()
             if not l2.startswith('---'):
                 lr.push(l2)
                 continue
             l3 = lr.readline()
             lr.push(l3)
             if not l3.startswith("***************"):
                 lr.push(l2)
                 continue
             newfile = True
             context = True
             afile = parsefilename(x)
             bfile = parsefilename(l2)
 
         if newfile:
             if current_file:
                 current_file.close()
                 if rejmerge:
                     rejmerge(current_file)
                 rejects += len(current_file.rej)
             state = BFILE
             current_file = None
             hunknum = 0
     if current_hunk:
         if current_hunk.complete():
             ret = current_file.apply(current_hunk, reverse)
             if ret >= 0:
                 changed.setdefault(current_file.fname, (None, None))
                 if ret > 0:
                     err = 1
         else:
             fname = current_file and current_file.fname or None
             raise PatchError(_("malformed patch %s %s") % (fname,
                              current_hunk.desc))
     if current_file:
         current_file.close()
         if rejmerge:
             rejmerge(current_file)
         rejects += len(current_file.rej)
     if updatedir and git:
         updatedir(gitpatches)
     if rejects:
         return -1
     if hunknum == 0 and dopatch and not gitworkdone:
         raise NoHunks
     return err
 
 def diffopts(ui, opts={}, untrusted=False):
     def get(key, name=None):
         return (opts.get(key) or
                 ui.configbool('diff', name or key, None, untrusted=untrusted))
     return mdiff.diffopts(
         text=opts.get('text'),
         git=get('git'),
         nodates=get('nodates'),
         showfunc=get('show_function', 'showfunc'),
         ignorews=get('ignore_all_space', 'ignorews'),
         ignorewsamount=get('ignore_space_change', 'ignorewsamount'),
         ignoreblanklines=get('ignore_blank_lines', 'ignoreblanklines'))
 
 def updatedir(ui, repo, patches):
     '''Update dirstate after patch application according to metadata'''
     if not patches:
         return
     copies = []
     removes = {}
     cfiles = patches.keys()
     cwd = repo.getcwd()
     if cwd:
         cfiles = [util.pathto(repo.root, cwd, f) for f in patches.keys()]
     for f in patches:
         ctype, gp = patches[f]
         if ctype == 'RENAME':
             copies.append((gp.oldpath, gp.path, gp.copymod))
             removes[gp.oldpath] = 1
         elif ctype == 'COPY':
             copies.append((gp.oldpath, gp.path, gp.copymod))
         elif ctype == 'DELETE':
             removes[gp.path] = 1
     for src, dst, after in copies:
         if not after:
             copyfile(src, dst, repo.root)
         repo.copy(src, dst)
     removes = removes.keys()
     if removes:
         removes.sort()
         repo.remove(removes, True)
     for f in patches:
         ctype, gp = patches[f]
         if gp and gp.mode:
             x = gp.mode & 0100 != 0
             dst = os.path.join(repo.root, gp.path)
             # patch won't create empty files
             if ctype == 'ADD' and not os.path.exists(dst):
                 repo.wwrite(gp.path, '', x and 'x' or '')
             else:
                 util.set_exec(dst, x)
     cmdutil.addremove(repo, cfiles)
     files = patches.keys()
     files.extend([r for r in removes if r not in files])
     files.sort()
 
     return files
 
 def b85diff(fp, to, tn):
     '''print base85-encoded binary diff'''
     def gitindex(text):
         if not text:
             return '0' * 40
         l = len(text)
         s = sha.new('blob %d\0' % l)
         s.update(text)
         return s.hexdigest()
 
     def fmtline(line):
         l = len(line)
         if l <= 26:
             l = chr(ord('A') + l - 1)
         else:
             l = chr(l - 26 + ord('a') - 1)
         return '%c%s\n' % (l, base85.b85encode(line, True))
 
     def chunk(text, csize=52):
         l = len(text)
         i = 0
         while i < l:
             yield text[i:i+csize]
             i += csize
 
     tohash = gitindex(to)
     tnhash = gitindex(tn)
     if tohash == tnhash:
         return ""
 
     # TODO: deltas
     ret = ['index %s..%s\nGIT binary patch\nliteral %s\n' %
            (tohash, tnhash, len(tn))]
     for l in chunk(zlib.compress(tn)):
         ret.append(fmtline(l))
     ret.append('\n')
     return ''.join(ret)
 
 def diff(repo, node1=None, node2=None, files=None, match=util.always,
          fp=None, changes=None, opts=None):
     '''print diff of changes to files between two nodes, or node and
     working directory.
 
     if node1 is None, use first dirstate parent instead.
     if node2 is None, compare node1 with working directory.'''
 
     if opts is None:
         opts = mdiff.defaultopts
     if fp is None:
         fp = repo.ui
 
     if not node1:
         node1 = repo.dirstate.parents()[0]
 
     ccache = {}
     def getctx(r):
         if r not in ccache:
             ccache[r] = context.changectx(repo, r)
         return ccache[r]
 
     flcache = {}
     def getfilectx(f, ctx):
         flctx = ctx.filectx(f, filelog=flcache.get(f))
         if f not in flcache:
             flcache[f] = flctx._filelog
         return flctx
 
     # reading the data for node1 early allows it to play nicely
     # with repo.status and the revlog cache.
     ctx1 = context.changectx(repo, node1)
     # force manifest reading
     man1 = ctx1.manifest()
     date1 = util.datestr(ctx1.date())
 
     if not changes:
         changes = repo.status(node1, node2, files, match=match)[:5]
     modified, added, removed, deleted, unknown = changes
 
     if not modified and not added and not removed:
         return
 
     if node2:
         ctx2 = context.changectx(repo, node2)
         execf2 = ctx2.manifest().execf
     else:
         ctx2 = context.workingctx(repo)
         execf2 = util.execfunc(repo.root, None)
         if execf2 is None:
             execf2 = ctx2.parents()[0].manifest().copy().execf
 
     # returns False if there was no rename between ctx1 and ctx2
     # returns None if the file was created between ctx1 and ctx2
     # returns the (file, node) present in ctx1 that was renamed to f in ctx2
     def renamed(f):
         startrev = ctx1.rev()
         c = ctx2
         crev = c.rev()
         if crev is None:
             crev = repo.changelog.count()
         orig = f
         while crev > startrev:
             if f in c.files():
                 try:
                     src = getfilectx(f, c).renamed()
                 except revlog.LookupError:
                     return None
                 if src:
                     f = src[0]
             crev = c.parents()[0].rev()
             # try to reuse
             c = getctx(crev)
         if f not in man1:
             return None
         if f == orig:
             return False
         return f
 
     if repo.ui.quiet:
         r = None
     else:
         hexfunc = repo.ui.debugflag and hex or short
         r = [hexfunc(node) for node in [node1, node2] if node]
 
     if opts.git:
         copied = {}
         for f in added:
             src = renamed(f)
             if src:
                 copied[f] = src
         srcs = [x[1] for x in copied.items()]
 
     all = modified + added + removed
     all.sort()
     gone = {}
 
     for f in all:
         to = None
         tn = None
         dodiff = True
         header = []
         if f in man1:
             to = getfilectx(f, ctx1).data()
         if f not in removed:
             tn = getfilectx(f, ctx2).data()
         if opts.git:
             def gitmode(x):
                 return x and '100755' or '100644'
             def addmodehdr(header, omode, nmode):
                 if omode != nmode:
                     header.append('old mode %s\n' % omode)
                     header.append('new mode %s\n' % nmode)
 
             a, b = f, f
             if f in added:
                 mode = gitmode(execf2(f))
                 if f in copied:
                     a = copied[f]
                     omode = gitmode(man1.execf(a))
                     addmodehdr(header, omode, mode)
                     if a in removed and a not in gone:
                         op = 'rename'
                         gone[a] = 1
                     else:
                         op = 'copy'
                     header.append('%s from %s\n' % (op, a))
                     header.append('%s to %s\n' % (op, f))
                     to = getfilectx(a, ctx1).data()
                 else:
                     header.append('new file mode %s\n' % mode)
                 if util.binary(tn):
                     dodiff = 'binary'
             elif f in removed:
                 if f in srcs:
                     dodiff = False
                 else:
                     mode = gitmode(man1.execf(f))
                     header.append('deleted file mode %s\n' % mode)
             else:
                 omode = gitmode(man1.execf(f))
                 nmode = gitmode(execf2(f))
                 addmodehdr(header, omode, nmode)
                 if util.binary(to) or util.binary(tn):
                     dodiff = 'binary'
             r = None
             header.insert(0, 'diff --git a/%s b/%s\n' % (a, b))
         if dodiff:
             if dodiff == 'binary':
                 text = b85diff(fp, to, tn)
             else:
                 text = mdiff.unidiff(to, date1,
                                     # ctx2 date may be dynamic
                                     tn, util.datestr(ctx2.date()),
                                     f, r, opts=opts)
             if text or len(header) > 1:
                 fp.write(''.join(header))
             fp.write(text)
 
 def export(repo, revs, template='hg-%h.patch', fp=None, switch_parent=False,
            opts=None):
     '''export changesets as hg patches.'''
 
     total = len(revs)
     revwidth = max([len(str(rev)) for rev in revs])
 
     def single(rev, seqno, fp):
         ctx = repo.changectx(rev)
         node = ctx.node()
         parents = [p.node() for p in ctx.parents() if p]
         branch = ctx.branch()
         if switch_parent:
             parents.reverse()
         prev = (parents and parents[0]) or nullid
 
         if not fp:
             fp = cmdutil.make_file(repo, template, node, total=total,
                                    seqno=seqno, revwidth=revwidth)
         if fp != sys.stdout and hasattr(fp, 'name'):
             repo.ui.note("%s\n" % fp.name)
 
         fp.write("# HG changeset patch\n")
         fp.write("# User %s\n" % ctx.user())
         fp.write("# Date %d %d\n" % ctx.date())
         if branch and (branch != 'default'):
             fp.write("# Branch %s\n" % branch)
         fp.write("# Node ID %s\n" % hex(node))
         fp.write("# Parent  %s\n" % hex(prev))
         if len(parents) > 1:
             fp.write("# Parent  %s\n" % hex(parents[1]))
         fp.write(ctx.description().rstrip())
         fp.write("\n\n")
 
         diff(repo, prev, node, fp=fp, opts=opts)
         if fp not in (sys.stdout, repo.ui):
             fp.close()
 
     for seqno, rev in enumerate(revs):
         single(rev, seqno+1, fp)
 
 def diffstat(patchlines):
     if not util.find_exe('diffstat'):
         return
     fd, name = tempfile.mkstemp(prefix="hg-patchbomb-", suffix=".txt")
     try:
         p = popen2.Popen3('diffstat -p1 -w79 2>/dev/null > ' + name)
         try:
             for line in patchlines: print >> p.tochild, line
             p.tochild.close()
             if p.wait(): return
             fp = os.fdopen(fd, 'r')
             stat = []
             for line in fp: stat.append(line.lstrip())
             last = stat.pop()
             stat.insert(0, last)
             stat = ''.join(stat)
             if stat.startswith('0 files'): raise ValueError
             return stat
         except: raise
     finally:
         try: os.unlink(name)
         except: pass

mercurial/util.py

@@ -1,1614 +1,1618 b''
 """
 util.py - Mercurial utility functions and platform specfic implementations
 
  Copyright 2005 K. Thananchayan <[e-mail]>
  Copyright 2005-2007 Matt Mackall <[e-mail]>
  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.
 
 This contains helper routines that are independent of the SCM core and hide
 platform-specific details from the core.
 """
 
 from i18n import _
 import cStringIO, errno, getpass, popen2, re, shutil, sys, tempfile
 import os, threading, time, calendar, ConfigParser, locale, glob
 
 try:
     set = set
     frozenset = frozenset
 except NameError:
     from sets import Set as set, ImmutableSet as frozenset
 
 try:
     _encoding = os.environ.get("HGENCODING")
     if sys.platform == 'darwin' and not _encoding:
         # On darwin, getpreferredencoding ignores the locale environment and
         # always returns mac-roman. We override this if the environment is
         # not C (has been customized by the user).
         locale.setlocale(locale.LC_CTYPE, '')
         _encoding = locale.getlocale()[1]
     if not _encoding:
         _encoding = locale.getpreferredencoding() or 'ascii'
 except locale.Error:
     _encoding = 'ascii'
 _encodingmode = os.environ.get("HGENCODINGMODE", "strict")
 _fallbackencoding = 'ISO-8859-1'
 
 def tolocal(s):
     """
     Convert a string from internal UTF-8 to local encoding
 
     All internal strings should be UTF-8 but some repos before the
     implementation of locale support may contain latin1 or possibly
     other character sets. We attempt to decode everything strictly
     using UTF-8, then Latin-1, and failing that, we use UTF-8 and
     replace unknown characters.
     """
     for e in ('UTF-8', _fallbackencoding):
         try:
             u = s.decode(e) # attempt strict decoding
             return u.encode(_encoding, "replace")
         except LookupError, k:
             raise Abort(_("%s, please check your locale settings") % k)
         except UnicodeDecodeError:
             pass
     u = s.decode("utf-8", "replace") # last ditch
     return u.encode(_encoding, "replace")
 
 def fromlocal(s):
     """
     Convert a string from the local character encoding to UTF-8
 
     We attempt to decode strings using the encoding mode set by
     HGENCODINGMODE, which defaults to 'strict'. In this mode, unknown
     characters will cause an error message. Other modes include
     'replace', which replaces unknown characters with a special
     Unicode character, and 'ignore', which drops the character.
     """
     try:
         return s.decode(_encoding, _encodingmode).encode("utf-8")
     except UnicodeDecodeError, inst:
         sub = s[max(0, inst.start-10):inst.start+10]
         raise Abort("decoding near '%s': %s!" % (sub, inst))
     except LookupError, k:
         raise Abort(_("%s, please check your locale settings") % k)
 
 def locallen(s):
     """Find the length in characters of a local string"""
     return len(s.decode(_encoding, "replace"))
 
 def localsub(s, a, b=None):
     try:
         u = s.decode(_encoding, _encodingmode)
         if b is not None:
             u = u[a:b]
         else:
             u = u[:a]
         return u.encode(_encoding, _encodingmode)
     except UnicodeDecodeError, inst:
         sub = s[max(0, inst.start-10), inst.start+10]
         raise Abort(_("decoding near '%s': %s!") % (sub, inst))
 
 # used by parsedate
 defaultdateformats = (
     '%Y-%m-%d %H:%M:%S',
     '%Y-%m-%d %I:%M:%S%p',
     '%Y-%m-%d %H:%M',
     '%Y-%m-%d %I:%M%p',
     '%Y-%m-%d',
     '%m-%d',
     '%m/%d',
     '%m/%d/%y',
     '%m/%d/%Y',
     '%a %b %d %H:%M:%S %Y',
     '%a %b %d %I:%M:%S%p %Y',
     '%a, %d %b %Y %H:%M:%S',        #  GNU coreutils "/bin/date --rfc-2822"
     '%b %d %H:%M:%S %Y',
     '%b %d %I:%M:%S%p %Y',
     '%b %d %H:%M:%S',
     '%b %d %I:%M:%S%p',
     '%b %d %H:%M',
     '%b %d %I:%M%p',
     '%b %d %Y',
     '%b %d',
     '%H:%M:%S',
     '%I:%M:%SP',
     '%H:%M',
     '%I:%M%p',
 )
 
 extendeddateformats = defaultdateformats + (
     "%Y",
     "%Y-%m",
     "%b",
     "%b %Y",
     )
 
 class SignalInterrupt(Exception):
     """Exception raised on SIGTERM and SIGHUP."""
 
 # differences from SafeConfigParser:
 # - case-sensitive keys
 # - allows values that are not strings (this means that you may not
 #   be able to save the configuration to a file)
 class configparser(ConfigParser.SafeConfigParser):
     def optionxform(self, optionstr):
         return optionstr
 
     def set(self, section, option, value):
         return ConfigParser.ConfigParser.set(self, section, option, value)
 
     def _interpolate(self, section, option, rawval, vars):
         if not isinstance(rawval, basestring):
             return rawval
         return ConfigParser.SafeConfigParser._interpolate(self, section,
                                                           option, rawval, vars)
 
 def cachefunc(func):
     '''cache the result of function calls'''
     # XXX doesn't handle keywords args
     cache = {}
     if func.func_code.co_argcount == 1:
         # we gain a small amount of time because
         # we don't need to pack/unpack the list
         def f(arg):
             if arg not in cache:
                 cache[arg] = func(arg)
             return cache[arg]
     else:
         def f(*args):
             if args not in cache:
                 cache[args] = func(*args)
             return cache[args]
 
     return f
 
 def pipefilter(s, cmd):
     '''filter string S through command CMD, returning its output'''
     (pin, pout) = os.popen2(cmd, 'b')
     def writer():
         try:
             pin.write(s)
             pin.close()
         except IOError, inst:
             if inst.errno != errno.EPIPE:
                 raise
 
     # we should use select instead on UNIX, but this will work on most
     # systems, including Windows
     w = threading.Thread(target=writer)
     w.start()
     f = pout.read()
     pout.close()
     w.join()
     return f
 
 def tempfilter(s, cmd):
     '''filter string S through a pair of temporary files with CMD.
     CMD is used as a template to create the real command to be run,
     with the strings INFILE and OUTFILE replaced by the real names of
     the temporary files generated.'''
     inname, outname = None, None
     try:
         infd, inname = tempfile.mkstemp(prefix='hg-filter-in-')
         fp = os.fdopen(infd, 'wb')
         fp.write(s)
         fp.close()
         outfd, outname = tempfile.mkstemp(prefix='hg-filter-out-')
         os.close(outfd)
         cmd = cmd.replace('INFILE', inname)
         cmd = cmd.replace('OUTFILE', outname)
         code = os.system(cmd)
         if sys.platform == 'OpenVMS' and code & 1:
             code = 0
         if code: raise Abort(_("command '%s' failed: %s") %
                              (cmd, explain_exit(code)))
         return open(outname, 'rb').read()
     finally:
         try:
             if inname: os.unlink(inname)
         except: pass
         try:
             if outname: os.unlink(outname)
         except: pass
 
 filtertable = {
     'tempfile:': tempfilter,
     'pipe:': pipefilter,
     }
 
 def filter(s, cmd):
     "filter a string through a command that transforms its input to its output"
     for name, fn in filtertable.iteritems():
         if cmd.startswith(name):
             return fn(s, cmd[len(name):].lstrip())
     return pipefilter(s, cmd)
 
 def binary(s):
     """return true if a string is binary data using diff's heuristic"""
     if s and '\0' in s[:4096]:
         return True
     return False
 
 def unique(g):
     """return the uniq elements of iterable g"""
     seen = {}
     l = []
     for f in g:
         if f not in seen:
             seen[f] = 1
             l.append(f)
     return l
 
 class Abort(Exception):
     """Raised if a command needs to print an error and exit."""
 
 class UnexpectedOutput(Abort):
     """Raised to print an error with part of output and exit."""
 
 def always(fn): return True
 def never(fn): return False
 
 def expand_glob(pats):
     '''On Windows, expand the implicit globs in a list of patterns'''
     if os.name != 'nt':
         return list(pats)
     ret = []
     for p in pats:
         kind, name = patkind(p, None)
         if kind is None:
             globbed = glob.glob(name)
             if globbed:
                 ret.extend(globbed)
                 continue
             # if we couldn't expand the glob, just keep it around
         ret.append(p)
     return ret
 
 def patkind(name, dflt_pat='glob'):
     """Split a string into an optional pattern kind prefix and the
     actual pattern."""
     for prefix in 're', 'glob', 'path', 'relglob', 'relpath', 'relre':
         if name.startswith(prefix + ':'): return name.split(':', 1)
     return dflt_pat, name
 
 def globre(pat, head='^', tail='$'):
     "convert a glob pattern into a regexp"
     i, n = 0, len(pat)
     res = ''
     group = False
     def peek(): return i < n and pat[i]
     while i < n:
         c = pat[i]
         i = i+1
         if c == '*':
             if peek() == '*':
                 i += 1
                 res += '.*'
             else:
                 res += '[^/]*'
         elif c == '?':
             res += '.'
         elif c == '[':
             j = i
             if j < n and pat[j] in '!]':
                 j += 1
             while j < n and pat[j] != ']':
                 j += 1
             if j >= n:
                 res += '\\['
             else:
                 stuff = pat[i:j].replace('\\','\\\\')
                 i = j + 1
                 if stuff[0] == '!':
                     stuff = '^' + stuff[1:]
                 elif stuff[0] == '^':
                     stuff = '\\' + stuff
                 res = '%s[%s]' % (res, stuff)
         elif c == '{':
             group = True
             res += '(?:'
         elif c == '}' and group:
             res += ')'
             group = False
         elif c == ',' and group:
             res += '|'
         elif c == '\\':
             p = peek()
             if p:
                 i += 1
                 res += re.escape(p)
             else:
                 res += re.escape(c)
         else:
             res += re.escape(c)
     return head + res + tail
 
 _globchars = {'[': 1, '{': 1, '*': 1, '?': 1}
 
 def pathto(root, n1, n2):
     '''return the relative path from one place to another.
     root should use os.sep to separate directories
     n1 should use os.sep to separate directories
     n2 should use "/" to separate directories
     returns an os.sep-separated path.
 
     If n1 is a relative path, it's assumed it's
     relative to root.
     n2 should always be relative to root.
     '''
     if not n1: return localpath(n2)
     if os.path.isabs(n1):
         if os.path.splitdrive(root)[0] != os.path.splitdrive(n1)[0]:
             return os.path.join(root, localpath(n2))
         n2 = '/'.join((pconvert(root), n2))
     a, b = n1.split(os.sep), n2.split('/')
     a.reverse()
     b.reverse()
     while a and b and a[-1] == b[-1]:
         a.pop()
         b.pop()
     b.reverse()
     return os.sep.join((['..'] * len(a)) + b)
 
 def canonpath(root, cwd, myname):
     """return the canonical path of myname, given cwd and root"""
     if root == os.sep:
         rootsep = os.sep
     elif root.endswith(os.sep):
         rootsep = root
     else:
         rootsep = root + os.sep
     name = myname
     if not os.path.isabs(name):
         name = os.path.join(root, cwd, name)
     name = os.path.normpath(name)
     if name != rootsep and name.startswith(rootsep):
         name = name[len(rootsep):]
         audit_path(name)
         return pconvert(name)
     elif name == root:
         return ''
     else:
         # Determine whether `name' is in the hierarchy at or beneath `root',
         # by iterating name=dirname(name) until that causes no change (can't
         # check name == '/', because that doesn't work on windows).  For each
         # `name', compare dev/inode numbers.  If they match, the list `rel'
         # holds the reversed list of components making up the relative file
         # name we want.
         root_st = os.stat(root)
         rel = []
         while True:
             try:
                 name_st = os.stat(name)
             except OSError:
                 break
             if samestat(name_st, root_st):
                 if not rel:
                     # name was actually the same as root (maybe a symlink)
                     return ''
                 rel.reverse()
                 name = os.path.join(*rel)
                 audit_path(name)
                 return pconvert(name)
             dirname, basename = os.path.split(name)
             rel.append(basename)
             if dirname == name:
                 break
             name = dirname
 
         raise Abort('%s not under root' % myname)
 
 def matcher(canonroot, cwd='', names=[], inc=[], exc=[], src=None):
     return _matcher(canonroot, cwd, names, inc, exc, 'glob', src)
 
 def cmdmatcher(canonroot, cwd='', names=[], inc=[], exc=[], src=None,
                globbed=False, default=None):
     default = default or 'relpath'
     if default == 'relpath' and not globbed:
         names = expand_glob(names)
     return _matcher(canonroot, cwd, names, inc, exc, default, src)
 
 def _matcher(canonroot, cwd, names, inc, exc, dflt_pat, src):
     """build a function to match a set of file patterns
 
     arguments:
     canonroot - the canonical root of the tree you're matching against
     cwd - the current working directory, if relevant
     names - patterns to find
     inc - patterns to include
     exc - patterns to exclude
     dflt_pat - if a pattern in names has no explicit type, assume this one
     src - where these patterns came from (e.g. .hgignore)
 
     a pattern is one of:
     'glob:<glob>' - a glob relative to cwd
     're:<regexp>' - a regular expression
     'path:<path>' - a path relative to canonroot
     'relglob:<glob>' - an unrooted glob (*.c matches C files in all dirs)
     'relpath:<path>' - a path relative to cwd
     'relre:<regexp>' - a regexp that doesn't have to match the start of a name
     '<something>' - one of the cases above, selected by the dflt_pat argument
 
     returns:
     a 3-tuple containing
     - list of roots (places where one should start a recursive walk of the fs);
       this often matches the explicit non-pattern names passed in, but also
       includes the initial part of glob: patterns that has no glob characters
     - a bool match(filename) function
     - a bool indicating if any patterns were passed in
     """
 
     # a common case: no patterns at all
     if not names and not inc and not exc:
         return [], always, False
 
     def contains_glob(name):
         for c in name:
             if c in _globchars: return True
         return False
 
     def regex(kind, name, tail):
         '''convert a pattern into a regular expression'''
         if not name:
             return ''
         if kind == 're':
             return name
         elif kind == 'path':
             return '^' + re.escape(name) + '(?:/|$)'
         elif kind == 'relglob':
             return globre(name, '(?:|.*/)', tail)
         elif kind == 'relpath':
             return re.escape(name) + '(?:/|$)'
         elif kind == 'relre':
             if name.startswith('^'):
                 return name
             return '.*' + name
         return globre(name, '', tail)
 
     def matchfn(pats, tail):
         """build a matching function from a set of patterns"""
         if not pats:
             return
         try:
             pat = '(?:%s)' % '|'.join([regex(k, p, tail) for (k, p) in pats])
             return re.compile(pat).match
         except re.error:
             for k, p in pats:
                 try:
                     re.compile('(?:%s)' % regex(k, p, tail))
                 except re.error:
                     if src:
                         raise Abort("%s: invalid pattern (%s): %s" %
                                     (src, k, p))
                     else:
                         raise Abort("invalid pattern (%s): %s" % (k, p))
             raise Abort("invalid pattern")
 
     def globprefix(pat):
         '''return the non-glob prefix of a path, e.g. foo/* -> foo'''
         root = []
         for p in pat.split('/'):
             if contains_glob(p): break
             root.append(p)
         return '/'.join(root) or '.'
 
     def normalizepats(names, default):
         pats = []
         roots = []
         anypats = False
         for kind, name in [patkind(p, default) for p in names]:
             if kind in ('glob', 'relpath'):
                 name = canonpath(canonroot, cwd, name)
             elif kind in ('relglob', 'path'):
                 name = normpath(name)
 
             pats.append((kind, name))
 
             if kind in ('glob', 're', 'relglob', 'relre'):
                 anypats = True
 
             if kind == 'glob':
                 root = globprefix(name)
                 roots.append(root)
             elif kind in ('relpath', 'path'):
                 roots.append(name or '.')
             elif kind == 'relglob':
                 roots.append('.')
         return roots, pats, anypats
 
     roots, pats, anypats = normalizepats(names, dflt_pat)
 
     patmatch = matchfn(pats, '$') or always
     incmatch = always
     if inc:
         dummy, inckinds, dummy = normalizepats(inc, 'glob')
         incmatch = matchfn(inckinds, '(?:/|$)')
     excmatch = lambda fn: False
     if exc:
         dummy, exckinds, dummy = normalizepats(exc, 'glob')
         excmatch = matchfn(exckinds, '(?:/|$)')
 
     if not names and inc and not exc:
         # common case: hgignore patterns
         match = incmatch
     else:
         match = lambda fn: incmatch(fn) and not excmatch(fn) and patmatch(fn)
 
     return (roots, match, (inc or exc or anypats) and True)
 
 _hgexecutable = 'hg'
 
 def set_hgexecutable(path):
     """remember location of the 'hg' executable if easily possible
 
     path might be None or empty if hg was loaded as a module,
     fall back to 'hg' in this case.
     """
     global _hgexecutable
     if path:
         _hgexecutable = os.path.abspath(path)
 
 def system(cmd, environ={}, cwd=None, onerr=None, errprefix=None):
     '''enhanced shell command execution.
     run with environment maybe modified, maybe in different dir.
 
     if command fails and onerr is None, return status.  if ui object,
     print error message and return status, else raise onerr object as
     exception.'''
     def py2shell(val):
         'convert python object into string that is useful to shell'
         if val in (None, False):
             return '0'
         if val == True:
             return '1'
         return str(val)
     oldenv = {}
     for k in environ:
         oldenv[k] = os.environ.get(k)
     if cwd is not None:
         oldcwd = os.getcwd()
     origcmd = cmd
     if os.name == 'nt':
         cmd = '"%s"' % cmd
     try:
         for k, v in environ.iteritems():
             os.environ[k] = py2shell(v)
         if 'HG' not in os.environ:
             os.environ['HG'] = _hgexecutable
         if cwd is not None and oldcwd != cwd:
             os.chdir(cwd)
         rc = os.system(cmd)
         if sys.platform == 'OpenVMS' and rc & 1:
             rc = 0
         if rc and onerr:
             errmsg = '%s %s' % (os.path.basename(origcmd.split(None, 1)[0]),
                                 explain_exit(rc)[0])
             if errprefix:
                 errmsg = '%s: %s' % (errprefix, errmsg)
             try:
                 onerr.warn(errmsg + '\n')
             except AttributeError:
                 raise onerr(errmsg)
         return rc
     finally:
         for k, v in oldenv.iteritems():
             if v is None:
                 del os.environ[k]
             else:
                 os.environ[k] = v
         if cwd is not None and oldcwd != cwd:
             os.chdir(oldcwd)
 
 # os.path.lexists is not available on python2.3
 def lexists(filename):
     "test whether a file with this name exists. does not follow symlinks"
     try:
         os.lstat(filename)
     except:
         return False
     return True
 
 def rename(src, dst):
     """forcibly rename a file"""
     try:
         os.rename(src, dst)
-    except OSError, err:
+    except OSError, err: # FIXME: check err (EEXIST ?)
         # on windows, rename to existing file is not allowed, so we
         # must delete destination first. but if file is open, unlink
         # schedules it for delete but does not delete it. rename
         # happens immediately even for open files, so we create
         # temporary file, delete it, rename destination to that name,
         # then delete that. then rename is safe to do.
         fd, temp = tempfile.mkstemp(dir=os.path.dirname(dst) or '.')
         os.close(fd)
         os.unlink(temp)
         os.rename(dst, temp)
         os.unlink(temp)
         os.rename(src, dst)
 
 def unlink(f):
     """unlink and remove the directory if it is empty"""
     os.unlink(f)
     # try removing directories that might now be empty
     try:
         os.removedirs(os.path.dirname(f))
     except OSError:
         pass
 
 def copyfile(src, dest):
     "copy a file, preserving mode"
     if os.path.islink(src):
         try:
             os.unlink(dest)
         except:
             pass
         os.symlink(os.readlink(src), dest)
     else:
         try:
             shutil.copyfile(src, dest)
             shutil.copymode(src, dest)
         except shutil.Error, inst:
             raise Abort(str(inst))
 
 def copyfiles(src, dst, hardlink=None):
     """Copy a directory tree using hardlinks if possible"""
 
     if hardlink is None:
         hardlink = (os.stat(src).st_dev ==
                     os.stat(os.path.dirname(dst)).st_dev)
 
     if os.path.isdir(src):
         os.mkdir(dst)
         for name in os.listdir(src):
             srcname = os.path.join(src, name)
             dstname = os.path.join(dst, name)
             copyfiles(srcname, dstname, hardlink)
     else:
         if hardlink:
             try:
                 os_link(src, dst)
             except (IOError, OSError):
                 hardlink = False
                 shutil.copy(src, dst)
         else:
             shutil.copy(src, dst)
 
 def audit_path(path):
     """Abort if path contains dangerous components"""
     parts = os.path.normcase(path).split(os.sep)
     if (os.path.splitdrive(path)[0] or parts[0] in ('.hg', '')
         or os.pardir in parts):
         raise Abort(_("path contains illegal component: %s") % path)
 
 def _makelock_file(info, pathname):
     ld = os.open(pathname, os.O_CREAT | os.O_WRONLY | os.O_EXCL)
     os.write(ld, info)
     os.close(ld)
 
 def _readlock_file(pathname):
     return posixfile(pathname).read()
 
 def nlinks(pathname):
     """Return number of hardlinks for the given file."""
     return os.lstat(pathname).st_nlink
 
 if hasattr(os, 'link'):
     os_link = os.link
 else:
     def os_link(src, dst):
         raise OSError(0, _("Hardlinks not supported"))
 
 def fstat(fp):
     '''stat file object that may not have fileno method.'''
     try:
         return os.fstat(fp.fileno())
     except AttributeError:
         return os.stat(fp.name)
 
 posixfile = file
 
 def is_win_9x():
     '''return true if run on windows 95, 98 or me.'''
     try:
         return sys.getwindowsversion()[3] == 1
     except AttributeError:
         return os.name == 'nt' and 'command' in os.environ.get('comspec', '')
 
 getuser_fallback = None
 
 def getuser():
     '''return name of current user'''
     try:
         return getpass.getuser()
     except ImportError:
         # import of pwd will fail on windows - try fallback
         if getuser_fallback:
             return getuser_fallback()
     # raised if win32api not available
     raise Abort(_('user name not available - set USERNAME '
                   'environment variable'))
 
 def username(uid=None):
     """Return the name of the user with the given uid.
 
     If uid is None, return the name of the current user."""
     try:
         import pwd
         if uid is None:
             uid = os.getuid()
         try:
             return pwd.getpwuid(uid)[0]
         except KeyError:
             return str(uid)
     except ImportError:
         return None
 
 def groupname(gid=None):
     """Return the name of the group with the given gid.
 
     If gid is None, return the name of the current group."""
     try:
         import grp
         if gid is None:
             gid = os.getgid()
         try:
             return grp.getgrgid(gid)[0]
         except KeyError:
             return str(gid)
     except ImportError:
         return None
 
 # File system features
 
 def checkfolding(path):
     """
     Check whether the given path is on a case-sensitive filesystem
 
     Requires a path (like /foo/.hg) ending with a foldable final
     directory component.
     """
     s1 = os.stat(path)
     d, b = os.path.split(path)
     p2 = os.path.join(d, b.upper())
     if path == p2:
         p2 = os.path.join(d, b.lower())
     try:
         s2 = os.stat(p2)
         if s2 == s1:
             return False
         return True
     except:
         return True
 
 def checkexec(path):
     """
     Check whether the given path is on a filesystem with UNIX-like exec flags
 
     Requires a directory (like /foo/.hg)
     """
     fh, fn = tempfile.mkstemp("", "", path)
     os.close(fh)
     m = os.stat(fn).st_mode
     os.chmod(fn, m ^ 0111)
     r = (os.stat(fn).st_mode != m)
     os.unlink(fn)
     return r
 
 def execfunc(path, fallback):
     '''return an is_exec() function with default to fallback'''
     if checkexec(path):
         return lambda x: is_exec(os.path.join(path, x))
     return fallback
 
 def checklink(path):
     """check whether the given path is on a symlink-capable filesystem"""
     # mktemp is not racy because symlink creation will fail if the
     # file already exists
     name = tempfile.mktemp(dir=path)
     try:
         os.symlink(".", name)
         os.unlink(name)
         return True
     except (OSError, AttributeError):
         return False
 
 def linkfunc(path, fallback):
     '''return an is_link() function with default to fallback'''
     if checklink(path):
         return lambda x: os.path.islink(os.path.join(path, x))
     return fallback
 
 _umask = os.umask(0)
 os.umask(_umask)
 
 def needbinarypatch():
     """return True if patches should be applied in binary mode by default."""
     return os.name == 'nt'
 
 # Platform specific variants
 if os.name == 'nt':
     import msvcrt
     nulldev = 'NUL:'
 
     class winstdout:
         '''stdout on windows misbehaves if sent through a pipe'''
 
         def __init__(self, fp):
             self.fp = fp
 
         def __getattr__(self, key):
             return getattr(self.fp, key)
 
         def close(self):
             try:
                 self.fp.close()
             except: pass
 
         def write(self, s):
             try:
                 return self.fp.write(s)
             except IOError, inst:
                 if inst.errno != 0: raise
                 self.close()
                 raise IOError(errno.EPIPE, 'Broken pipe')
 
         def flush(self):
             try:
                 return self.fp.flush()
             except IOError, inst:
                 if inst.errno != errno.EINVAL: raise
                 self.close()
                 raise IOError(errno.EPIPE, 'Broken pipe')
 
     sys.stdout = winstdout(sys.stdout)
 
     def system_rcpath():
         try:
             return system_rcpath_win32()
         except:
             return [r'c:\mercurial\mercurial.ini']
 
     def user_rcpath():
         '''return os-specific hgrc search path to the user dir'''
         try:
             userrc = user_rcpath_win32()
         except:
             userrc = os.path.join(os.path.expanduser('~'), 'mercurial.ini')
         path = [userrc]
         userprofile = os.environ.get('USERPROFILE')
         if userprofile:
             path.append(os.path.join(userprofile, 'mercurial.ini'))
         return path
 
     def parse_patch_output(output_line):
         """parses the output produced by patch and returns the file name"""
         pf = output_line[14:]
         if pf[0] == '`':
             pf = pf[1:-1] # Remove the quotes
         return pf
 
     def testpid(pid):
         '''return False if pid dead, True if running or not known'''
         return True
 
     def set_exec(f, mode):
         pass
 
     def set_link(f, mode):
         pass
 
     def set_binary(fd):
         msvcrt.setmode(fd.fileno(), os.O_BINARY)
 
     def pconvert(path):
         return path.replace("\\", "/")
 
     def localpath(path):
         return path.replace('/', '\\')
 
     def normpath(path):
         return pconvert(os.path.normpath(path))
 
     makelock = _makelock_file
     readlock = _readlock_file
 
     def samestat(s1, s2):
         return False
 
     # A sequence of backslashes is special iff it precedes a double quote:
     # - if there's an even number of backslashes, the double quote is not
     #   quoted (i.e. it ends the quoted region)
     # - if there's an odd number of backslashes, the double quote is quoted
     # - in both cases, every pair of backslashes is unquoted into a single
     #   backslash
     # (See http://msdn2.microsoft.com/en-us/library/a1y7w461.aspx )
     # So, to quote a string, we must surround it in double quotes, double
     # the number of backslashes that preceed double quotes and add another
     # backslash before every double quote (being careful with the double
     # quote we've appended to the end)
     _quotere = None
     def shellquote(s):
         global _quotere
         if _quotere is None:
             _quotere = re.compile(r'(\\*)("|\\$)')
         return '"%s"' % _quotere.sub(r'\1\1\\\2', s)
 
     def explain_exit(code):
         return _("exited with status %d") % code, code
 
     # if you change this stub into a real check, please try to implement the
     # username and groupname functions above, too.
     def isowner(fp, st=None):
         return True
 
     def find_in_path(name, path, default=None):
         '''find name in search path. path can be string (will be split
         with os.pathsep), or iterable thing that returns strings.  if name
         found, return path to name. else return default. name is looked up
         using cmd.exe rules, using PATHEXT.'''
         if isinstance(path, str):
             path = path.split(os.pathsep)
 
         pathext = os.environ.get('PATHEXT', '.COM;.EXE;.BAT;.CMD')
         pathext = pathext.lower().split(os.pathsep)
         isexec = os.path.splitext(name)[1].lower() in pathext
 
         for p in path:
             p_name = os.path.join(p, name)
 
             if isexec and os.path.exists(p_name):
                 return p_name
 
             for ext in pathext:
                 p_name_ext = p_name + ext
                 if os.path.exists(p_name_ext):
                     return p_name_ext
         return default
 
     def set_signal_handler():
         try:
             set_signal_handler_win32()
         except NameError:
             pass
 
     try:
         # override functions with win32 versions if possible
         from util_win32 import *
         if not is_win_9x():
             posixfile = posixfile_nt
     except ImportError:
         pass
 
 else:
     nulldev = '/dev/null'
 
     def rcfiles(path):
         rcs = [os.path.join(path, 'hgrc')]
         rcdir = os.path.join(path, 'hgrc.d')
         try:
             rcs.extend([os.path.join(rcdir, f) for f in os.listdir(rcdir)
                         if f.endswith(".rc")])
         except OSError:
             pass
         return rcs
 
     def system_rcpath():
         path = []
         # old mod_python does not set sys.argv
         if len(getattr(sys, 'argv', [])) > 0:
             path.extend(rcfiles(os.path.dirname(sys.argv[0]) +
                                   '/../etc/mercurial'))
         path.extend(rcfiles('/etc/mercurial'))
         return path
 
     def user_rcpath():
         return [os.path.expanduser('~/.hgrc')]
 
     def parse_patch_output(output_line):
         """parses the output produced by patch and returns the file name"""
         pf = output_line[14:]
         if os.sys.platform == 'OpenVMS':
             if pf[0] == '`':
                 pf = pf[1:-1] # Remove the quotes
         else:
            if pf.startswith("'") and pf.endswith("'") and " " in pf:
                 pf = pf[1:-1] # Remove the quotes
         return pf
 
     def is_exec(f):
         """check whether a file is executable"""
         return (os.lstat(f).st_mode & 0100 != 0)
 
     def set_exec(f, mode):
         s = os.lstat(f).st_mode
         if (s & 0100 != 0) == mode:
             return
         if mode:
             # Turn on +x for every +r bit when making a file executable
             # and obey umask.
             os.chmod(f, s | (s & 0444) >> 2 & ~_umask)
         else:
             os.chmod(f, s & 0666)
 
     def set_link(f, mode):
         """make a file a symbolic link/regular file
 
         if a file is changed to a link, its contents become the link data
         if a link is changed to a file, its link data become its contents
         """
 
         m = os.path.islink(f)
         if m == bool(mode):
             return
 
         if mode: # switch file to link
             data = file(f).read()
             os.unlink(f)
             os.symlink(data, f)
         else:
             data = os.readlink(f)
             os.unlink(f)
             file(f, "w").write(data)
 
     def set_binary(fd):
         pass
 
     def pconvert(path):
         return path
 
     def localpath(path):
         return path
 
     normpath = os.path.normpath
     samestat = os.path.samestat
 
     def makelock(info, pathname):
         try:
             os.symlink(info, pathname)
         except OSError, why:
             if why.errno == errno.EEXIST:
                 raise
             else:
                 _makelock_file(info, pathname)
 
     def readlock(pathname):
         try:
             return os.readlink(pathname)
         except OSError, why:
             if why.errno in (errno.EINVAL, errno.ENOSYS):
                 return _readlock_file(pathname)
             else:
                 raise
 
     def shellquote(s):
         if os.sys.platform == 'OpenVMS':
             return '"%s"' % s
         else:
             return "'%s'" % s.replace("'", "'\\''")
 
     def testpid(pid):
         '''return False if pid dead, True if running or not sure'''
         if os.sys.platform == 'OpenVMS':
             return True
         try:
             os.kill(pid, 0)
             return True
         except OSError, inst:
             return inst.errno != errno.ESRCH
 
     def explain_exit(code):
         """return a 2-tuple (desc, code) describing a process's status"""
         if os.WIFEXITED(code):
             val = os.WEXITSTATUS(code)
             return _("exited with status %d") % val, val
         elif os.WIFSIGNALED(code):
             val = os.WTERMSIG(code)
             return _("killed by signal %d") % val, val
         elif os.WIFSTOPPED(code):
             val = os.WSTOPSIG(code)
             return _("stopped by signal %d") % val, val
         raise ValueError(_("invalid exit code"))
 
     def isowner(fp, st=None):
         """Return True if the file object f belongs to the current user.
 
         The return value of a util.fstat(f) may be passed as the st argument.
         """
         if st is None:
             st = fstat(fp)
         return st.st_uid == os.getuid()
 
     def find_in_path(name, path, default=None):
         '''find name in search path. path can be string (will be split
         with os.pathsep), or iterable thing that returns strings.  if name
         found, return path to name. else return default.'''
         if isinstance(path, str):
             path = path.split(os.pathsep)
         for p in path:
             p_name = os.path.join(p, name)
             if os.path.exists(p_name):
                 return p_name
         return default
 
     def set_signal_handler():
         pass
 
 def find_exe(name, default=None):
     '''find path of an executable.
     if name contains a path component, return it as is.  otherwise,
     use normal executable search path.'''
 
     if os.sep in name or sys.platform == 'OpenVMS':
         # don't check the executable bit.  if the file isn't
         # executable, whoever tries to actually run it will give a
         # much more useful error message.
         return name
     return find_in_path(name, os.environ.get('PATH', ''), default=default)
 
 def _buildencodefun():
     e = '_'
     win_reserved = [ord(x) for x in '\\:*?"<>|']
     cmap = dict([ (chr(x), chr(x)) for x in xrange(127) ])
     for x in (range(32) + range(126, 256) + win_reserved):
         cmap[chr(x)] = "~%02x" % x
     for x in range(ord("A"), ord("Z")+1) + [ord(e)]:
         cmap[chr(x)] = e + chr(x).lower()
     dmap = {}
     for k, v in cmap.iteritems():
         dmap[v] = k
     def decode(s):
         i = 0
         while i < len(s):
             for l in xrange(1, 4):
                 try:
                     yield dmap[s[i:i+l]]
                     i += l
                     break
                 except KeyError:
                     pass
             else:
                 raise KeyError
     return (lambda s: "".join([cmap[c] for c in s]),
             lambda s: "".join(list(decode(s))))
 
 encodefilename, decodefilename = _buildencodefun()
 
 def encodedopener(openerfn, fn):
     def o(path, *args, **kw):
         return openerfn(fn(path), *args, **kw)
     return o
 
 def mktempcopy(name, emptyok=False):
     """Create a temporary file with the same contents from name
 
     The permission bits are copied from the original file.
 
     If the temporary file is going to be truncated immediately, you
     can use emptyok=True as an optimization.
 
     Returns the name of the temporary file.
     """
     d, fn = os.path.split(name)
     fd, temp = tempfile.mkstemp(prefix='.%s-' % fn, dir=d)
     os.close(fd)
     # Temporary files are created with mode 0600, which is usually not
     # what we want.  If the original file already exists, just copy
     # its mode.  Otherwise, manually obey umask.
     try:
         st_mode = os.lstat(name).st_mode
     except OSError, inst:
         if inst.errno != errno.ENOENT:
             raise
         st_mode = 0666 & ~_umask
     os.chmod(temp, st_mode)
     if emptyok:
         return temp
     try:
         try:
             ifp = posixfile(name, "rb")
         except IOError, inst:
             if inst.errno == errno.ENOENT:
                 return temp
             if not getattr(inst, 'filename', None):
                 inst.filename = name
             raise
         ofp = posixfile(temp, "wb")
         for chunk in filechunkiter(ifp):
             ofp.write(chunk)
         ifp.close()
         ofp.close()
     except:
         try: os.unlink(temp)
         except: pass
         raise
     return temp
 
 class atomictempfile(posixfile):
     """file-like object that atomically updates a file
 
     All writes will be redirected to a temporary copy of the original
     file.  When rename is called, the copy is renamed to the original
     name, making the changes visible.
     """
     def __init__(self, name, mode):
         self.__name = name
         self.temp = mktempcopy(name, emptyok=('w' in mode))
         posixfile.__init__(self, self.temp, mode)
 
     def rename(self):
         if not self.closed:
             posixfile.close(self)
             rename(self.temp, localpath(self.__name))
 
     def __del__(self):
         if not self.closed:
             try:
                 os.unlink(self.temp)
             except: pass
             posixfile.close(self)
 
 class opener(object):
     """Open files relative to a base directory
 
     This class is used to hide the details of COW semantics and
     remote file access from higher level code.
     """
     def __init__(self, base, audit=True):
         self.base = base
         self.audit = audit
 
     def __getattr__(self, name):
         if name == '_can_symlink':
             self._can_symlink = checklink(self.base)
             return self._can_symlink
         raise AttributeError(name)
 
     def __call__(self, path, mode="r", text=False, atomictemp=False):
         if self.audit:
             audit_path(path)
         f = os.path.join(self.base, path)
 
         if not text and "b" not in mode:
             mode += "b" # for that other OS
 
         if mode[0] != "r":
             try:
                 nlink = nlinks(f)
             except OSError:
                 nlink = 0
                 d = os.path.dirname(f)
                 if not os.path.isdir(d):
                     os.makedirs(d)
             if atomictemp:
                 return atomictempfile(f, mode)
             if nlink > 1:
                 rename(mktempcopy(f), f)
         return posixfile(f, mode)
 
     def symlink(self, src, dst):
         if self.audit:
             audit_path(dst)
         linkname = os.path.join(self.base, dst)
         try:
             os.unlink(linkname)
         except OSError:
             pass
 
         dirname = os.path.dirname(linkname)
         if not os.path.exists(dirname):
             os.makedirs(dirname)
 
         if self._can_symlink:
-            os.symlink(src, linkname)
+            try:
+                os.symlink(src, linkname)
+            except OSError, err:
+                raise OSError(err.errno, _('could not symlink to %r: %s') %
+                              (src, err.strerror), linkname)
         else:
             f = self(self, dst, "w")
             f.write(src)
             f.close()
 
 class chunkbuffer(object):
     """Allow arbitrary sized chunks of data to be efficiently read from an
     iterator over chunks of arbitrary size."""
 
     def __init__(self, in_iter, targetsize = 2**16):
         """in_iter is the iterator that's iterating over the input chunks.
         targetsize is how big a buffer to try to maintain."""
         self.in_iter = iter(in_iter)
         self.buf = ''
         self.targetsize = int(targetsize)
         if self.targetsize <= 0:
             raise ValueError(_("targetsize must be greater than 0, was %d") %
                              targetsize)
         self.iterempty = False
 
     def fillbuf(self):
         """Ignore target size; read every chunk from iterator until empty."""
         if not self.iterempty:
             collector = cStringIO.StringIO()
             collector.write(self.buf)
             for ch in self.in_iter:
                 collector.write(ch)
             self.buf = collector.getvalue()
             self.iterempty = True
 
     def read(self, l):
         """Read L bytes of data from the iterator of chunks of data.
         Returns less than L bytes if the iterator runs dry."""
         if l > len(self.buf) and not self.iterempty:
             # Clamp to a multiple of self.targetsize
             targetsize = self.targetsize * ((l // self.targetsize) + 1)
             collector = cStringIO.StringIO()
             collector.write(self.buf)
             collected = len(self.buf)
             for chunk in self.in_iter:
                 collector.write(chunk)
                 collected += len(chunk)
                 if collected >= targetsize:
                     break
             if collected < targetsize:
                 self.iterempty = True
             self.buf = collector.getvalue()
         s, self.buf = self.buf[:l], buffer(self.buf, l)
         return s
 
 def filechunkiter(f, size=65536, limit=None):
     """Create a generator that produces the data in the file size
     (default 65536) bytes at a time, up to optional limit (default is
     to read all data).  Chunks may be less than size bytes if the
     chunk is the last chunk in the file, or the file is a socket or
     some other type of file that sometimes reads less data than is
     requested."""
     assert size >= 0
     assert limit is None or limit >= 0
     while True:
         if limit is None: nbytes = size
         else: nbytes = min(limit, size)
         s = nbytes and f.read(nbytes)
         if not s: break
         if limit: limit -= len(s)
         yield s
 
 def makedate():
     lt = time.localtime()
     if lt[8] == 1 and time.daylight:
         tz = time.altzone
     else:
         tz = time.timezone
     return time.mktime(lt), tz
 
 def datestr(date=None, format='%a %b %d %H:%M:%S %Y', timezone=True):
     """represent a (unixtime, offset) tuple as a localized time.
     unixtime is seconds since the epoch, and offset is the time zone's
     number of seconds away from UTC. if timezone is false, do not
     append time zone to string."""
     t, tz = date or makedate()
     s = time.strftime(format, time.gmtime(float(t) - tz))
     if timezone:
         s += " %+03d%02d" % (-tz / 3600, ((-tz % 3600) / 60))
     return s
 
 def strdate(string, format, defaults):
     """parse a localized time string and return a (unixtime, offset) tuple.
     if the string cannot be parsed, ValueError is raised."""
     def timezone(string):
         tz = string.split()[-1]
         if tz[0] in "+-" and len(tz) == 5 and tz[1:].isdigit():
             tz = int(tz)
             offset = - 3600 * (tz / 100) - 60 * (tz % 100)
             return offset
         if tz == "GMT" or tz == "UTC":
             return 0
         return None
 
     # NOTE: unixtime = localunixtime + offset
     offset, date = timezone(string), string
     if offset != None:
         date = " ".join(string.split()[:-1])
 
     # add missing elements from defaults
     for part in defaults:
         found = [True for p in part if ("%"+p) in format]
         if not found:
             date += "@" + defaults[part]
             format += "@%" + part[0]
 
     timetuple = time.strptime(date, format)
     localunixtime = int(calendar.timegm(timetuple))
     if offset is None:
         # local timezone
         unixtime = int(time.mktime(timetuple))
         offset = unixtime - localunixtime
     else:
         unixtime = localunixtime + offset
     return unixtime, offset
 
 def parsedate(string, formats=None, defaults=None):
     """parse a localized time string and return a (unixtime, offset) tuple.
     The date may be a "unixtime offset" string or in one of the specified
     formats."""
     if not string:
         return 0, 0
     if not formats:
         formats = defaultdateformats
     string = string.strip()
     try:
         when, offset = map(int, string.split(' '))
     except ValueError:
         # fill out defaults
         if not defaults:
             defaults = {}
         now = makedate()
         for part in "d mb yY HI M S".split():
             if part not in defaults:
                 if part[0] in "HMS":
                     defaults[part] = "00"
                 elif part[0] in "dm":
                     defaults[part] = "1"
                 else:
                     defaults[part] = datestr(now, "%" + part[0], False)
 
         for format in formats:
             try:
                 when, offset = strdate(string, format, defaults)
             except ValueError:
                 pass
             else:
                 break
         else:
             raise Abort(_('invalid date: %r ') % string)
     # validate explicit (probably user-specified) date and
     # time zone offset. values must fit in signed 32 bits for
     # current 32-bit linux runtimes. timezones go from UTC-12
     # to UTC+14
     if abs(when) > 0x7fffffff:
         raise Abort(_('date exceeds 32 bits: %d') % when)
     if offset < -50400 or offset > 43200:
         raise Abort(_('impossible time zone offset: %d') % offset)
     return when, offset
 
 def matchdate(date):
     """Return a function that matches a given date match specifier
 
     Formats include:
 
     '{date}' match a given date to the accuracy provided
 
     '<{date}' on or before a given date
 
     '>{date}' on or after a given date
 
     """
 
     def lower(date):
         return parsedate(date, extendeddateformats)[0]
 
     def upper(date):
         d = dict(mb="12", HI="23", M="59", S="59")
         for days in "31 30 29".split():
             try:
                 d["d"] = days
                 return parsedate(date, extendeddateformats, d)[0]
             except:
                 pass
         d["d"] = "28"
         return parsedate(date, extendeddateformats, d)[0]
 
     if date[0] == "<":
         when = upper(date[1:])
         return lambda x: x <= when
     elif date[0] == ">":
         when = lower(date[1:])
         return lambda x: x >= when
     elif date[0] == "-":
         try:
             days = int(date[1:])
         except ValueError:
             raise Abort(_("invalid day spec: %s") % date[1:])
         when = makedate()[0] - days * 3600 * 24
         return lambda x: x >= when
     elif " to " in date:
         a, b = date.split(" to ")
         start, stop = lower(a), upper(b)
         return lambda x: x >= start and x <= stop
     else:
         start, stop = lower(date), upper(date)
         return lambda x: x >= start and x <= stop
 
 def shortuser(user):
     """Return a short representation of a user name or email address."""
     f = user.find('@')
     if f >= 0:
         user = user[:f]
     f = user.find('<')
     if f >= 0:
         user = user[f+1:]
     f = user.find(' ')
     if f >= 0:
         user = user[:f]
     f = user.find('.')
     if f >= 0:
         user = user[:f]
     return user
 
 def ellipsis(text, maxlength=400):
     """Trim string to at most maxlength (default: 400) characters."""
     if len(text) <= maxlength:
         return text
     else:
         return "%s..." % (text[:maxlength-3])
 
 def walkrepos(path):
     '''yield every hg repository under path, recursively.'''
     def errhandler(err):
         if err.filename == path:
             raise err
 
     for root, dirs, files in os.walk(path, onerror=errhandler):
         for d in dirs:
             if d == '.hg':
                 yield root
                 dirs[:] = []
                 break
 
 _rcpath = None
 
 def os_rcpath():
     '''return default os-specific hgrc search path'''
     path = system_rcpath()
     path.extend(user_rcpath())
     path = [os.path.normpath(f) for f in path]
     return path
 
 def rcpath():
     '''return hgrc search path. if env var HGRCPATH is set, use it.
     for each item in path, if directory, use files ending in .rc,
     else use item.
     make HGRCPATH empty to only look in .hg/hgrc of current repo.
     if no HGRCPATH, use default os-specific path.'''
     global _rcpath
     if _rcpath is None:
         if 'HGRCPATH' in os.environ:
             _rcpath = []
             for p in os.environ['HGRCPATH'].split(os.pathsep):
                 if not p: continue
                 if os.path.isdir(p):
                     for f in os.listdir(p):
                         if f.endswith('.rc'):
                             _rcpath.append(os.path.join(p, f))
                 else:
                     _rcpath.append(p)
         else:
             _rcpath = os_rcpath()
     return _rcpath
 
 def bytecount(nbytes):
     '''return byte count formatted as readable string, with units'''
 
     units = (
         (100, 1<<30, _('%.0f GB')),
         (10, 1<<30, _('%.1f GB')),
         (1, 1<<30, _('%.2f GB')),
         (100, 1<<20, _('%.0f MB')),
         (10, 1<<20, _('%.1f MB')),
         (1, 1<<20, _('%.2f MB')),
         (100, 1<<10, _('%.0f KB')),
         (10, 1<<10, _('%.1f KB')),
         (1, 1<<10, _('%.2f KB')),
         (1, 1, _('%.0f bytes')),
         )
 
     for multiplier, divisor, format in units:
         if nbytes >= divisor * multiplier:
             return format % (nbytes / float(divisor))
     return units[-1][2] % nbytes
 
 def drop_scheme(scheme, path):
     sc = scheme + ':'
     if path.startswith(sc):
         path = path[len(sc):]
         if path.startswith('//'):
             path = path[2:]
     return path

mercurial/util_win32.py

@@ -1,310 +1,310 b''
 # util_win32.py - utility functions that use win32 API
 #
 # Copyright 2005 Matt Mackall <[e-mail]>
 # 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.
 
 # Mark Hammond's win32all package allows better functionality on
 # Windows.  this module overrides definitions in util.py.  if not
 # available, import of this module will fail, and generic code will be
 # used.
 
 import win32api
 
 from i18n import _
 import errno, os, pywintypes, win32con, win32file, win32process
 import cStringIO, winerror
 from win32com.shell import shell,shellcon
 
 class WinError:
     winerror_map = {
         winerror.ERROR_ACCESS_DENIED: errno.EACCES,
         winerror.ERROR_ACCOUNT_DISABLED: errno.EACCES,
         winerror.ERROR_ACCOUNT_RESTRICTION: errno.EACCES,
         winerror.ERROR_ALREADY_ASSIGNED: errno.EBUSY,
         winerror.ERROR_ALREADY_EXISTS: errno.EEXIST,
         winerror.ERROR_ARITHMETIC_OVERFLOW: errno.ERANGE,
         winerror.ERROR_BAD_COMMAND: errno.EIO,
         winerror.ERROR_BAD_DEVICE: errno.ENODEV,
         winerror.ERROR_BAD_DRIVER_LEVEL: errno.ENXIO,
         winerror.ERROR_BAD_EXE_FORMAT: errno.ENOEXEC,
         winerror.ERROR_BAD_FORMAT: errno.ENOEXEC,
         winerror.ERROR_BAD_LENGTH: errno.EINVAL,
         winerror.ERROR_BAD_PATHNAME: errno.ENOENT,
         winerror.ERROR_BAD_PIPE: errno.EPIPE,
         winerror.ERROR_BAD_UNIT: errno.ENODEV,
         winerror.ERROR_BAD_USERNAME: errno.EINVAL,
         winerror.ERROR_BROKEN_PIPE: errno.EPIPE,
         winerror.ERROR_BUFFER_OVERFLOW: errno.ENAMETOOLONG,
         winerror.ERROR_BUSY: errno.EBUSY,
         winerror.ERROR_BUSY_DRIVE: errno.EBUSY,
         winerror.ERROR_CALL_NOT_IMPLEMENTED: errno.ENOSYS,
         winerror.ERROR_CANNOT_MAKE: errno.EACCES,
         winerror.ERROR_CANTOPEN: errno.EIO,
         winerror.ERROR_CANTREAD: errno.EIO,
         winerror.ERROR_CANTWRITE: errno.EIO,
         winerror.ERROR_CRC: errno.EIO,
         winerror.ERROR_CURRENT_DIRECTORY: errno.EACCES,
         winerror.ERROR_DEVICE_IN_USE: errno.EBUSY,
         winerror.ERROR_DEV_NOT_EXIST: errno.ENODEV,
         winerror.ERROR_DIRECTORY: errno.EINVAL,
         winerror.ERROR_DIR_NOT_EMPTY: errno.ENOTEMPTY,
         winerror.ERROR_DISK_CHANGE: errno.EIO,
         winerror.ERROR_DISK_FULL: errno.ENOSPC,
         winerror.ERROR_DRIVE_LOCKED: errno.EBUSY,
         winerror.ERROR_ENVVAR_NOT_FOUND: errno.EINVAL,
         winerror.ERROR_EXE_MARKED_INVALID: errno.ENOEXEC,
         winerror.ERROR_FILENAME_EXCED_RANGE: errno.ENAMETOOLONG,
         winerror.ERROR_FILE_EXISTS: errno.EEXIST,
         winerror.ERROR_FILE_INVALID: errno.ENODEV,
         winerror.ERROR_FILE_NOT_FOUND: errno.ENOENT,
         winerror.ERROR_GEN_FAILURE: errno.EIO,
         winerror.ERROR_HANDLE_DISK_FULL: errno.ENOSPC,
         winerror.ERROR_INSUFFICIENT_BUFFER: errno.ENOMEM,
         winerror.ERROR_INVALID_ACCESS: errno.EACCES,
         winerror.ERROR_INVALID_ADDRESS: errno.EFAULT,
         winerror.ERROR_INVALID_BLOCK: errno.EFAULT,
         winerror.ERROR_INVALID_DATA: errno.EINVAL,
         winerror.ERROR_INVALID_DRIVE: errno.ENODEV,
         winerror.ERROR_INVALID_EXE_SIGNATURE: errno.ENOEXEC,
         winerror.ERROR_INVALID_FLAGS: errno.EINVAL,
         winerror.ERROR_INVALID_FUNCTION: errno.ENOSYS,
         winerror.ERROR_INVALID_HANDLE: errno.EBADF,
         winerror.ERROR_INVALID_LOGON_HOURS: errno.EACCES,
         winerror.ERROR_INVALID_NAME: errno.EINVAL,
         winerror.ERROR_INVALID_OWNER: errno.EINVAL,
         winerror.ERROR_INVALID_PARAMETER: errno.EINVAL,
         winerror.ERROR_INVALID_PASSWORD: errno.EPERM,
         winerror.ERROR_INVALID_PRIMARY_GROUP: errno.EINVAL,
         winerror.ERROR_INVALID_SIGNAL_NUMBER: errno.EINVAL,
         winerror.ERROR_INVALID_TARGET_HANDLE: errno.EIO,
         winerror.ERROR_INVALID_WORKSTATION: errno.EACCES,
         winerror.ERROR_IO_DEVICE: errno.EIO,
         winerror.ERROR_IO_INCOMPLETE: errno.EINTR,
         winerror.ERROR_LOCKED: errno.EBUSY,
         winerror.ERROR_LOCK_VIOLATION: errno.EACCES,
         winerror.ERROR_LOGON_FAILURE: errno.EACCES,
         winerror.ERROR_MAPPED_ALIGNMENT: errno.EINVAL,
         winerror.ERROR_META_EXPANSION_TOO_LONG: errno.E2BIG,
         winerror.ERROR_MORE_DATA: errno.EPIPE,
         winerror.ERROR_NEGATIVE_SEEK: errno.ESPIPE,
         winerror.ERROR_NOACCESS: errno.EFAULT,
         winerror.ERROR_NONE_MAPPED: errno.EINVAL,
         winerror.ERROR_NOT_ENOUGH_MEMORY: errno.ENOMEM,
         winerror.ERROR_NOT_READY: errno.EAGAIN,
         winerror.ERROR_NOT_SAME_DEVICE: errno.EXDEV,
         winerror.ERROR_NO_DATA: errno.EPIPE,
         winerror.ERROR_NO_MORE_SEARCH_HANDLES: errno.EIO,
         winerror.ERROR_NO_PROC_SLOTS: errno.EAGAIN,
         winerror.ERROR_NO_SUCH_PRIVILEGE: errno.EACCES,
         winerror.ERROR_OPEN_FAILED: errno.EIO,
         winerror.ERROR_OPEN_FILES: errno.EBUSY,
         winerror.ERROR_OPERATION_ABORTED: errno.EINTR,
         winerror.ERROR_OUTOFMEMORY: errno.ENOMEM,
         winerror.ERROR_PASSWORD_EXPIRED: errno.EACCES,
         winerror.ERROR_PATH_BUSY: errno.EBUSY,
         winerror.ERROR_PATH_NOT_FOUND: errno.ENOENT,
         winerror.ERROR_PIPE_BUSY: errno.EBUSY,
         winerror.ERROR_PIPE_CONNECTED: errno.EPIPE,
         winerror.ERROR_PIPE_LISTENING: errno.EPIPE,
         winerror.ERROR_PIPE_NOT_CONNECTED: errno.EPIPE,
         winerror.ERROR_PRIVILEGE_NOT_HELD: errno.EACCES,
         winerror.ERROR_READ_FAULT: errno.EIO,
         winerror.ERROR_SEEK: errno.EIO,
         winerror.ERROR_SEEK_ON_DEVICE: errno.ESPIPE,
         winerror.ERROR_SHARING_BUFFER_EXCEEDED: errno.ENFILE,
         winerror.ERROR_SHARING_VIOLATION: errno.EACCES,
         winerror.ERROR_STACK_OVERFLOW: errno.ENOMEM,
         winerror.ERROR_SWAPERROR: errno.ENOENT,
         winerror.ERROR_TOO_MANY_MODULES: errno.EMFILE,
         winerror.ERROR_TOO_MANY_OPEN_FILES: errno.EMFILE,
         winerror.ERROR_UNRECOGNIZED_MEDIA: errno.ENXIO,
         winerror.ERROR_UNRECOGNIZED_VOLUME: errno.ENODEV,
         winerror.ERROR_WAIT_NO_CHILDREN: errno.ECHILD,
         winerror.ERROR_WRITE_FAULT: errno.EIO,
         winerror.ERROR_WRITE_PROTECT: errno.EROFS,
         }
 
     def __init__(self, err):
         self.win_errno, self.win_function, self.win_strerror = err
         if self.win_strerror.endswith('.'):
             self.win_strerror = self.win_strerror[:-1]
 
 class WinIOError(WinError, IOError):
     def __init__(self, err, filename=None):
         WinError.__init__(self, err)
         IOError.__init__(self, self.winerror_map.get(self.win_errno, 0),
                          self.win_strerror)
         self.filename = filename
 
 class WinOSError(WinError, OSError):
     def __init__(self, err):
         WinError.__init__(self, err)
         OSError.__init__(self, self.winerror_map.get(self.win_errno, 0),
                          self.win_strerror)
 
 def os_link(src, dst):
     # NB will only succeed on NTFS
     try:
         win32file.CreateHardLink(dst, src)
     except pywintypes.error, details:
         raise WinOSError(details)
 
 def nlinks(pathname):
     """Return number of hardlinks for the given file."""
     try:
         fh = win32file.CreateFile(pathname,
             win32file.GENERIC_READ, win32file.FILE_SHARE_READ,
             None, win32file.OPEN_EXISTING, 0, None)
         res = win32file.GetFileInformationByHandle(fh)
         fh.Close()
         return res[7]
     except pywintypes.error:
         return os.lstat(pathname).st_nlink
 
 def testpid(pid):
     '''return True if pid is still running or unable to
     determine, False otherwise'''
     try:
         handle = win32api.OpenProcess(
             win32con.PROCESS_QUERY_INFORMATION, False, pid)
         if handle:
             status = win32process.GetExitCodeProcess(handle)
             return status == win32con.STILL_ACTIVE
     except pywintypes.error, details:
         return details[0] != winerror.ERROR_INVALID_PARAMETER
     return True
 
 def system_rcpath_win32():
     '''return default os-specific hgrc search path'''
     proc = win32api.GetCurrentProcess()
     try:
         # This will fail on windows < NT
         filename = win32process.GetModuleFileNameEx(proc, 0)
     except:
         filename = win32api.GetModuleFileName(0)
     return [os.path.join(os.path.dirname(filename), 'mercurial.ini')]
 
 def user_rcpath_win32():
     '''return os-specific hgrc search path to the user dir'''
     userdir = os.path.expanduser('~')
     if userdir == '~':
         # We are on win < nt: fetch the APPDATA directory location and use
         # the parent directory as the user home dir.
         appdir = shell.SHGetPathFromIDList(
             shell.SHGetSpecialFolderLocation(0, shellcon.CSIDL_APPDATA))
         userdir = os.path.dirname(appdir)
     return os.path.join(userdir, 'mercurial.ini')
 
 class posixfile_nt(object):
     '''file object with posix-like semantics.  on windows, normal
     files can not be deleted or renamed if they are open. must open
     with win32file.FILE_SHARE_DELETE. this flag does not exist on
     windows < nt, so do not use this class there.'''
 
     # tried to use win32file._open_osfhandle to pass fd to os.fdopen,
     # but does not work at all. wrap win32 file api instead.
 
     def __init__(self, name, mode='rb'):
         access = 0
-        if 'r' in mode or '+' in mode:
+        if 'r' in mode:
             access |= win32file.GENERIC_READ
-        if 'w' in mode or 'a' in mode:
+        if 'w' in mode or 'a' in mode or '+' in mode:
             access |= win32file.GENERIC_WRITE
         if 'r' in mode:
             creation = win32file.OPEN_EXISTING
         elif 'a' in mode:
             creation = win32file.OPEN_ALWAYS
         else:
             creation = win32file.CREATE_ALWAYS
         try:
             self.handle = win32file.CreateFile(name,
                                                access,
                                                win32file.FILE_SHARE_READ |
                                                win32file.FILE_SHARE_WRITE |
                                                win32file.FILE_SHARE_DELETE,
                                                None,
                                                creation,
                                                win32file.FILE_ATTRIBUTE_NORMAL,
                                                0)
         except pywintypes.error, err:
             raise WinIOError(err, name)
         self.closed = False
         self.name = name
         self.mode = mode
 
     def __iter__(self):
         for line in self.read().splitlines(True):
             yield line
 
     def read(self, count=-1):
         try:
             cs = cStringIO.StringIO()
             while count:
                 wincount = int(count)
                 if wincount == -1:
                     wincount = 1048576
                 val, data = win32file.ReadFile(self.handle, wincount)
                 if not data: break
                 cs.write(data)
                 if count != -1:
                     count -= len(data)
             return cs.getvalue()
         except pywintypes.error, err:
             raise WinIOError(err)
 
     def write(self, data):
         try:
             if 'a' in self.mode:
                 win32file.SetFilePointer(self.handle, 0, win32file.FILE_END)
             nwrit = 0
             while nwrit < len(data):
                 val, nwrit = win32file.WriteFile(self.handle, data)
                 data = data[nwrit:]
         except pywintypes.error, err:
             raise WinIOError(err)
 
     def seek(self, pos, whence=0):
         try:
             win32file.SetFilePointer(self.handle, int(pos), whence)
         except pywintypes.error, err:
             raise WinIOError(err)
 
     def tell(self):
         try:
             return win32file.SetFilePointer(self.handle, 0,
                                             win32file.FILE_CURRENT)
         except pywintypes.error, err:
             raise WinIOError(err)
 
     def close(self):
         if not self.closed:
             self.handle = None
             self.closed = True
 
     def flush(self):
         try:
             win32file.FlushFileBuffers(self.handle)
         except pywintypes.error, err:
             raise WinIOError(err)
 
     def truncate(self, pos=0):
         try:
             win32file.SetFilePointer(self.handle, int(pos),
                                      win32file.FILE_BEGIN)
             win32file.SetEndOfFile(self.handle)
         except pywintypes.error, err:
             raise WinIOError(err)
 
 getuser_fallback = win32api.GetUserName
 
 def set_signal_handler_win32():
     """Register a termination handler for console events including
     CTRL+C. python signal handlers do not work well with socket
     operations.
     """
     def handler(event):
         win32process.ExitProcess(1)
     win32api.SetConsoleCtrlHandler(handler)

tests/test-extension

@@ -1,66 +1,81 b''
 #!/bin/sh
 # Test basic extension support
 
 cat > foobar.py <<EOF
 import os
 from mercurial import commands
 
 def uisetup(ui):
     ui.write("uisetup called\\n")
     ui.write("ui.parentui is%s None\\n" % (ui.parentui is not None
                                            and "not" or ""))
 
 def reposetup(ui, repo):
     ui.write("reposetup called for %s\\n" % os.path.basename(repo.root))
     ui.write("ui %s= repo.ui\\n" % (ui == repo.ui and "=" or "!"))
 
 def foo(ui, *args, **kwargs):
     ui.write("Foo\\n")
 
 def bar(ui, *args, **kwargs):
     ui.write("Bar\\n")
 
 cmdtable = {
     "foo": (foo, [], "hg foo"),
     "bar": (bar, [], "hg bar"),
 }
 
 commands.norepo += ' bar'
 EOF
 abspath=`pwd`/foobar.py
 
 mkdir barfoo
 cp foobar.py barfoo/__init__.py
 barfoopath=`pwd`/barfoo
 
 hg init a
 cd a
 echo foo > file
 hg add file
 hg commit -m 'add file'
 
 echo '[extensions]' >> $HGRCPATH
 echo "foobar = $abspath" >> $HGRCPATH
 hg foo
 
 cd ..
 hg clone a b
 
 hg bar
 
 echo '% module/__init__.py-style'
 echo '[extensions]' > $HGRCPATH
 echo "barfoo = $barfoopath" >> $HGRCPATH
 cd a
 hg foo
 
 cd ..
 cat > empty.py <<EOF
 '''empty cmdtable
 '''
 cmdtable = {}
 EOF
 emptypath=`pwd`/empty.py
 echo '[extensions]' > $HGRCPATH
 echo "empty = $emptypath" >> $HGRCPATH
 hg help empty
+
+cat > debugextension.py <<EOF
+'''only debugcommands
+'''
+def debugfoobar(ui, repo, *args, **opts):
+    "yet another debug command"
+    pass
+
+cmdtable = {"debugfoobar": (debugfoobar, (), "hg debugfoobar")}
+EOF
+debugpath=`pwd`/debugextension.py
+echo '[extensions]' > $HGRCPATH
+echo "debugextension = $debugpath" >> $HGRCPATH
+hg help debugextension
+hg --debug help debugextension

tests/test-extension.out

@@ -1,24 +1,51 b''
 uisetup called
 ui.parentui isnot None
 reposetup called for a
 ui == repo.ui
 Foo
 uisetup called
 ui.parentui is None
 reposetup called for a
 ui == repo.ui
 reposetup called for b
 ui == repo.ui
 1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 uisetup called
 ui.parentui is None
 Bar
 % module/__init__.py-style
 uisetup called
 ui.parentui isnot None
 reposetup called for a
 ui == repo.ui
 Foo
 empty extension - empty cmdtable
 
 no commands defined
+debugextension extension - only debugcommands
+
+no commands defined
+debugextension extension - only debugcommands
+
+list of commands:
+
+ debugfoobar:
+      yet another debug command
+
+global options:
+ -R --repository      repository root directory or symbolic path name
+    --cwd             change working directory
+ -y --noninteractive  do not prompt, assume 'yes' for any required answers
+ -q --quiet           suppress output
+ -v --verbose         enable additional output
+    --config          set/override config option
+    --debug           enable debugging output
+    --debugger        start debugger
+    --encoding        set the charset encoding (default: ascii)
+    --encodingmode    set the charset encoding mode (default: strict)
+    --lsprof          print improved command execution profile
+    --traceback       print traceback on exception
+    --time            time how long the command takes
+    --profile         print command execution profile
+    --version         output version information and exit
+ -h --help            display help and exit

tests/test-tag

@@ -1,43 +1,47 b''
 #!/bin/sh
 
 hg init
 echo a > a
 hg add a
 hg commit -m "test" -d "1000000 0"
 hg history
 hg tag -d "1000000 0" "bleah"
 hg history
 
 echo foo >> .hgtags
 hg tag -d "1000000 0" "bleah2" || echo "failed"
 hg tag -d "1000000 0" -r 0 "bleah2" 1 || echo "failed"
 
 hg revert .hgtags
 hg tag -d "1000000 0" -r 0 "bleah0"
 hg tag -l -d "1000000 0" "bleah1" 1
 
 cat .hgtags
 cat .hg/localtags
 
 hg update 0
 hg tag -d "1000000 0" "foobar"
 cat .hgtags
 cat .hg/localtags
 
 hg tag -l 'xx
 newline'
 hg tag -l 'xx:xx'
 
 echo % issue 601
-mv .hg/localtags .hg/ltags
-head -1 .hg/ltags | tr -d '\n' > .hg/localtags
+python << EOF
+f = file('.hg/localtags'); last = f.readlines()[-1][:-1]; f.close()
+f = file('.hg/localtags', 'w'); f.write(last); f.close()
+EOF
 cat .hg/localtags
 hg tag -l localnewline
 cat .hg/localtags
 
-mv .hgtags hgtags
-head -1 hgtags | tr -d '\n' > .hgtags
+python << EOF
+f = file('.hgtags'); last = f.readlines()[-1][:-1]; f.close()
+f = file('.hgtags', 'w'); f.write(last); f.close()
+EOF
 hg ci -d '1000000 0' -m'broken manual edit of .hgtags'
 cat .hgtags
 hg tag -d '1000000 0' newline
 cat .hgtags