convert/bzr: convert all branches (issue3229) (BC)

Instead of opening the target bzr checkout as a single branch, we try to open
it as a repository. This has the following effects:
- All branches are now converted
- bzr branch names are preserved. Previously, the selected branch was always
  converted as 'default'. Branches without a name or 'trunk' are mapped to
  'default branch.
- Lightweight checkouts are no longer supported. Maybe they can be, I did not
  try to fix that at all.

Implementation notes:
- This was a quick fix, I have no knowledge of bzr API besides browsing 2.0.3
  sources.
- The fix was only tested on OSX against bzr 2.4.2.
- Tags discovery does not handle collisions. I have no idea how tags work in
  bzr so maybe such collisions are not possible.

hgext/convert/bzr.py

@@ -1,265 +1,280
 # bzr.py - bzr support for the convert extension
 #
 #  Copyright 2008, 2009 Marek Kubica <[e-mail]> and others
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 # 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',
         'ElementPath',
     ])
 
 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 import bzrdir, 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 repository')
                          % path)
 
         try:
             # access bzrlib stuff
-            branch
+            bzrdir
         except NameError:
             raise NoRepo(_('Bazaar modules could not be loaded'))
 
         path = os.path.abspath(path)
         self._checkrepotype(path)
-        self.branch = branch.Branch.open(path)
-        self.sourcerepo = self.branch.repository
+        try:
+            self.sourcerepo = bzrdir.BzrDir.open(path).open_repository()
+        except errors.NoRepositoryPresent:
+            raise NoRepo(_('%s does not look like a Bazaar repository')
+                         % path)
         self._parentids = {}
 
     def _checkrepotype(self, path):
         # Lightweight checkouts detection is informational but probably
         # fragile at API level. It should not terminate the conversion.
         try:
             from bzrlib import bzrdir
             dir = bzrdir.BzrDir.open_containing(path)[0]
             try:
                 tree = dir.open_workingtree(recommend_upgrade=False)
                 branch = tree.branch
             except (errors.NoWorkingTree, errors.NotLocalUrl):
                 tree = None
                 branch = dir.open_branch()
             if (tree is not None and tree.bzrdir.root_transport.base !=
                 branch.bzrdir.root_transport.base):
                 self.ui.warn(_('warning: lightweight checkouts may cause '
                                'conversion failures, try with a regular '
                                'branch instead.\n'))
         except:
             self.ui.note(_('bzr source type could not be determined\n'))
 
     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()]
+            heads = sorted([b.last_revision()
+                            for b in self.sourcerepo.find_branches()])
+        else:
+            revid = None
+            for branch in self.sourcerepo.find_branches():
         try:
             r = RevisionSpec.from_string(self.rev)
-            info = r.in_history(self.branch)
+                    info = r.in_history(branch)
         except errors.BzrError:
-            raise util.Abort(_('%s is not a valid revision in current branch')
-                             % self.rev)
-        return [info.rev_id]
+                    pass
+                revid = info.rev_id
+            if revid is None:
+                raise util.Abort(_('%s is not a valid revision') % self.rev)
+            heads = [revid]
+        return heads
 
     def getfile(self, name, rev):
         revtree = self.sourcerepo.revision_tree(rev)
         fileid = revtree.path2id(name.decode(self.encoding or 'utf-8'))
         kind = None
         if fileid is not None:
             kind = revtree.kind(fileid)
         if kind not in supportedkinds:
             # the file is not available anymore - was deleted
             raise IOError(_('%s is not available in %s anymore') %
                     (name, rev))
         mode = self._modecache[(name, rev)]
         if kind == 'symlink':
             target = revtree.get_symlink_target(fileid)
             if target is None:
                 raise util.Abort(_('%s.%s symlink has no target')
                                  % (name, rev))
             return target, mode
         else:
             sio = revtree.get_file(fileid)
             return sio.read(), mode
 
     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
 
+        branch = self.recode(rev.properties.get('branch-nick', u'default'))
+        if branch == 'trunk':
+            branch = 'default'
         return commit(parents=parents,
                 date='%d %d' % (rev.timestamp, -rev.timezone),
                 author=self.recode(rev.committer),
                 desc=self.recode(rev.message),
+                branch=branch,
                 rev=version)
 
     def gettags(self):
-        if not self.branch.supports_tags():
+        bytetags = {}
+        for branch in self.sourcerepo.find_branches():
+            if not branch.supports_tags():
             return {}
-        tagdict = self.branch.tags.get_tag_dict()
-        bytetags = {}
+            tagdict = branch.tags.get_tag_dict()
         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)
         if i is not None:
             parentid = self._parentids[rev][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 = {}
         seen = set()
         # Process the entries by reverse lexicographic name order to
         # handle nested renames correctly, most specific first.
         curchanges = sorted(current.iter_changes(origin),
                             key=lambda c: c[1][0] or c[1][1],
                             reverse=True)
         for (fileid, paths, changed_content, versioned, parent, name,
             kind, executable) in curchanges:
 
             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 kind[0] == 'directory' and None not in paths:
                     renaming = 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)
                         if frompath in seen:
                             # Already handled by a more specific change entry
                             # This is important when you have:
                             # a => b
                             # a/c => a/c
                             # Here a/c must not be renamed into b/c
                             continue
                         seen.add(frompath)
                         if not renaming:
                             continue
                         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 = paths
             if path is not None:
                 path = self.recode(path)
             if topath is not None:
                 topath = self.recode(topath)
             seen.add(path or topath)
 
             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 'l')
                     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

tests/bzr-definitions

@@ -1,19 +1,19
 # this file holds the definitions that are used in various bzr tests
 
 "$TESTDIR/hghave" bzr || exit 80
 
 TERM=dumb; export TERM
 echo '[extensions]' >> $HGRCPATH
 echo 'convert = ' >> $HGRCPATH
 echo 'hgext.graphlog = ' >> $HGRCPATH
 
 glog()
 {
-    hg glog --template '{rev} "{desc|firstline}" files: {files}\n' "$@"
+    hg glog --template '{rev}@{branch} "{desc|firstline}" files: {files}\n' "$@"
 }
 
 manifest()
 {
     echo "% manifest of $2"
     hg -R $1 manifest -v -r $2
 }

tests/test-convert-bzr-ghosts.t

@@ -1,36 +1,36
 
   $ . "$TESTDIR/bzr-definitions"
   $ cat > ghostcreator.py <<EOF
   > import sys
   > from bzrlib import workingtree
   > wt = workingtree.WorkingTree.open('.')
   > 
   > message, ghostrev = sys.argv[1:]
   > wt.set_parent_ids(wt.get_parent_ids() + [ghostrev])
   > wt.commit(message)
   > EOF
 
 ghost revisions
 
   $ mkdir test-ghost-revisions
   $ cd test-ghost-revisions
   $ bzr init -q source
   $ cd source
   $ echo content > somefile
   $ bzr add -q somefile
   $ bzr commit -q -m 'Initial layout setup'
   $ echo morecontent >> somefile
   $ python ../../ghostcreator.py 'Commit with ghost revision' ghostrev
   $ cd ..
   $ hg convert source source-hg
   initializing destination source-hg repository
   scanning source...
   sorting...
   converting...
   1 Initial layout setup
   0 Commit with ghost revision
   $ glog -R source-hg
-  o  1 "Commit with ghost revision" files: somefile
+  o  1@source "Commit with ghost revision" files: somefile
   |
-  o  0 "Initial layout setup" files: somefile
+  o  0@source "Initial layout setup" files: somefile
   

tests/test-convert-bzr-merges.t

@@ -1,68 +1,68
 N.B. bzr 1.13 has a bug that breaks this test.  If you see this
 test fail, check your bzr version.  Upgrading to bzr 1.13.1
 should fix it.
 
   $ . "$TESTDIR/bzr-definitions"
 
 test multiple merges at once
 
   $ mkdir test-multimerge
   $ cd test-multimerge
   $ bzr init -q source
   $ cd source
   $ echo content > file
   $ bzr add -q file
   $ bzr commit -q -m 'Initial add'
   $ cd ..
   $ bzr branch -q source source-branch1
   $ cd source-branch1
   $ echo morecontent >> file
   $ echo evenmorecontent > file-branch1
   $ bzr add -q file-branch1
   $ bzr commit -q -m 'Added branch1 file'
   $ cd ../source
   $ sleep 1
   $ echo content > file-parent
   $ bzr add -q file-parent
   $ bzr commit -q -m 'Added parent file'
   $ cd ..
   $ bzr branch -q source source-branch2
   $ cd source-branch2
   $ echo somecontent > file-branch2
   $ bzr add -q file-branch2
   $ bzr commit -q -m 'Added brach2 file'
   $ sleep 1
   $ cd ../source
   $ bzr merge -q ../source-branch1
   $ bzr merge -q --force ../source-branch2
   $ bzr commit -q -m 'Merged branches'
   $ cd ..
   $ hg convert --datesort source source-hg
   initializing destination source-hg repository
   scanning source...
   sorting...
   converting...
   4 Initial add
   3 Added branch1 file
   2 Added parent file
   1 Added brach2 file
   0 Merged branches
   $ glog -R source-hg
-  o    5 "(octopus merge fixup)" files:
+  o    5@source "(octopus merge fixup)" files:
   |\
-  | o    4 "Merged branches" files: file-branch2
+  | o    4@source "Merged branches" files: file-branch2
   | |\
-  o---+  3 "Added brach2 file" files: file-branch2
+  o---+  3@source-branch2 "Added brach2 file" files: file-branch2
    / /
-  | o  2 "Added parent file" files: file-parent
+  | o  2@source "Added parent file" files: file-parent
   | |
-  o |  1 "Added branch1 file" files: file file-branch1
+  o |  1@source-branch1 "Added branch1 file" files: file file-branch1
   |/
-  o  0 "Initial add" files: file
+  o  0@source "Initial add" files: file
   
   $ manifest source-hg tip
   % manifest of tip
   644   file
   644   file-branch1
   644   file-branch2
   644   file-parent

tests/test-convert-bzr.t

@@ -1,210 +1,238
   $ "$TESTDIR/hghave" symlink execbit || exit 80
 
   $ . "$TESTDIR/bzr-definitions"
 
 create and rename on the same file in the same step
 
   $ mkdir test-createandrename
   $ cd test-createandrename
   $ bzr init -q source
   $ cd source
   $ echo a > a
   $ echo c > c
   $ echo e > e
   $ bzr add -q a c e
   $ bzr commit -q -m 'Initial add: a, c, e'
   $ bzr mv a b
   a => b
   $ bzr mv c d
   c => d
   $ bzr mv e f
   e => f
   $ echo a2 >> a
   $ mkdir e
   $ bzr add -q a e
   $ bzr commit -q -m 'rename a into b, create a, rename c into d'
   $ cd ..
   $ hg convert source source-hg
   initializing destination source-hg repository
   scanning source...
   sorting...
   converting...
   1 Initial add: a, c, e
   0 rename a into b, create a, rename c into d
   $ glog -R source-hg
-  o  1 "rename a into b, create a, rename c into d" files: a b c d e f
+  o  1@source "rename a into b, create a, rename c into d" files: a b c d e f
   |
-  o  0 "Initial add: a, c, e" files: a c e
+  o  0@source "Initial add: a, c, e" files: a c e
   
 
 manifest
 
   $ hg manifest -R source-hg -r tip
   a
   b
   d
   f
 
 test --rev option
 
   $ hg convert -r 1 source source-1-hg
   initializing destination source-1-hg repository
   scanning source...
   sorting...
   converting...
   0 Initial add: a, c, e
   $ glog -R source-1-hg
-  o  0 "Initial add: a, c, e" files: a c e
+  o  0@source "Initial add: a, c, e" files: a c e
   
 
 test with filemap
 
   $ cat > filemap <<EOF
   > exclude a
   > EOF
   $ hg convert --filemap filemap source source-filemap-hg
   initializing destination source-filemap-hg repository
   scanning source...
   sorting...
   converting...
   1 Initial add: a, c, e
   0 rename a into b, create a, rename c into d
   $ hg -R source-filemap-hg manifest -r tip
   b
   d
   f
 
 convert from lightweight checkout
 
   $ bzr checkout --lightweight source source-light
-  $ hg convert source-light source-light-hg
+  $ hg convert -s bzr source-light source-light-hg
   initializing destination source-light-hg repository
   warning: lightweight checkouts may cause conversion failures, try with a regular branch instead.
-  scanning source...
-  sorting...
-  converting...
-  1 Initial add: a, c, e
-  0 rename a into b, create a, rename c into d
-
-lightweight manifest
-
-  $ hg manifest -R source-light-hg -r tip
-  a
-  b
-  d
-  f
+  $TESTTMP/test-createandrename/source-light does not look like a Bazaar repository
+  abort: source-light: missing or unsupported repository
+  [255]
 
 extract timestamps that look just like hg's {date|isodate}:
 yyyy-mm-dd HH:MM zzzz (no seconds!)
 compare timestamps
 
   $ cd source
   $ bzr log | \
   >   sed '/timestamp/!d;s/.\{15\}\([0-9: -]\{16\}\):.. \(.[0-9]\{4\}\)/\1 \2/' \
   >   > ../bzr-timestamps
   $ cd ..
   $ hg -R source-hg log --template "{date|isodate}\n" > hg-timestamps
   $ diff -u bzr-timestamps hg-timestamps
   $ cd ..
 
 merge
 
   $ mkdir test-merge
   $ cd test-merge
   $ cat > helper.py <<EOF
   > import sys
   > from bzrlib import workingtree
   > wt = workingtree.WorkingTree.open('.')
   > 
   > message, stamp = sys.argv[1:]
   > wt.commit(message, timestamp=int(stamp))
   > EOF
   $ bzr init -q source
   $ cd source
   $ echo content > a
   $ echo content2 > b
   $ bzr add -q a b
   $ bzr commit -q -m 'Initial add'
   $ cd ..
   $ bzr branch -q source source-improve
   $ cd source
   $ echo more >> a
   $ python ../helper.py 'Editing a' 100
   $ cd ../source-improve
   $ echo content3 >> b
   $ python ../helper.py 'Editing b' 200
   $ cd ../source
   $ bzr merge -q ../source-improve
   $ bzr commit -q -m 'Merged improve branch'
   $ cd ..
   $ hg convert --datesort source source-hg
   initializing destination source-hg repository
   scanning source...
   sorting...
   converting...
   3 Initial add
   2 Editing a
   1 Editing b
   0 Merged improve branch
   $ glog -R source-hg
-  o    3 "Merged improve branch" files:
+  o    3@source "Merged improve branch" files:
   |\
-  | o  2 "Editing b" files: b
+  | o  2@source-improve "Editing b" files: b
   | |
-  o |  1 "Editing a" files: a
+  o |  1@source "Editing a" files: a
   |/
-  o  0 "Initial add" files: a b
+  o  0@source "Initial add" files: a b
   
   $ cd ..
 
 symlinks and executable files
 
   $ mkdir test-symlinks
   $ cd test-symlinks
   $ bzr init -q source
   $ cd source
   $ touch program
   $ chmod +x program
   $ ln -s program altname
   $ mkdir d
   $ echo a > d/a
   $ ln -s a syma
   $ bzr add -q altname program syma d/a
   $ bzr commit -q -m 'Initial setup'
   $ touch newprog
   $ chmod +x newprog
   $ rm altname
   $ ln -s newprog altname
   $ chmod -x program
   $ bzr add -q newprog
   $ bzr commit -q -m 'Symlink changed, x bits changed'
   $ cd ..
   $ hg convert source source-hg
   initializing destination source-hg repository
   scanning source...
   sorting...
   converting...
   1 Initial setup
   0 Symlink changed, x bits changed
   $ manifest source-hg 0
   % manifest of 0
   644 @ altname
   644   d/a
   755 * program
   644 @ syma
   $ manifest source-hg tip
   % manifest of tip
   644 @ altname
   644   d/a
   755 * newprog
   644   program
   644 @ syma
   $ cd source-hg
 
 test the symlinks can be recreated
 
   $ hg up
   5 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg cat syma; echo
   a
 
+Multiple branches
+
+  $ bzr init-repo -q --no-trees repo
+  $ bzr init -q repo/trunk
+  $ bzr co repo/trunk repo-trunk
+  $ cd repo-trunk
+  $ echo a > a
+  $ bzr add a
+  adding a
+  $ bzr ci -qm adda --commit-time '2012-01-01 00:00:01 +0000'
+  $ bzr switch -b branch
+  Tree is up to date at revision 1.
+  Switched to branch: *repo/branch/ (glob)
+  $ echo b > b
+  $ bzr add b
+  adding b
+  $ bzr ci -qm addb --commit-time '2012-01-01 00:00:02 +0000'
+  $ bzr switch --force ../repo/trunk
+  Updated to revision 1.
+  Switched to branch: */repo/trunk/ (glob)
+  $ echo a >> a
+  $ bzr ci -qm changea --commit-time '2012-01-01 00:00:03 +0000'
+  $ cd ..
+  $ hg convert --datesort repo repo-bzr
+  initializing destination repo-bzr repository
+  scanning source...
+  sorting...
+  converting...
+  2 adda
+  1 addb
+  0 changea
+  $ (cd repo-bzr; glog)
+  o  2@default "changea" files: a
+  |
+  | o  1@branch "addb" files: b
+  |/
+  o  0@default "adda" files: a
+