Merge with crew-stable

tests/test-convert-bzr-114

@@ -0,0 +1,30 b''
+#!/bin/sh
+
+"$TESTDIR/hghave" bzr114 || exit 80
+
+. "$TESTDIR/bzr-definitions"
+
+# The file/directory replacement can only be reproduced on
+# bzr >= 1.4. Merge it back in test-convert-bzr-directories once
+# this version becomes mainstream.
+echo % replace file with dir
+mkdir test-replace-file-with-dir
+cd test-replace-file-with-dir
+bzr init -q source
+cd source
+echo d > d
+bzr add -q d
+bzr commit -q -m 'add d file'
+rm d
+mkdir d
+bzr add -q d
+bzr commit -q -m 'replace with d dir'
+echo a > d/a
+bzr add -q d/a
+bzr commit -q -m 'add d/a'
+cd ..
+hg convert source source-hg
+manifest source-hg tip
+cd source-hg
+hg update
+cd ../..

tests/test-convert-bzr-114.out

@@ -0,0 +1,11 b''
+% replace file with dir
+initializing destination source-hg repository
+scanning source...
+sorting...
+converting...
+2 add d file
+1 replace with d dir
+0 add d/a
+% manifest of tip
+644   d/a
+1 files updated, 0 files merged, 0 files removed, 0 files unresolved

hgext/convert/bzr.py

@@ -1,219 +1,224 b''
 # bzr support for the convert extension
 # This module is for handling 'bzr', that was formerly known as Bazaar-NG;
 # it cannot access 'bar' repositories, but they were never used very much
 
 import os
 from mercurial import demandimport
 # these do not work with demandimport, blacklist
 demandimport.ignore.extend([
         'bzrlib.transactions',
         'bzrlib.urlutils',
     ])
 
 from mercurial.i18n import _
 from mercurial import util
 from common import NoRepo, commit, converter_source
 
 try:
     # bazaar imports
     from bzrlib import branch, revision, errors
     from bzrlib.revisionspec import RevisionSpec
 except ImportError:
     pass
 
 supportedkinds = ('file', 'symlink')
 
 class bzr_source(converter_source):
     """Reads Bazaar repositories by using the Bazaar Python libraries"""
 
     def __init__(self, ui, path, rev=None):
         super(bzr_source, self).__init__(ui, path, rev=rev)
 
         if not os.path.exists(os.path.join(path, '.bzr')):
             raise NoRepo('%s does not look like a Bazaar repo' % path)
 
         try:
             # access bzrlib stuff
             branch
         except NameError:
             raise NoRepo('Bazaar modules could not be loaded')
 
         path = os.path.abspath(path)
         self.branch = branch.Branch.open(path)
         self.sourcerepo = self.branch.repository
         self._parentids = {}
 
     def before(self):
         """Before the conversion begins, acquire a read lock
         for all the operations that might need it. Fortunately
         read locks don't block other reads or writes to the
         repository, so this shouldn't have any impact on the usage of
         the source repository.
 
         The alternative would be locking on every operation that
         needs locks (there are currently two: getting the file and
         getting the parent map) and releasing immediately after,
         but this approach can take even 40% longer."""
         self.sourcerepo.lock_read()
 
     def after(self):
         self.sourcerepo.unlock()
 
     def getheads(self):
         if not self.rev:
             return [self.branch.last_revision()]
         try:
             r = RevisionSpec.from_string(self.rev)
             info = r.in_history(self.branch)
         except errors.BzrError:
             raise util.Abort(_('%s is not a valid revision in current branch')
                              % self.rev)
         return [info.rev_id]
 
     def getfile(self, name, rev):
         revtree = self.sourcerepo.revision_tree(rev)
         fileid = revtree.path2id(name)
         if fileid is None or revtree.kind(fileid) not in supportedkinds:
             # the file is not available anymore - was deleted
             raise IOError(_('%s is not available in %s anymore') %
                     (name, rev))
         sio = revtree.get_file(fileid)
         return sio.read()
 
     def getmode(self, name, rev):
         return self._modecache[(name, rev)]
 
     def getchanges(self, version):
         # set up caches: modecache and revtree
         self._modecache = {}
         self._revtree = self.sourcerepo.revision_tree(version)
         # get the parentids from the cache
         parentids = self._parentids.pop(version)
         # only diff against first parent id
         prevtree = self.sourcerepo.revision_tree(parentids[0])
         return self._gettreechanges(self._revtree, prevtree)
 
     def getcommit(self, version):
         rev = self.sourcerepo.get_revision(version)
         # populate parent id cache
         if not rev.parent_ids:
             parents = []
             self._parentids[version] = (revision.NULL_REVISION,)
         else:
             parents = self._filterghosts(rev.parent_ids)
             self._parentids[version] = parents
 
         return commit(parents=parents,
                 # bzr uses 1 second timezone precision
                 date='%d %d' % (rev.timestamp, rev.timezone / 3600),
                 author=self.recode(rev.committer),
                 # bzr returns bytestrings or unicode, depending on the content
                 desc=self.recode(rev.message),
                 rev=version)
 
     def gettags(self):
         if not self.branch.supports_tags():
             return {}
         tagdict = self.branch.tags.get_tag_dict()
         bytetags = {}
         for name, rev in tagdict.iteritems():
             bytetags[self.recode(name)] = rev
         return bytetags
 
     def getchangedfiles(self, rev, i):
         self._modecache = {}
         curtree = self.sourcerepo.revision_tree(rev)
         parentids = self._parentids.pop(rev)
         if i is not None:
             parentid = parentids[i]
         else:
             # no parent id, get the empty revision
             parentid = revision.NULL_REVISION
 
         prevtree = self.sourcerepo.revision_tree(parentid)
         changes = [e[0] for e in self._gettreechanges(curtree, prevtree)[0]]
         return changes
 
     def _gettreechanges(self, current, origin):
         revid = current._revision_id;
         changes = []
         renames = {}
         for (fileid, paths, changed_content, versioned, parent, name,
             kind, executable) in current.iter_changes(origin):
 
             if paths[0] == u'' or paths[1] == u'':
                 # ignore changes to tree root
                 continue
 
             # bazaar tracks directories, mercurial does not, so
             # we have to rename the directory contents
             if kind[1] == 'directory':
+                if kind[0] not in (None, 'directory'):
+                    # Replacing 'something' with a directory, record it
+                    # so it can be removed.
+                    changes.append((self.recode(paths[0]), revid))
+
                 if None not in paths and paths[0] != paths[1]:
                     # neither an add nor an delete - a move
                     # rename all directory contents manually
                     subdir = origin.inventory.path2id(paths[0])
                     # get all child-entries of the directory
                     for name, entry in origin.inventory.iter_entries(subdir):
                         # hg does not track directory renames
                         if entry.kind == 'directory':
                             continue
                         frompath = self.recode(paths[0] + '/' + name)
                         topath = self.recode(paths[1] + '/' + name)
                         # register the files as changed
                         changes.append((frompath, revid))
                         changes.append((topath, revid))
                         # add to mode cache
                         mode = ((entry.executable and 'x') or (entry.kind == 'symlink' and 's')
                                 or '')
                         self._modecache[(topath, revid)] = mode
                         # register the change as move
                         renames[topath] = frompath
 
                 # no futher changes, go to the next change
                 continue
 
             # we got unicode paths, need to convert them
             path, topath = [self.recode(part) for part in paths]
 
             if topath is None:
                 # file deleted
                 changes.append((path, revid))
                 continue
 
             # renamed
             if path and path != topath:
                 renames[topath] = path
                 changes.append((path, revid))
 
             # populate the mode cache
             kind, executable = [e[1] for e in (kind, executable)]
             mode = ((executable and 'x') or (kind == 'symlink' and 's')
                     or '')
             self._modecache[(topath, revid)] = mode
             changes.append((topath, revid))
 
         return changes, renames
 
     def _filterghosts(self, ids):
         """Filters out ghost revisions which hg does not support, see
         <http://bazaar-vcs.org/GhostRevision>
         """
         parentmap = self.sourcerepo.get_parent_map(ids)
         parents = tuple([parent for parent in ids if parent in parentmap])
         return parents
 
     def recode(self, s, encoding=None):
         """This version of recode tries to encode unicode to bytecode,
         and preferably using the UTF-8 codec.
         Other types than Unicode are silently returned, this is by
         intention, e.g. the None-type is not going to be encoded but instead
         just passed through
         """
         if not encoding:
             encoding = self.encoding or 'utf-8'
 
         if isinstance(s, unicode):
             return s.encode(encoding)
         else:
             # leave it alone
             return s

hgext/convert/monotone.py

@@ -1,216 +1,222 b''
 # monotone support for the convert extension
 
 import os, re
 from mercurial import util
 from common import NoRepo, commit, converter_source, checktool
 from common import commandline
 from mercurial.i18n import _
 
 class monotone_source(converter_source, commandline):
     def __init__(self, ui, path=None, rev=None):
         converter_source.__init__(self, ui, path, rev)
         commandline.__init__(self, ui, 'mtn')
 
         self.ui = ui
         self.path = path
 
         norepo = NoRepo (_("%s does not look like a monotone repo") % path)
         if not os.path.exists(os.path.join(path, '_MTN')):
             # Could be a monotone repository (SQLite db file)
             try:
                 header = file(path, 'rb').read(16)
             except:
                 header = ''
             if header != 'SQLite format 3\x00':
                 raise norepo
 
         # regular expressions for parsing monotone output
         space    = r'\s*'
         name     = r'\s+"((?:\\"|[^"])*)"\s*'
         value    = name
         revision = r'\s+\[(\w+)\]\s*'
         lines    = r'(?:.|\n)+'
 
         self.dir_re      = re.compile(space + "dir" + name)
         self.file_re     = re.compile(space + "file" + name + "content" + revision)
         self.add_file_re = re.compile(space + "add_file" + name + "content" + revision)
         self.patch_re    = re.compile(space + "patch" + name + "from" + revision + "to" + revision)
         self.rename_re   = re.compile(space + "rename" + name + "to" + name)
         self.delete_re   = re.compile(space + "delete" + name)
         self.tag_re      = re.compile(space + "tag" + name + "revision" + revision)
         self.cert_re     = re.compile(lines + space + "name" + name + "value" + value)
 
         attr = space + "file" + lines + space + "attr" + space
         self.attr_execute_re = re.compile(attr  + '"mtn:execute"' + space + '"true"')
 
         # cached data
         self.manifest_rev = None
         self.manifest = None
         self.files = None
         self.dirs  = None
 
         checktool('mtn', abort=False)
 
         # test if there are any revisions
         self.rev = None
         try:
             self.getheads()
         except:
             raise norepo
         self.rev = rev
 
     def mtnrun(self, *args, **kwargs):
         kwargs['d'] = self.path
         return self.run0('automate', *args, **kwargs)
 
     def mtnloadmanifest(self, rev):
         if self.manifest_rev == rev:
             return
         self.manifest = self.mtnrun("get_manifest_of", rev).split("\n\n")
         self.manifest_rev = rev
         self.files = {}
         self.dirs = {}
 
         for e in self.manifest:
             m = self.file_re.match(e)
             if m:
                 attr = ""
                 name = m.group(1)
                 node = m.group(2)
                 if self.attr_execute_re.match(e):
                     attr += "x"
                 self.files[name] = (node, attr)
             m = self.dir_re.match(e)
             if m:
                 self.dirs[m.group(1)] = True
 
     def mtnisfile(self, name, rev):
         # a non-file could be a directory or a deleted or renamed file
         self.mtnloadmanifest(rev)
         try:
             self.files[name]
             return True
         except KeyError:
             return False
 
     def mtnisdir(self, name, rev):
         self.mtnloadmanifest(rev)
         try:
             self.dirs[name]
             return True
         except KeyError:
             return False
 
     def mtngetcerts(self, rev):
         certs = {"author":"<missing>", "date":"<missing>",
             "changelog":"<missing>", "branch":"<missing>"}
         cert_list = self.mtnrun("certs", rev).split('\n\n      key "')
         for e in cert_list:
             m = self.cert_re.match(e)
             if m:
                 name, value = m.groups()
                 value = value.replace(r'\"', '"')
                 value = value.replace(r'\\', '\\')
                 certs[name] = value
         # Monotone may have subsecond dates: 2005-02-05T09:39:12.364306
-        certs["date"] = certs["date"].split('.')[0]
+        # and all times are stored in UTC
+        certs["date"] = certs["date"].split('.')[0] + " UTC"
         return certs
 
     # implement the converter_source interface:
 
     def getheads(self):
         if not self.rev:
             return self.mtnrun("leaves").splitlines()
         else:
             return [self.rev]
 
     def getchanges(self, rev):
         #revision = self.mtncmd("get_revision %s" % rev).split("\n\n")
         revision = self.mtnrun("get_revision", rev).split("\n\n")
         files = {}
-        addedfiles = {}
+        ignoremove = {}
         renameddirs = []
         copies = {}
         for e in revision:
             m = self.add_file_re.match(e)
             if m:
                 files[m.group(1)] = rev
-                addedfiles[m.group(1)] = rev
+                ignoremove[m.group(1)] = rev
             m = self.patch_re.match(e)
             if m:
                 files[m.group(1)] = rev
             # Delete/rename is handled later when the convert engine
             # discovers an IOError exception from getfile,
             # but only if we add the "from" file to the list of changes.
             m = self.delete_re.match(e)
             if m:
                 files[m.group(1)] = rev
             m = self.rename_re.match(e)
             if m:
                 toname = m.group(2)
                 fromname = m.group(1)
                 if self.mtnisfile(toname, rev):
+                    ignoremove[toname] = 1
                     copies[toname] = fromname
                     files[toname] = rev
                     files[fromname] = rev
                 elif self.mtnisdir(toname, rev):
                     renameddirs.append((fromname, toname))
 
         # Directory renames can be handled only once we have recorded
         # all new files
         for fromdir, todir in renameddirs:
             renamed = {}
             for tofile in self.files:
-                if tofile in addedfiles:
+                if tofile in ignoremove:
                     continue
                 if tofile.startswith(todir + '/'):
                     renamed[tofile] = fromdir + tofile[len(todir):]
+                    # Avoid chained moves like:
+                    # d1(/a) => d3/d1(/a)
+                    # d2 => d3
+                    ignoremove[tofile] = 1
             for tofile, fromfile in renamed.items():
                 self.ui.debug (_("copying file in renamed directory "
                                  "from '%s' to '%s'")
                                % (fromfile, tofile), '\n')
                 files[tofile] = rev
                 copies[tofile] = fromfile
             for fromfile in renamed.values():
                 files[fromfile] = rev
 
         return (files.items(), copies)
 
     def getmode(self, name, rev):
         self.mtnloadmanifest(rev)
         try:
             node, attr = self.files[name]
             return attr
         except KeyError:
             return ""
 
     def getfile(self, name, rev):
         if not self.mtnisfile(name, rev):
             raise IOError() # file was deleted or renamed
         try:
             return self.mtnrun("get_file_of", name, r=rev)
         except:
             raise IOError() # file was deleted or renamed
 
     def getcommit(self, rev):
         certs   = self.mtngetcerts(rev)
         return commit(
             author=certs["author"],
             date=util.datestr(util.strdate(certs["date"], "%Y-%m-%dT%H:%M:%S")),
             desc=certs["changelog"],
             rev=rev,
             parents=self.mtnrun("parents", rev).splitlines(),
             branch=certs["branch"])
 
     def gettags(self):
         tags = {}
         for e in self.mtnrun("tags").split("\n\n"):
             m = self.tag_re.match(e)
             if m:
                 tags[m.group(1)] = m.group(2)
         return tags
 
     def getchangedfiles(self, rev, i):
         # This function is only needed to support --filemap
         # ... and we don't support that
         raise NotImplementedError()

tests/hghave

@@ -1,255 +1,264 b''
 #!/usr/bin/env python
 """Test the running system for features availability. Exit with zero
 if all features are there, non-zero otherwise. If a feature name is
 prefixed with "no-", the absence of feature is tested.
 """
 import optparse
 import os
 import re
 import sys
 import tempfile
 
 tempprefix = 'hg-hghave-'
 
 def matchoutput(cmd, regexp, ignorestatus=False):
     """Return True if cmd executes successfully and its output
     is matched by the supplied regular expression.
     """
     r = re.compile(regexp)
     fh = os.popen(cmd)
     s = fh.read()
     ret = fh.close()
     return (ignorestatus or ret is None) and r.search(s)
 
 def has_baz():
     return matchoutput('baz --version 2>&1', r'baz Bazaar version')
 
 def has_bzr():
     try:
         import bzrlib
         return bzrlib.__doc__ != None
     except ImportError:
         return False
 
+def has_bzr114():
+    try:
+        import bzrlib
+        return (bzrlib.__doc__ != None
+                and bzrlib.version_info[:2] == (1, 14))
+    except ImportError:
+        return False
+
 def has_cvs():
     re = r'Concurrent Versions System.*?server'
     return matchoutput('cvs --version 2>&1', re)
 
 def has_cvsps():
     return matchoutput('cvsps -h -q 2>&1', r'cvsps version', True)
 
 def has_darcs():
     return matchoutput('darcs', r'darcs version', True)
 
 def has_mtn():
     return matchoutput('mtn --version', r'monotone', True) and not matchoutput(
         'mtn --version', r'monotone 0\.(\d|[12]\d|3[01])[^\d]', True)
 
 def has_eol_in_paths():
     try:
         fd, path = tempfile.mkstemp(prefix=tempprefix, suffix='\n\r')
         os.close(fd)
         os.remove(path)
         return True
     except:
         return False
 
 def has_executablebit():
     fd, path = tempfile.mkstemp(prefix=tempprefix)
     os.close(fd)
     try:
         s = os.lstat(path).st_mode
         os.chmod(path, s | 0100)
         return (os.lstat(path).st_mode & 0100 != 0)
     finally:
         os.remove(path)
 
 def has_icasefs():
     # Stolen from mercurial.util
     fd, path = tempfile.mkstemp(prefix=tempprefix)
     os.close(fd)
     try:
         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)
             return s2 == s1
         except:
             return False
     finally:
         os.remove(path)
 
 def has_inotify():
     try:
         import hgext.inotify.linux.watcher
         return True
     except ImportError:
         return False
 
 def has_fifo():
     return hasattr(os, "mkfifo")
 
 def has_hotshot():
     try:
         # hotshot.stats tests hotshot and many problematic dependencies
         # like profile.
         import hotshot.stats
         return True
     except ImportError:
         return False
 
 def has_lsprof():
     try:
         import _lsprof
         return True
     except ImportError:
         return False
 
 def has_git():
     return matchoutput('git --version 2>&1', r'^git version')
 
 def has_svn():
     return matchoutput('svn --version 2>&1', r'^svn, version') and \
         matchoutput('svnadmin --version 2>&1', r'^svnadmin, version')
 
 def has_svn_bindings():
     try:
         import svn.core
         version = svn.core.SVN_VER_MAJOR, svn.core.SVN_VER_MINOR
         if version < (1, 4):
             return False
         return True
     except ImportError:
         return False
 
 def has_p4():
     return matchoutput('p4 -V', r'Rev\. P4/') and matchoutput('p4d -V', r'Rev\. P4D/')
 
 def has_symlink():
     return hasattr(os, "symlink")
 
 def has_tla():
     return matchoutput('tla --version 2>&1', r'The GNU Arch Revision')
 
 def has_unix_permissions():
     d = tempfile.mkdtemp(prefix=tempprefix, dir=".")
     try:
         fname = os.path.join(d, 'foo')
         for umask in (077, 007, 022):
             os.umask(umask)
             f = open(fname, 'w')
             f.close()
             mode = os.stat(fname).st_mode
             os.unlink(fname)
             if mode & 0777 != ~umask & 0666:
                 return False
         return True
     finally:
         os.rmdir(d)
 
 def has_pygments():
     try:
         import pygments
         return True
     except ImportError:
         return False
 
 def has_outer_repo():
     return matchoutput('hg root 2>&1', r'')
 
 checks = {
     "baz": (has_baz, "GNU Arch baz client"),
     "bzr": (has_bzr, "Canonical's Bazaar client"),
+    "bzr114": (has_bzr114, "Canonical's Bazaar client >= 1.14"),
     "cvs": (has_cvs, "cvs client/server"),
     "cvsps": (has_cvsps, "cvsps utility"),
     "darcs": (has_darcs, "darcs client"),
     "eol-in-paths": (has_eol_in_paths, "end-of-lines in paths"),
     "execbit": (has_executablebit, "executable bit"),
     "fifo": (has_fifo, "named pipes"),
     "git": (has_git, "git command line client"),
     "hotshot": (has_hotshot, "python hotshot module"),
     "icasefs": (has_icasefs, "case insensitive file system"),
     "inotify": (has_inotify, "inotify extension support"),
     "lsprof": (has_lsprof, "python lsprof module"),
     "mtn": (has_mtn, "monotone client (> 0.31)"),
     "outer-repo": (has_outer_repo, "outer repo"),
     "p4": (has_p4, "Perforce server and client"),
     "pygments": (has_pygments, "Pygments source highlighting library"),
     "svn": (has_svn, "subversion client and admin tools"),
     "svn-bindings": (has_svn_bindings, "subversion python bindings"),
     "symlink": (has_symlink, "symbolic links"),
     "tla": (has_tla, "GNU Arch tla client"),
     "unix-permissions": (has_unix_permissions, "unix-style permissions"),
 }
 
 def list_features():
     for name, feature in checks.iteritems():
         desc = feature[1]
         print name + ':', desc
 
 def test_features():
     failed = 0
     for name, feature in checks.iteritems():
         check, _ = feature
         try:
             check()
         except Exception, e:
             print "feature %s failed:  %s" % (name, e)
             failed += 1
     return failed
 
 parser = optparse.OptionParser("%prog [options] [features]")
 parser.add_option("--test-features", action="store_true",
                   help="test available features")
 parser.add_option("--list-features", action="store_true",
                   help="list available features")
 parser.add_option("-q", "--quiet", action="store_true",
                   help="check features silently")
 
 if __name__ == '__main__':
     options, args = parser.parse_args()
     if options.list_features:
         list_features()
         sys.exit(0)
 
     if options.test_features:
         sys.exit(test_features())
 
     quiet = options.quiet
 
     failures = 0
 
     def error(msg):
         global failures
         if not quiet:
             sys.stderr.write(msg + '\n')
         failures += 1
 
     for feature in args:
         negate = feature.startswith('no-')
         if negate:
             feature = feature[3:]
 
         if feature not in checks:
             error('skipped: unknown feature: ' + feature)
             continue
 
         check, desc = checks[feature]
         try:
             available = check()
         except Exception, e:
             error('hghave check failed: ' + feature)
             continue
 
         if not negate and not available:
             error('skipped: missing feature: ' + desc)
         elif negate and available:
             error('skipped: system supports %s' % desc)
 
     if failures != 0:
         sys.exit(1)
 
 

tests/test-convert-mtn

@@ -1,112 +1,146 b''
 #!/bin/sh
 
 "$TESTDIR/hghave" mtn || exit 80
 
 # Monotone directory is called .monotone on *nix and monotone
 # on Windows. Having a variable here ease test patching.
 mtndir=.monotone
 echo "[extensions]" >> $HGRCPATH
 echo "convert=" >> $HGRCPATH
 echo 'hgext.graphlog =' >> $HGRCPATH
 
 HOME=`pwd`/do_not_use_HOME_mtn; export HOME
 # Windows version of monotone home
 APPDATA=$HOME; export APPDATA
 
 echo % tedious monotone keys configuration
 # The /dev/null redirection is necessary under Windows, or
 # it complains about home directory permissions
 mtn --quiet genkey [e-mail] 1>/dev/null 2>&1 <<EOF
 passphrase
 passphrase
 EOF
 cat >> $HOME/$mtndir/monotonerc <<EOF
 function get_passphrase(keypair_id)
     return "passphrase"
 end
 EOF
 
 echo % create monotone repository
 mtn db init --db=repo.mtn
 mtn --db=repo.mtn --branch=com.selenic.test setup workingdir
 cd workingdir
 echo a > a
 mkdir dir
 echo b > dir/b
 echo d > dir/d
 python -c 'file("bin", "wb").write("a\\x00b")'
 echo c > c
 mtn add a dir/b dir/d c bin
 mtn ci -m initialize
 echo % update monotone working directory
 mtn mv a dir/a
 echo a >> dir/a
 echo b >> dir/b
 mtn drop c
 python -c 'file("bin", "wb").write("b\\x00c")'
 mtn ci -m update1
 cd ..
 
 echo % convert once
 hg convert -s mtn repo.mtn
 
 cd workingdir
 echo e > e
 mtn add e
 mtn drop dir/b
 mtn mv bin bin2
 mtn ci -m 'update2 "with" quotes'
 echo '% test directory move'
 mkdir -p dir1/subdir1
 mkdir -p dir1/subdir2_other
 echo file1 > dir1/subdir1/file1
 echo file2 > dir1/subdir2_other/file1
 mtn add dir1/subdir1/file1 dir1/subdir2_other/file1
 mtn ci -m createdir1
 mtn rename dir1/subdir1 dir1/subdir2
 mtn ci -m movedir1
 echo '% test subdirectory move'
 mtn mv dir dir2
 echo newfile > dir2/newfile
 mtn drop dir2/d
 mtn add dir2/newfile
 mtn ci -m movedir
 # Test directory removal with empty directory
 mkdir dir2/dir
 mkdir dir2/dir/subdir
 echo f > dir2/dir/subdir/f
 mkdir dir2/dir/emptydir
 mtn add --quiet -R dir2/dir
 mtn ci -m emptydir
 mtn drop -R dir2/dir
 mtn ci -m dropdirectory
+echo '% test directory and file move'
+mkdir -p dir3/d1
+echo a > dir3/a
+mtn add dir3/a dir3/d1
+mtn ci -m dirfilemove
+mtn mv dir3/a dir3/d1/a
+mtn mv dir3/d1 dir3/d2
+mtn ci -m dirfilemove2
+echo '% test directory move into another directory move'
+mkdir dir4
+mkdir dir5
+echo a > dir4/a
+mtn add dir4/a dir5
+mtn ci -m dirdirmove
+mtn mv dir5 dir6
+mtn mv dir4 dir6/dir4
+mtn ci -m dirdirmove2
+echo '% test diverging directory moves'
+mkdir -p dir7/dir9/dir8
+echo a > dir7/dir9/dir8/a
+echo b > dir7/dir9/b
+echo c > dir7/c
+mtn add -R dir7
+mtn ci -m divergentdirmove
+mtn mv dir7 dir7-2
+mtn mv dir7-2/dir9 dir9-2
+mtn mv dir9-2/dir8 dir8-2
+mtn ci -m divergentdirmove2
 cd ..
 
 echo % convert incrementally
 hg convert -s mtn repo.mtn
 
 glog()
 {
     hg glog --template '#rev# "#desc|firstline#" files: #files#\n' "$@"
 }
 
 cd repo.mtn-hg
 hg up -C
 glog
 echo % manifest
 hg manifest
 echo % contents
 cat dir2/a
 test -d dir2/dir && echo 'removed dir2/dir is still there!'
 
 echo % file move
 hg log -v -C -r 1 | grep copies
 echo % check directory move
 hg manifest -r 4
 test -d dir1/subdir2 || echo 'new dir1/subdir2 does not exist!'
 test -d dir1/subdir1 && echo 'renamed dir1/subdir1 is still there!'
 hg log -v -C -r 4 | grep copies
 echo % check file remove with directory move
 hg manifest -r 5
+echo % check file move with directory move
+hg manifest -r 9
+echo % check file directory directory move
+hg manifest -r 11
+echo % check divergent directory moves
+hg manifest -r 13
 exit 0
 

tests/test-convert-mtn.out

@@ -1,110 +1,199 b''
 % tedious monotone keys configuration
 % create monotone repository
 mtn: adding a to workspace manifest
 mtn: adding bin to workspace manifest
 mtn: adding c to workspace manifest
 mtn: adding dir to workspace manifest
 mtn: adding dir/b to workspace manifest
 mtn: adding dir/d to workspace manifest
 mtn: beginning commit on branch 'com.selenic.test'
 mtn: committed revision 0f6e5e4f2e7d2a8ef312408f57618abf026afd90
 % update monotone working directory
 mtn: skipping dir, already accounted for in workspace
 mtn: renaming a to dir/a in workspace manifest
 mtn: dropping c from workspace manifest
 mtn: beginning commit on branch 'com.selenic.test'
 mtn: committed revision 51d0a982464573a2a2cf5ee2c9219c652aaebeff
 % convert once
 assuming destination repo.mtn-hg
 initializing destination repo.mtn-hg repository
 scanning source...
 sorting...
 converting...
 1 initialize
 0 update1
 mtn: adding e to workspace manifest
 mtn: dropping dir/b from workspace manifest
 mtn: renaming bin to bin2 in workspace manifest
 mtn: beginning commit on branch 'com.selenic.test'
 mtn: committed revision ebe58335d85d8cb176b6d0a12be04f5314b998da
 % test directory move
 mtn: adding dir1 to workspace manifest
 mtn: adding dir1/subdir1 to workspace manifest
 mtn: adding dir1/subdir1/file1 to workspace manifest
 mtn: adding dir1/subdir2_other to workspace manifest
 mtn: adding dir1/subdir2_other/file1 to workspace manifest
 mtn: beginning commit on branch 'com.selenic.test'
 mtn: committed revision a8d62bc04fee4d2936d28e98bbcc81686dd74306
 mtn: skipping dir1, already accounted for in workspace
 mtn: renaming dir1/subdir1 to dir1/subdir2 in workspace manifest
 mtn: beginning commit on branch 'com.selenic.test'
 mtn: committed revision 2c3d241bbbfe538b1b51d910f5676407e3f4d3a6
 % test subdirectory move
 mtn: renaming dir to dir2 in workspace manifest
 mtn: dropping dir2/d from workspace manifest
 mtn: adding dir2/newfile to workspace manifest
 mtn: beginning commit on branch 'com.selenic.test'
 mtn: committed revision fdb5a02dae8bfce3a79b3393680af471016e1b4c
 mtn: beginning commit on branch 'com.selenic.test'
 mtn: committed revision 8bbf76d717001d24964e4604739fdcd0f539fc88
 mtn: dropping dir2/dir/subdir/f from workspace manifest
 mtn: dropping dir2/dir/subdir from workspace manifest
 mtn: dropping dir2/dir/emptydir from workspace manifest
 mtn: dropping dir2/dir from workspace manifest
 mtn: beginning commit on branch 'com.selenic.test'
 mtn: committed revision 2323d4bc324e6c82628dc04d47a9fd32ad24e322
+% test directory and file move
+mtn: adding dir3 to workspace manifest
+mtn: adding dir3/a to workspace manifest
+mtn: adding dir3/d1 to workspace manifest
+mtn: beginning commit on branch 'com.selenic.test'
+mtn: committed revision 47b192f720faa622f48c68d1eb075b26d405aa8b
+mtn: skipping dir3/d1, already accounted for in workspace
+mtn: renaming dir3/a to dir3/d1/a in workspace manifest
+mtn: skipping dir3, already accounted for in workspace
+mtn: renaming dir3/d1 to dir3/d2 in workspace manifest
+mtn: beginning commit on branch 'com.selenic.test'
+mtn: committed revision 8b543a400d3ee7f6d4bb1835b9b9e3747c8cb632
+% test directory move into another directory move
+mtn: adding dir4 to workspace manifest
+mtn: adding dir4/a to workspace manifest
+mtn: adding dir5 to workspace manifest
+mtn: beginning commit on branch 'com.selenic.test'
+mtn: committed revision 466e0b2afc7a55aa2b4ab2f57cb240bb6cd66fc7
+mtn: renaming dir5 to dir6 in workspace manifest
+mtn: skipping dir6, already accounted for in workspace
+mtn: renaming dir4 to dir6/dir4 in workspace manifest
+mtn: beginning commit on branch 'com.selenic.test'
+mtn: committed revision 3d1f77ebad0c23a5d14911be3b670f990991b749
+% test diverging directory moves
+mtn: adding dir7 to workspace manifest
+mtn: adding dir7/c to workspace manifest
+mtn: adding dir7/dir9 to workspace manifest
+mtn: adding dir7/dir9/b to workspace manifest
+mtn: adding dir7/dir9/dir8 to workspace manifest
+mtn: adding dir7/dir9/dir8/a to workspace manifest
+mtn: beginning commit on branch 'com.selenic.test'
+mtn: committed revision 08a08511f18b428d840199b062de90d0396bc2ed
+mtn: renaming dir7 to dir7-2 in workspace manifest
+mtn: renaming dir7-2/dir9 to dir9-2 in workspace manifest
+mtn: renaming dir9-2/dir8 to dir8-2 in workspace manifest
+mtn: beginning commit on branch 'com.selenic.test'
+mtn: committed revision 4a736634505795f17786fffdf2c9cbf5b11df6f6
 % convert incrementally
 assuming destination repo.mtn-hg
 scanning source...
 sorting...
 converting...
-5 update2 "with" quotes
-4 createdir1
-3 movedir1
-2 movedir
-1 emptydir
-0 dropdirectory
-6 files updated, 0 files merged, 0 files removed, 0 files unresolved
-@  7 "dropdirectory" files: dir2/dir/subdir/f
+11 update2 "with" quotes
+10 createdir1
+9 movedir1
+8 movedir
+7 emptydir
+6 dropdirectory
+5 dirfilemove
+4 dirfilemove2
+3 dirdirmove
+2 dirdirmove2
+1 divergentdirmove
+0 divergentdirmove2
+11 files updated, 0 files merged, 0 files removed, 0 files unresolved
+@  13 "divergentdirmove2" files: dir7-2/c dir7/c dir7/dir9/b dir7/dir9/dir8/a dir8-2/a dir9-2/b
+|
+o  12 "divergentdirmove" files: dir7/c dir7/dir9/b dir7/dir9/dir8/a
+|
+o  11 "dirdirmove2" files: dir4/a dir6/dir4/a
+|
+o  10 "dirdirmove" files: dir4/a
+|
+o  9 "dirfilemove2" files: dir3/a dir3/d2/a
+|
+o  8 "dirfilemove" files: dir3/a
+|
+o  7 "dropdirectory" files: dir2/dir/subdir/f
 |
 o  6 "emptydir" files: dir2/dir/subdir/f
 |
 o  5 "movedir" files: dir/a dir/d dir2/a dir2/newfile
 |
 o  4 "movedir1" files: dir1/subdir1/file1 dir1/subdir2/file1
 |
 o  3 "createdir1" files: dir1/subdir1/file1 dir1/subdir2_other/file1
 |
 o  2 "update2 "with" quotes" files: bin bin2 dir/b e
 |
 o  1 "update1" files: a bin c dir/a dir/b
 |
 o  0 "initialize" files: a bin c dir/b dir/d
 
 % manifest
 bin2
 dir1/subdir2/file1
 dir1/subdir2_other/file1
 dir2/a
 dir2/newfile
+dir3/d2/a
+dir6/dir4/a
+dir7-2/c
+dir8-2/a
+dir9-2/b
 e
 % contents
 a
 a
 % file move
 copies:      dir/a (a)
 % check directory move
 bin2
 dir/a
 dir/d
 dir1/subdir2/file1
 dir1/subdir2_other/file1
 e
 copies:      dir1/subdir2/file1 (dir1/subdir1/file1)
 % check file remove with directory move
 bin2
 dir1/subdir2/file1
 dir1/subdir2_other/file1
 dir2/a
 dir2/newfile
 e
+% check file move with directory move
+bin2
+dir1/subdir2/file1
+dir1/subdir2_other/file1
+dir2/a
+dir2/newfile
+dir3/d2/a
+e
+% check file directory directory move
+bin2
+dir1/subdir2/file1
+dir1/subdir2_other/file1
+dir2/a
+dir2/newfile
+dir3/d2/a
+dir6/dir4/a
+e
+% check divergent directory moves
+bin2
+dir1/subdir2/file1
+dir1/subdir2_other/file1
+dir2/a
+dir2/newfile
+dir3/d2/a
+dir6/dir4/a
+dir7-2/c
+dir8-2/a
+dir9-2/b
+e