convert: call superclass init from engine init functions

hgext/convert/common.py

@@ -1,110 +1,110 b''
 # common code for the convert extension
 
 class NoRepo(Exception): pass
 
 class commit(object):
     def __init__(self, **parts):
         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)"""
-        raise NotImplementedError()
+        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 = hasattr(self, 'encoding') and 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/cvs.py

@@ -1,260 +1,262 b''
 # CVS conversion code inspired by hg-cvs-import and git-cvsimport
 
 import os, locale, re, socket
 from mercurial import util
 
 from common import NoRepo, commit, converter_source
 
 class convert_cvs(converter_source):
     def __init__(self, ui, path, rev=None):
+        super(convert_cvs, self).__init__(ui, path, rev=rev)
+
         self.path = path
         self.ui = ui
         self.rev = rev
         cvs = os.path.join(path, "CVS")
         if not os.path.exists(cvs):
             raise NoRepo("couldn't open CVS repo %s" % path)
 
         self.changeset = {}
         self.files = {}
         self.tags = {}
         self.lastbranch = {}
         self.parent = {}
         self.socket = None
         self.cvsroot = file(os.path.join(cvs, "Root")).read()[:-1]
         self.cvsrepo = file(os.path.join(cvs, "Repository")).read()[:-1]
         self.encoding = locale.getpreferredencoding()
         self._parse()
         self._connect()
 
     def _parse(self):
         if self.changeset:
             return
 
         maxrev = 0
         cmd = 'cvsps -A -u --cvs-direct -q'
         if self.rev:
             # TODO: handle tags
             try:
                 # patchset number?
                 maxrev = int(self.rev)
             except ValueError:
                 try:
                     # date
                     util.parsedate(self.rev, ['%Y/%m/%d %H:%M:%S'])
                     cmd = "%s -d '1970/01/01 00:00:01' -d '%s'" % (cmd, self.rev)
                 except util.Abort:
                     raise util.Abort('revision %s is not a patchset number or date' % self.rev)
 
         d = os.getcwd()
         try:
             os.chdir(self.path)
             id = None
             state = 0
             for l in os.popen(cmd):
                 if state == 0: # header
                     if l.startswith("PatchSet"):
                         id = l[9:-2]
                         if maxrev and int(id) > maxrev:
                             state = 3
                     elif l.startswith("Date"):
                         date = util.parsedate(l[6:-1], ["%Y/%m/%d %H:%M:%S"])
                         date = util.datestr(date)
                     elif l.startswith("Branch"):
                         branch = l[8:-1]
                         self.parent[id] = self.lastbranch.get(branch, 'bad')
                         self.lastbranch[branch] = id
                     elif l.startswith("Ancestor branch"):
                         ancestor = l[17:-1]
                         self.parent[id] = self.lastbranch[ancestor]
                     elif l.startswith("Author"):
                         author = self.recode(l[8:-1])
                     elif l.startswith("Tag:") or l.startswith("Tags:"):
                         t = l[l.index(':')+1:]
                         t = [ut.strip() for ut in t.split(',')]
                         if (len(t) > 1) or (t[0] and (t[0] != "(none)")):
                             self.tags.update(dict.fromkeys(t, id))
                     elif l.startswith("Log:"):
                         state = 1
                         log = ""
                 elif state == 1: # log
                     if l == "Members: \n":
                         files = {}
                         log = self.recode(log[:-1])
                         state = 2
                     else:
                         log += l
                 elif state == 2:
                     if l == "\n": #
                         state = 0
                         p = [self.parent[id]]
                         if id == "1":
                             p = []
                         if branch == "HEAD":
                             branch = ""
                         c = commit(author=author, date=date, parents=p,
                                    desc=log, branch=branch)
                         self.changeset[id] = c
                         self.files[id] = files
                     else:
                         colon = l.rfind(':')
                         file = l[1:colon]
                         rev = l[colon+1:-2]
                         rev = rev.split("->")[1]
                         files[file] = rev
                 elif state == 3:
                     continue
 
             self.heads = self.lastbranch.values()
         finally:
             os.chdir(d)
 
     def _connect(self):
         root = self.cvsroot
         conntype = None
         user, host = None, None
         cmd = ['cvs', 'server']
 
         self.ui.status("connecting to %s\n" % root)
 
         if root.startswith(":pserver:"):
             root = root[9:]
             m = re.match(r'(?:(.*?)(?::(.*?))?@)?([^:\/]*)(?::(\d*))?(.*)',
                          root)
             if m:
                 conntype = "pserver"
                 user, passw, serv, port, root = m.groups()
                 if not user:
                     user = "anonymous"
                 rr = ":pserver:" + user + "@" + serv + ":" +  root
                 if port:
                     rr2, port = "-", int(port)
                 else:
                     rr2, port = rr, 2401
                 rr += str(port)
 
                 if not passw:
                     passw = "A"
                     pf = open(os.path.join(os.environ["HOME"], ".cvspass"))
                     for l in pf:
                         # :pserver:[e-mail]:/cvsroot/zmailer Ah<Z
                         m = re.match(r'(/\d+\s+/)?(.*)', l)
                         l = m.group(2)
                         w, p = l.split(' ', 1)
                         if w in [rr, rr2]:
                             passw = p
                             break
                     pf.close()
 
                 sck = socket.socket()
                 sck.connect((serv, port))
                 sck.send("\n".join(["BEGIN AUTH REQUEST", root, user, passw,
                                     "END AUTH REQUEST", ""]))
                 if sck.recv(128) != "I LOVE YOU\n":
                     raise NoRepo("CVS pserver authentication failed")
 
                 self.writep = self.readp = sck.makefile('r+')
 
         if not conntype and root.startswith(":local:"):
             conntype = "local"
             root = root[7:]
 
         if not conntype:
             # :ext:user@host/home/user/path/to/cvsroot
             if root.startswith(":ext:"):
                 root = root[5:]
             m = re.match(r'(?:([^@:/]+)@)?([^:/]+):?(.*)', root)
             if not m:
                 conntype = "local"
             else:
                 conntype = "rsh"
                 user, host, root = m.group(1), m.group(2), m.group(3)
 
         if conntype != "pserver":
             if conntype == "rsh":
                 rsh = os.environ.get("CVS_RSH" or "rsh")
                 if user:
                     cmd = [rsh, '-l', user, host] + cmd
                 else:
                     cmd = [rsh, host] + cmd
 
             self.writep, self.readp = os.popen2(cmd)
 
         self.realroot = root
 
         self.writep.write("Root %s\n" % root)
         self.writep.write("Valid-responses ok error Valid-requests Mode"
                           " M Mbinary E Checked-in Created Updated"
                           " Merged Removed\n")
         self.writep.write("valid-requests\n")
         self.writep.flush()
         r = self.readp.readline()
         if not r.startswith("Valid-requests"):
             raise util.Abort("server sucks")
         if "UseUnchanged" in r:
             self.writep.write("UseUnchanged\n")
             self.writep.flush()
             r = self.readp.readline()
 
     def getheads(self):
         return self.heads
 
     def _getfile(self, name, rev):
         if rev.endswith("(DEAD)"):
             raise IOError
 
         args = ("-N -P -kk -r %s --" % rev).split()
         args.append(os.path.join(self.cvsrepo, name))
         for x in args:
             self.writep.write("Argument %s\n" % x)
         self.writep.write("Directory .\n%s\nco\n" % self.realroot)
         self.writep.flush()
 
         data = ""
         while 1:
             line = self.readp.readline()
             if line.startswith("Created ") or line.startswith("Updated "):
                 self.readp.readline() # path
                 self.readp.readline() # entries
                 mode = self.readp.readline()[:-1]
                 count = int(self.readp.readline()[:-1])
                 data = self.readp.read(count)
             elif line.startswith(" "):
                 data += line[1:]
             elif line.startswith("M "):
                 pass
             elif line.startswith("Mbinary "):
                 count = int(self.readp.readline()[:-1])
                 data = self.readp.read(count)
             else:
                 if line == "ok\n":
                     return (data, "x" in mode and "x" or "")
                 elif line.startswith("E "):
                     self.ui.warn("cvs server: %s\n" % line[2:])
                 elif line.startswith("Remove"):
                     l = self.readp.readline()
                     l = self.readp.readline()
                     if l != "ok\n":
                         raise util.Abort("unknown CVS response: %s" % l)
                 else:
                     raise util.Abort("unknown CVS response: %s" % line)
 
     def getfile(self, file, rev):
         data, mode = self._getfile(file, rev)
         self.modecache[(file, rev)] = mode
         return data
 
     def getmode(self, file, rev):
         return self.modecache[(file, rev)]
 
     def getchanges(self, rev):
         self.modecache = {}
         files = self.files[rev]
         cl = files.items()
         cl.sort()
         return cl
 
     def getcommit(self, rev):
         return self.changeset[rev]
 
     def gettags(self):
         return self.tags

hgext/convert/git.py

@@ -1,102 +1,104 b''
 # git support for the convert extension
 
 import os
 
 from common import NoRepo, commit, converter_source
 
 class convert_git(converter_source):
     def gitcmd(self, s):
         return os.popen('GIT_DIR=%s %s' % (self.path, s))
 
     def __init__(self, ui, path, rev=None):
+        super(convert_git, self).__init__(ui, path, rev=rev)
+
         if os.path.isdir(path + "/.git"):
             path += "/.git"
         if not os.path.exists(path + "/objects"):
             raise NoRepo("couldn't open GIT repo %s" % path)
 
         self.path = path
         self.ui = ui
         self.rev = rev
         self.encoding = 'utf-8'
 
     def getheads(self):
         if not self.rev:
             return self.gitcmd('git-rev-parse --branches').read().splitlines()
         else:
             fh = self.gitcmd("git-rev-parse --verify %s" % self.rev)
             return [fh.read()[:-1]]
 
     def catfile(self, rev, type):
         if rev == "0" * 40: raise IOError()
         fh = self.gitcmd("git-cat-file %s %s 2>/dev/null" % (type, rev))
         return fh.read()
 
     def getfile(self, name, rev):
         return self.catfile(rev, "blob")
 
     def getmode(self, name, rev):
         return self.modecache[(name, rev)]
 
     def getchanges(self, version):
         self.modecache = {}
         fh = self.gitcmd("git-diff-tree --root -m -r %s" % version)
         changes = []
         for l in fh:
             if "\t" not in l: continue
             m, f = l[:-1].split("\t")
             m = m.split()
             h = m[3]
             p = (m[1] == "100755")
             s = (m[1] == "120000")
             self.modecache[(f, h)] = (p and "x") or (s and "l") or ""
             changes.append((f, h))
         return changes
 
     def getcommit(self, version):
         c = self.catfile(version, "commit") # read the commit hash
         end = c.find("\n\n")
         message = c[end+2:]
         message = self.recode(message)
         l = c[:end].splitlines()
         manifest = l[0].split()[1]
         parents = []
         for e in l[1:]:
             n, v = e.split(" ", 1)
             if n == "author":
                 p = v.split()
                 tm, tz = p[-2:]
                 author = " ".join(p[:-2])
                 if author[0] == "<": author = author[1:-1]
                 author = self.recode(author)
             if n == "committer":
                 p = v.split()
                 tm, tz = p[-2:]
                 committer = " ".join(p[:-2])
                 if committer[0] == "<": committer = committer[1:-1]
                 committer = self.recode(committer)
                 message += "\ncommitter: %s\n" % committer
             if n == "parent": parents.append(v)
 
         tzs, tzh, tzm = tz[-5:-4] + "1", tz[-4:-2], tz[-2:]
         tz = -int(tzs) * (int(tzh) * 3600 + int(tzm))
         date = tm + " " + str(tz)
         author = author or "unknown"
 
         c = commit(parents=parents, date=date, author=author, desc=message)
         return c
 
     def gettags(self):
         tags = {}
         fh = self.gitcmd('git-ls-remote --tags "%s" 2>/dev/null' % self.path)
         prefix = 'refs/tags/'
         for line in fh:
             line = line.strip()
             if not line.endswith("^{}"):
                 continue
             node, tag = line.split(None, 1)
             if not tag.startswith(prefix):
                 continue
             tag = tag[len(prefix):-3]
             tags[tag] = node
 
         return tags

hgext/convert/subversion.py

@@ -1,602 +1,604 b''
 # Subversion 1.4/1.5 Python API backend
 #
 # Copyright(C) 2007 Daniel Holth et al
 
 import pprint
 import locale
 
 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 svn_entry(object):
     """Emulate a Subversion path change."""
     __slots__ = ['path', 'copyfrom_path', 'copyfrom_rev', 'action']
     def __init__(self, entry):
         self.copyfrom_path = entry.copyfrom_path
         self.copyfrom_rev = entry.copyfrom_rev
         self.action = entry.action
 
     def __str__(self):
         return "%s %s %s" % (self.action, self.copyfrom_path, self.copyfrom_rev)
 
     def __repr__(self):
         return self.__str__()
 
 class svn_paths(object):
     """Emulate a Subversion ordered dictionary of changed paths."""
     __slots__ = ['values', 'order']
     def __init__(self, orig_paths):
         self.order = []
         self.values = {}
         if hasattr(orig_paths, 'keys'):
             self.order = sorted(orig_paths.keys())
             self.values.update(orig_paths)
             return
         if not orig_paths:
             return
         for path in orig_paths:
             self.order.append(path)
             self.values[path] = svn_entry(orig_paths[path])
         self.order.sort() # maybe the order it came in isn't so great...
 
     def __iter__(self):
         return iter(self.order)
 
     def __getitem__(self, key):
         return self.values[key]
 
     def __str__(self):
         s = "{\n"
         for path in self.order:
             s += "'%s': %s,\n" % (path, self.values[path])
         s += "}"
         return s
     
     def __repr__(self):
         return self.__str__()
 
 # 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.ui = ui
         self.encoding = locale.getpreferredencoding()
         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)
         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.ra = self.transport.ra
             self.ctx = svn.client.create_context()
             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.rev(self.last_changed)
 
     def rev(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))
 
         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
 
         self.child_cset = None
         def parselogentry(*arg, **args):
             orig_paths, revnum, author, date, message, pool = arg
             orig_paths = svn_paths(orig_paths)
 
             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
 
             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.rev(revnum)
             parents = []
             try:
                 branch = self.module.split("/")[-1]
                 if branch == 'trunk':
                     branch = ''
             except IndexError:
                 branch = None
                 
             for path 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.rev(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 
                         # from the new location in the same commit. This
                         # code can't deal with that yet.
                         if ent.action == 'C':
                             children = self._find_children(path, fromrev)
                         else:
                             oroot = entrypath.strip('/')
                             nroot = path.strip('/')
                             children = self._find_children(oroot, fromrev)
                             children = [s.replace(oroot,nroot) for s in children]
                         # Mark all [files, not directories] as deleted.
                         for child in children:
                             # Can we move a child directory and its
                             # parent in the same commit? (probably can). Could
                             # cause problems if instead of revnum -1, 
                             # we have to look in (copyfrom_path, revnum - 1)
                             entrypath = 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, 
                         # 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 
             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, 
                           parents=parents,
                           copies=copies,
                           branch=branch)
 
             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.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,
                            parselogentry)
             self.last_revnum = to_revnum
         except SubversionException, (_, num):
             if num == svn.core.SVN_ERR_FS_NO_SUCH_REVISION:
                 raise NoSuchRevision(branch=self, 
                     revision="Revision number %d" % to_revnum)
             raise
 
     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'
             lt = self.latest(self.module, self.last_changed)
             self.head = self.rev(lt)
             self.heads = [self.head]
             branches = svn.client.ls(rpath + '/branches', optrev, False, self.ctx)
             for branch in branches.keys():
                 module = '/branches/' + branch
                 brevnum = self.latest(module, self.last_changed)
                 brev = self.rev(brevnum, module)
                 self.ui.note('found branch %s at %d\n' % (branch, brevnum))
                 self.heads.append(brev)
         else:
             self.heads = [self.head]
         return self.heads
 
     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 getfile(self, file, rev):
         data, mode = self._getfile(file, rev)
         self.modecache[(file, rev)] = mode
         return data
 
     def getmode(self, file, rev):        
         return self.modecache[(file, rev)]
 
     def getchanges(self, rev):
         self.modecache = {}
         files = self.files[rev]
         cl = files
         cl.sort()
         return cl
 
     def getcommit(self, rev):
         if rev not in self.commits:
             uuid, module, revnum = self.revsplit(rev)
             self.module = module
             self.reparent(module)
             self._fetch_revisions(from_revnum=revnum, to_revnum=0)
         return self.commits[rev]
 
     def gettags(self):
         tags = {}
         def parselogentry(*arg, **args):
             orig_paths, revnum, author, date, message, pool = arg
             orig_paths = svn_paths(orig_paths)
             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.rev(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:
             self.ui.note('no tags found at revision %d\n' % start)
             return {}
 
     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]