convert/bzr: handle empty bzr repositories (issue3233)

hgext/convert/bzr.py

@@ -1,280 +1,282 b''
 # 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 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
             bzrdir
         except NameError:
             raise NoRepo(_('Bazaar modules could not be loaded'))
 
         path = os.path.abspath(path)
         self._checkrepotype(path)
         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:
             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(branch)
                 except errors.BzrError:
                     pass
                 revid = info.rev_id
             if revid is None:
                 raise util.Abort(_('%s is not a valid revision') % self.rev)
             heads = [revid]
+        # Empty repositories return 'null:', which cannot be retrieved
+        heads = [h for h in heads if h != 'null:']
         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):
         bytetags = {}
         for branch in self.sourcerepo.find_branches():
             if not branch.supports_tags():
                 return {}
             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/test-convert-bzr.t

@@ -1,238 +1,248 b''
   $ "$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
+
+test empty repo conversion (issue3233)
+
+  $ hg convert source source-hg
+  initializing destination source-hg repository
+  scanning source...
+  sorting...
+  converting...
+
+back to the rename stuff
+
   $ 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@source "rename a into b, create a, rename c into d" files: a b c d e f
   |
   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@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 -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.
   $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@source "Merged improve branch" files:
   |\
   | o  2@source-improve "Editing b" files: b
   | |
   o |  1@source "Editing a" files: a
   |/
   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