Merge lp:~jelmer/bzr-hg/sprout into lp:~launchpad-pqm/bzr-hg/devel

[Jelmer Vernooij]

Provide a custom sprout implementation. Fixes compatibility with newer versions of bzr.

Unmerged revisions

=== modified file '.bzrignore'
--- .bzrignore	2009-05-21 15:53:00 +0000
+++ .bzrignore	2011-03-23 21:41:04 +0000
@@ -1,3 +1,4 @@
 *.pyc
 build
 .plugins
+.testrepository
 
=== added file '.testr.conf'
--- .testr.conf	1970-01-01 00:00:00 +0000
+++ .testr.conf	2011-03-23 21:41:04 +0000
@@ -0,0 +1,4 @@
+[DEFAULT]
+test_command=BZR_PLUGINS_AT=hg@`pwd` bzr selftest ^bzrlib.plugins.hg. Hg Mercurial --subunit $IDOPTION $LISTOPT
+test_id_option=--load-list $IDFILE
+test_list_option=--list
 
=== modified file 'HACKING'
--- HACKING	2009-10-10 01:17:00 +0000
+++ HACKING	2011-03-23 21:41:04 +0000
@@ -3,8 +3,7 @@
 
 Unit testing
 ~~~~~~~~~~~~
-To run the bzr-hg testsuite, simply run 
-'bzr selftest --starting-with=bazaar.plugins.hg' or 
+To run the bzr-hg testsuite, simply run 'bzr selftest -s bp.hg' or
 run 'make check' in the top-level bzr-hg directory.
 
 Unavailable bzrlib API's
@@ -24,4 +23,3 @@
 Coding Style, etc
 ~~~~~~~~~~~~~~~~~
 Please refer to HACKING in the Bazaar source distribution.
-
 
=== modified file 'Makefile'
--- Makefile	2010-07-28 16:15:17 +0000
+++ Makefile	2011-03-23 21:41:04 +0000
@@ -6,7 +6,7 @@
 CTAGS ?= ctags
 PYLINT ?= pylint
 RST2HTML ?= rst2html
-TESTS ?= bzrlib.tests.per_foreign_vcs.*Hg bzrlib.plugins.hg
+TESTS ?= -s bt.per_foreign_vcs.*Hg -s bp.hg
 
 all:: build 
 
 
=== modified file 'NEWS'
--- NEWS	2010-08-14 00:41:20 +0000
+++ NEWS	2011-03-23 21:41:04 +0000
@@ -27,9 +27,14 @@
   * Put idmap information in a bzr-hg-specific directory. (Jelmer Vernooij,
     #599397)
 
+  * Add basic support for tags. (Jelmer Vernooij)
+
+  * Check for Mercurial repository before checking for Bazaar repository.
+    (Jelmer Vernooij, #674581, #688455)
+
  BUG FIXES
 
-  * Mark as compatible with Bazaar 2.1. (Jelmer Vernooij)
+  * Mark as compatible with Bazaar 2.1, 2.2, 2.3 and 2.4. (Jelmer Vernooij)
 
   * Check for Mercurial version before attempting to import it.
     (#432100, Jelmer Vernooij)
@@ -38,7 +43,7 @@
 
   * Remove empty directories during fetch. (Jelmer Vernooij)
 
-  * Mark Mercurial 1.6 as supported, drop support for earlier versions.
+  * Mark Mercurial 1.6, 1.7 and 1.8 as supported, drop support for earlier versions.
     (#486899, Jelmer Vernooij)
 
   * Don't warn about development versions of Mercurial. (#492292, Jelmer 
@@ -59,6 +64,22 @@
   * Don't allow probing for Mercurial repositories over HTTP to break 
     bzr. (Jelmer Vernooij)
 
+  * Fix recursive removing of parent empty directories. (#691994,
+    Leonid Borisenko)
+
+  * WorkingTree.commit()'s message argument is now optional, consistent
+    with bzr.dev. (#692902, Jelmer Vernooij)
+
+  * Fix handling of unknown strings in converted_from extra. 
+    (#670870, Jelmer Vernooij)
+
+  * Fix handling of first revision without changes. (Jelmer Vernooij, #688459)
+
+  * Support stop_revision in Branch.pull(). (Jelmer Vernooij, #544701)
+
+  * Provide custom ControlDir.sprout() implementation. Required for
+    compatibility with bzr 2.4. (Jelmer Vernooij, #717937)
+
  DOCUMENTATION
 
   * Add some basic instructions in INSTALL. (Martin Pool)
 
=== modified file '__init__.py'
--- __init__.py	2010-08-06 10:51:08 +0000
+++ __init__.py	2011-03-23 21:41:04 +0000
@@ -25,13 +25,12 @@
 
 from info import (
     bzr_compatible_versions,
-    hg_compatible_versions,
+    hg_compatible_version_strings,
     bzr_plugin_version as version_info,
     )
 
 bzrlib.api.require_any_api(bzrlib, bzr_compatible_versions)
 
-import bzrlib.bzrdir
 from bzrlib import (
     errors,
     trace,
@@ -39,13 +38,17 @@
 from bzrlib.foreign import (
     foreign_vcs_registry,
     )
-import bzrlib.lockable_files
 from bzrlib.send import (
     format_registry as send_format_registry,
     )
 
+from bzrlib.controldir import (
+    network_format_registry as controldir_network_format_registry,
+    ControlDirFormat,
+    Prober,
+    )
+
 _mercurial_loaded = False
-LockWarner = bzrlib.lockable_files._LockWarner
 
 def lazy_load_mercurial():
     global _mercurial_loaded
@@ -61,7 +64,7 @@
     from mercurial.__version__ import version as hg_version
     if hg_version != "unknown":
         hg_major_version = ".".join(hg_version.split(".")[:2])
-        if hg_major_version not in hg_compatible_versions and not "+" in hg_version:
+        if hg_major_version not in hg_compatible_version_strings and not "+" in hg_version:
             raise errors.DependencyNotPresent("mercurial",
                 'bzr-hg: Mercurial version %s not supported.' % hg_version)
     trace.mutter("bzr-hg: using Mercurial %s" % hg_version)
@@ -70,266 +73,79 @@
 foreign_vcs_registry.register_lazy("hg",
     "bzrlib.plugins.hg.mapping", "foreign_hg", "Mercurial")
 
-class HgDummyLock(object):
-    """Lock that doesn't actually lock."""
-
-    def __init__(self, hgrepo):
-        self._hgrepo = hgrepo
-
-    def lock_write(self, token=None):
-        if token is not None:
-            raise errors.TokenLockingNotSupported(self)
-        self._lock = self._hgrepo.wlock()
-
-    def lock_read(self):
-        self._lock = None
-
-    def peek(self):
-        raise NotImplementedError(self.peek)
-
-    def unlock(self):
-        if self._lock is not None:
-            self._lock.release()
-
-    def validate_token(self, token):
-        if token is not None:
-            raise errors.TokenLockingNotSupported(self)
-
-
-class HgLock(object):
-    """A lock that thunks through to Hg."""
-
-    def __init__(self, hgrepo):
-        self._hgrepo = hgrepo
-
-    def lock_write(self, token=None):
-        if token is not None:
-            raise errors.TokenLockingNotSupported(self)
-        self._lock = self._hgrepo.wlock()
-
-    def lock_read(self):
-        self._lock = self._hgrepo.lock()
-
-    def peek(self):
-        raise NotImplementedError(self.peek)
-
-    def unlock(self):
-        self._lock.release()
-
-    def validate_token(self, token):
-        if token is not None:
-            raise errors.TokenLockingNotSupported(self)
-
-    def break_lock(self):
-        pass
-
-
-class HgLockableFiles(bzrlib.lockable_files.LockableFiles):
-    """Hg specific lockable files abstraction."""
-
-    def __init__(self, lock, transport):
-        self._lock = lock
-        self._transaction = None
-        self._lock_mode = None
-        self._transport = transport
-        self._lock_warner = LockWarner(repr(self))
-
-
-class HgDir(bzrlib.bzrdir.BzrDir):
-    """An adapter to the '.hg' dir used by mercurial."""
-
-    def __init__(self, hgrepo, transport, lockfiles, format):
-        self._format = format
-        self.root_transport = transport
-        self.transport = transport.clone('.hg')
-        self._hgrepo = hgrepo
-        self._lockfiles = lockfiles
-
-    def backup_bzrdir(self):
-        self.root_transport.copy_tree(".hg", ".hg.backup")
-        return (self.root_transport.abspath(".hg"),
-                self.root_transport.abspath(".hg.backup"))
-
-    def break_lock(self):
-        """Mercurial locks never break."""
-        raise NotImplementedError(self.break_lock)
-
-    def clone(self, url, revision_id=None, basis=None, force_new_repo=False):
-        """Clone this hg dir to url."""
-        self._make_tail(url)
-        if url.startswith('file://'):
-            url = url[len('file://'):]
-        url = url.encode('utf8')
-        result = self._format.initialize(url)
-        result._hgrepo.pull(self._hgrepo)
-        return result
-
-    def create_branch(self, name=None):
-        """'create' a branch for this dir."""
-        return self.open_branch(name=name)
-
-    def create_repository(self, shared=False):
-        """'create' a repository for this dir."""
-        if shared:
-            # dont know enough about hg yet to do 'shared repositories' in it.
-            raise errors.IncompatibleFormat(self._format, self._format)
-        return self.open_repository()
-
-    def create_workingtree(self, revision_id=None, from_branch=None,
-            accelerator_tree=None, hardlink=False):
-        """'create' a workingtree for this dir."""
-        if revision_id is not None:
-            raise NotImplementedError("revision_id argument not yet supported")
-        if from_branch is not None:
-            raise NotImplementedError("from_branch argument not yet supported")
-        return self.open_workingtree()
-
-    def destroy_branch(self, name=None):
-        if name is not None:
-            raise errors.NoColocatedBranchSupport(self)
-        raise errors.UnsupportedOperation(self.destroy_branch, self)
-
-    def destroy_workingtree(self):
-        raise errors.UnsupportedOperation(self.destroy_workingtree, self)
-
-    def destroy_repository(self):
-        raise errors.UnsupportedOperation(self.destroy_repository, self)
-
-    def get_branch_transport(self, branch_format, name=None):
-        if name is not None:
-            raise errors.NoColocatedBranchSupport(self)
-        if branch_format is None:
-            return self.transport
-        if isinstance(branch_format, HgBzrDirFormat):
-            return self.transport
-        raise errors.IncompatibleFormat(branch_format, self._format)
-
-    get_repository_transport = get_branch_transport
-    get_workingtree_transport = get_branch_transport
-
-    def is_supported(self):
-        return True
-
-    def needs_format_conversion(self, format=None):
-        return (format is not HgBzrDirFormat)
-
-    def open_branch(self, name=None, unsupported=False,
-            ignore_fallbacks=False):
-        """'create' a branch for this dir."""
-        if name is not None:
-            raise errors.NoColocatedBranchSupport(self)
-        from bzrlib.plugins.hg.branch import HgLocalBranch, HgRemoteBranch
-        if self._hgrepo.local():
-            branch_klass = HgLocalBranch
-        else:
-            branch_klass = HgRemoteBranch
-        return branch_klass(self._hgrepo, self, self._lockfiles)
-
-    def open_repository(self, shared=False):
-        """'open' a repository for this dir."""
-        from bzrlib.plugins.hg.repository import (
-            HgLocalRepository,
-            HgRemoteRepository,
-            )
-        if self._hgrepo.local():
-            repo_klass = HgLocalRepository
-        else:
-            repo_klass = HgRemoteRepository
-        return repo_klass(self._hgrepo, self, self._lockfiles)
-
-    def open_workingtree(self, shared=False, recommend_upgrade=False):
-        """'open' a workingtree for this dir."""
-        from bzrlib.plugins.hg.workingtree import HgWorkingTree
-        return HgWorkingTree(self._hgrepo, self.open_branch(), self,
-                             self._lockfiles)
-
-    def cloning_metadir(self, stacked=False):
-        return bzrlib.bzrdir.format_registry.make_bzrdir("default-rich-root")
-
-
-class HgToSomethingConverter(bzrlib.bzrdir.Converter):
-    """A class to upgrade an hg dir to something else."""
-
-    def __init__(self, format):
-        self.format = format
-        if self.format is None:
-            self.format = bzrlib.bzrdir.BzrDirFormat.get_default_format()
-
-    def convert(self, bzrdir, pb):
-        source_repo = bzrdir.open_repository()
-        source_branch = bzrdir.open_branch()
-        target = self.format.initialize_on_transport(bzrdir.root_transport)
-        target_repo = target.create_repository()
-        target_repo.fetch(source_repo, pb=pb)
-        target_branch = target.create_branch()
-        target_branch.generate_revision_history(source_branch.last_revision())
-        target_wt = target.create_workingtree()
-        bzrdir.root_transport.delete_tree(".hg")
-        return target
-
-
-class HgBzrDirFormat(bzrlib.bzrdir.BzrDirFormat):
-    """The .hg directory control format."""
-
-    def __init__(self):
-        super(HgBzrDirFormat, self).__init__()
-        self.workingtree_format = None
-
-    def get_converter(self, format):
-        """We should write a converter."""
-        return HgToSomethingConverter(format)
-
-    def network_name(self):
-        return "hg"
-
-    def get_format_description(self):
-        return "Mercurial Branch"
-
-    def initialize_on_transport(self, transport):
-        """Initialize a new .not dir in the base directory of a Transport."""
-        return self.open(transport, _create=True)
-
-    def __eq__(self, other):
-        return type(self) == type(other)
-
-    @classmethod
-    def _known_formats(self):
-        return set([HgBzrDirFormat()])
-
-    def open(self, transport, _create=False, _found=None):
-        """Open this directory.
-
-        :param _create: create the hg dir on the fly. private to HgBzrDirFormat.
-        """
-        # we dont grok readonly - hg isn't integrated with transport.
-        if transport.base.startswith('readonly+'):
-            transport = transport._decorated
-        if transport.base.startswith('file://'):
-            path = transport.local_abspath('.').encode('utf-8')
-            lock_class = HgLock
-        else:
-            path = transport.base
-            lock_class = HgDummyLock
-        lazy_load_mercurial()
-        import mercurial.hg
-        from bzrlib.plugins.hg.ui import ui
-        repository = mercurial.hg.repository(ui(), path, create=_create)
-        lockfiles = HgLockableFiles(lock_class(repository), transport)
-        return HgDir(repository, transport, lockfiles, self)
-
-    @classmethod
-    def probe_transport(klass, transport):
-        """Our format is present if the transport ends in '.not/'."""
-        # little ugly, but works
-        format = klass()
-        from bzrlib.transport.local import LocalTransport
-        lazy_load_mercurial()
-        from mercurial import error as hg_errors
-        if isinstance(transport, LocalTransport) and not transport.has(".hg"):
+def has_hg_http_smart_server(transport, external_url):
+    if not external_url.startswith("http:") and not external_url.startswith("https:"):
+        return False
+    url = external_url + "?pairs=%s-%s&cmd=between" % ("0" * 40, "0" * 40)
+    from bzrlib.transport.http._urllib import HttpTransport_urllib, Request
+    if isinstance(transport, HttpTransport_urllib):
+        req = Request('GET', url, accepted_errors=[200, 403, 404, 405])
+        req.follow_redirections = True
+        resp = transport._perform(req)
+        if resp.code == 404:
+            return False
+        headers = resp.headers
+    else:
+        try:
+            from bzrlib.transport.http._pycurl import PyCurlTransport
+        except errors.DependencyNotPresent:
+            return False
+        else:
+            import pycurl
+            from cStringIO import StringIO
+            if isinstance(transport, PyCurlTransport):
+                conn = transport._get_curl()
+                conn.setopt(pycurl.URL, url)
+                transport._set_curl_options(conn)
+                conn.setopt(pycurl.HTTPGET, 1)
+                conn.setopt(pycurl.NOBODY, 1)
+                header = StringIO()
+                data = StringIO()
+                conn.setopt(pycurl.HEADERFUNCTION, header.write)
+                conn.setopt(pycurl.WRITEFUNCTION, data.write)
+                transport._curl_perform(conn, header)
+                code = conn.getinfo(pycurl.HTTP_CODE)
+                if code == 404:
+                    raise errors.NoSuchFile(transport._path)
+                headers = transport._parse_headers(header)
+            else:
+                return False
+    ct = headers.getheader("Content-Type")
+    return ct.startswith("application/mercurial")
+
+
+def has_hg_dumb_repository(transport):
+    try:
+        return transport.has(".hg/requires")
+    except (errors.NoSuchFile, errors.PermissionDenied):
+        return False
+
+
+class HgProber(Prober):
+
+    # Perhaps retrieve list from mercurial.hg.schemes ?
+    _supported_schemes = ["http", "https", "file", "ssh"]
+
+    def probe_transport(self, transport):
+        try:
+            external_url = transport.external_url()
+        except errors.InProcessTransport:
+            raise errors.NotBranchError(path=transport.base)
+        scheme = external_url.split(":")[0]
+        if scheme not in self._supported_schemes:
+            raise errors.NotBranchError(path=transport.base)
+        if (not has_hg_dumb_repository(transport) and
+            not has_hg_http_smart_server(transport, external_url)):
             # Explicitly check for .hg directories here, so we avoid
             # loading foreign branches through Mercurial.
             raise errors.NotBranchError(path=transport.base)
+
+        lazy_load_mercurial()
+        from mercurial import error as hg_errors
+
         import urllib2
+        from bzrlib.plugins.hg.dir import HgControlDirFormat
+        format = HgControlDirFormat()
         try:
             format.open(transport)
         except hg_errors.RepoError, e:
@@ -342,11 +158,68 @@
             raise errors.NotBranchError(path=transport.base)
         return format
 
-
-bzrlib.bzrdir.BzrDirFormat.register_control_format(HgBzrDirFormat)
-
-bzrlib.bzrdir.format_registry.register("hg",
-    HgBzrDirFormat, "Mercurial repository. ", native=False, hidden=False)
+    @classmethod
+    def known_formats(cls):
+        from bzrlib.plugins.hg.dir import HgControlDirFormat
+        return set([HgControlDirFormat()])
+
+
+ControlDirFormat.register_prober(HgProber)
+ControlDirFormat._server_probers.insert(0, HgProber)
+if not getattr(Prober, "known_formats", False): # bzr < 2.4
+    from bzrlib.plugins.hg.dir import HgControlDirFormat
+    ControlDirFormat.register_format(HgControlDirFormat())
+
+controldir_network_format_registry.register_lazy("hg",
+    "bzrlib.plugins.hg.dir", "HgControlDirFormat")
+
+bzrlib.bzrdir.format_registry.register_lazy("hg",
+    "bzrlib.plugins.hg.dir", "HgControlDirFormat",
+    "Mercurial repository. ", native=False, hidden=False)
+
+from bzrlib.repository import (
+    format_registry as repository_format_registry,
+    network_format_registry as repository_network_format_registry,
+    )
+repository_network_format_registry.register_lazy('hg',
+    'bzrlib.plugins.hg.repository', 'HgRepositoryFormat')
+
+
+from bzrlib.branch import (
+    network_format_registry as branch_network_format_registry,
+    )
+branch_network_format_registry.register_lazy(
+    "hg", "bzrlib.plugins.hg.branch", "HgBranchFormat")
+
+try:
+    from bzrlib.branch import (
+        format_registry as branch_format_registry,
+        )
+except ImportError: # bzr < 2.4
+    pass
+else:
+    branch_format_registry.register_extra_lazy(
+        "bzrlib.plugins.hg.branch", "HgBranchFormat")
+
+try:
+    from bzrlib.workingtree import (
+        format_registry as workingtree_format_registry,
+        )
+except ImportError: # bzr < 2.4
+    pass
+else:
+    workingtree_format_registry.register_extra_lazy(
+        "bzrlib.plugins.hg.workingtree", "HgWorkingTreeFormat")
+
+
+try:
+    register_extra_lazy_repository_format = getattr(repository_format_registry,
+        "register_extra_lazy")
+except AttributeError: # bzr < 2.4
+    pass
+else:
+    register_extra_lazy_repository_format('bzrlib.plugins.hg.repository',
+        'HgRepositoryFormat')
 
 send_format_registry.register_lazy('hg', 'bzrlib.plugins.hg.send',
                                    'send_hg', 'Mecurial bundle format')
@@ -360,15 +233,14 @@
     )
 plugin_cmds.register_lazy('cmd_hg_import', [], 'bzrlib.plugins.hg.commands')
 
-try:
-    from bzrlib.revisionspec import dwim_revspecs
-except ImportError:
-    pass
-else:
+from bzrlib.revisionspec import dwim_revspecs, RevisionSpec_dwim
+if getattr(RevisionSpec_dwim, "append_possible_lazy_revspec", None):
+    RevisionSpec_dwim.append_possible_lazy_revspec(
+        "bzrlib.plugins.hg.revspec", "RevisionSpec_hg")
+else: # bzr < 2.4
     from bzrlib.plugins.hg.revspec import RevisionSpec_hg
     dwim_revspecs.append(RevisionSpec_hg)
 
-
 def test_suite():
     from unittest import TestSuite, TestLoader
     from bzrlib.plugins.hg import tests
 
=== modified file 'branch.py'
--- branch.py	2010-08-14 00:38:48 +0000
+++ branch.py	2011-03-23 21:41:04 +0000
@@ -1,5 +1,5 @@
-# Copyright (C) 2005, 2006 Canonical Ltd
-# Copyright (C) 2008-2009 Jelmer Vernooij <[e-mail]>
+# Copyright (C) 2005, 2006, 2011 Canonical Ltd
+# Copyright (C) 2008-2011 Jelmer Vernooij <[e-mail]>
 #
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
@@ -39,6 +39,10 @@
 from bzrlib.repository import (
     InterRepository,
     )
+from bzrlib.tag import (
+    BasicTags,
+    DisabledTags,
+    )
 
 from bzrlib.plugins.hg.changegroup import (
     dchangegroup,
@@ -48,6 +52,49 @@
     _fmt = "Push is not yet supported for bzr-hg. Try dpush instead."
 
 
+class HgTags(BasicTags):
+
+    def __init__(self, branch):
+        self.branch = branch
+
+    def _get_hg_tags(self):
+        raise NotImplementedError(self._get_hg_tags)
+
+    def get_tag_dict(self):
+        ret = {}
+        hgtags = self._get_hg_tags()
+        for name, value in hgtags.iteritems():
+            ret[name] = self.branch.repository.lookup_foreign_revision_id(value)
+        return ret
+
+    def set_tag(self, name, value):
+        self.branch.repository._hgrepo.tag([name],
+            self.branch.repository.lookup_bzr_revision_id(value)[0],
+            "Create tag %s" % name,
+            True,
+            self.branch.get_config().username(), None)
+
+
+class LocalHgTags(HgTags):
+
+    def _get_hg_tags(self):
+        return self.branch.repository._hgrepo.tags()
+
+
+class FileHgTags(HgTags):
+
+    def __init__(self, branch, revid):
+        self.branch = branch
+        self.revid = revid
+
+    def _get_hg_tags(self):
+        revtree = self.branch.repository.revision_tree(self.revid)
+        f = revtree.get_file_text(revtree.path2id(".hgtags"), ".hgtags")
+        for l in f.readlines():
+            (name, hgtag) = l.strip().split(" ")
+            yield name, hgtag
+
+
 class HgBranchFormat(BranchFormat):
     """Mercurial Branch Format.
 
@@ -56,6 +103,11 @@
     support the branch format.
     """
 
+    @property
+    def _matchingbzrdir(self):
+        from bzrlib.plugins.hg.dir import HgControlDirFormat
+        return HgControlDirFormat()
+
     def get_format_description(self):
         """See BranchFormat.get_format_description()."""
         return "Mercurial Branch"
@@ -67,6 +119,25 @@
         from bzrlib.plugins.hg.tests.test_branch import ForeignTestsBranchFactory
         return ForeignTestsBranchFactory()
 
+    def initialize(self, a_bzrdir, name=None, repository=None):
+        from bzrlib.plugins.hg.dir import HgDir
+        if name is None:
+            name = 'default'
+        if not isinstance(a_bzrdir, HgDir):
+            raise errors.IncompatibleFormat(self, a_bzrdir._format)
+        bm = a_bzrdir._hgrepo.branchmap()
+        if name in bm:
+            raise errors.AlreadyBranchError(a_bzrdir.user_url)
+        return a_bzrdir.open_branch(name=name)
+
+    def make_tags(self, branch):
+        """See bzrlib.branch.BranchFormat.make_tags()."""
+        if getattr(branch.repository._hgrepo, "tags", None) is not None:
+            return LocalHgTags(branch)
+        else:
+            return DisabledTags(branch)
+
+
 
 class HgBranchConfig(object):
     """Access Branch Configuration data for an HgBranch.
@@ -78,6 +149,9 @@
         self._branch = branch
         self._ui = branch.repository._hgrepo.ui
 
+    def username(self):
+        return self._ui.config("username", "default")
+
     def get_nickname(self):
         # remove the trailing / and take the basename.
         return os.path.basename(self._branch.base[:-1])
@@ -92,13 +166,13 @@
         return False
 
     def get_user_option(self, name):
-        return None
+        return self._ui.config(name, "bazaar")
 
     def get_user_option_as_bool(self, name):
         return False
 
     def set_user_option(self, name, value, warn_masked=False):
-        pass # FIXME: Uhm?
+        self._ui.setconfig(name, "bazaar", value)
 
     def log_format(self):
         """What log format should be used"""
@@ -120,14 +194,22 @@
 class HgBranch(ForeignBranch):
     """An adapter to mercurial repositories for bzr Branch objects."""
 
-    def __init__(self, hgrepo, hgdir, lockfiles):
-        self._format = HgBranchFormat()
+    @property
+    def control_url(self):
+        return self.bzrdir.control_url
+
+    @property
+    def control_transport(self):
+        return self.bzrdir.control_transport
+
+    def __init__(self, hgrepo, name, hgdir, lockfiles):
         self.repository = hgdir.open_repository()
         ForeignBranch.__init__(self, self.repository.get_mapping())
         self._hgrepo = hgrepo
         self.bzrdir = hgdir
         self.control_files = lockfiles
         self.base = hgdir.root_transport.base
+        self.name = name
 
     def _check(self):
         # TODO: Call out to mercurial for consistency checking?
@@ -195,21 +277,42 @@
             revision_id = source_revision_id
         destination.generate_revision_history(revision_id)
 
+    def _tip(self):
+        try:
+            return self._hgrepo.branchmap()[self.name][0]
+        except KeyError:
+            import mercurial.node
+            return mercurial.node.nullid
+
 
 class HgLocalBranch(HgBranch):
 
+    def __init__(self, hgrepo, name, hgdir, lockfiles):
+        self._format = HgBranchFormat()
+        super(HgLocalBranch, self).__init__(hgrepo, name, hgdir, lockfiles)
+
+    def supports_tags(self):
+        return True
+
     @needs_read_lock
     def last_revision(self):
-        tip = self._hgrepo.lookup("tip")
+        tip = self._tip()
         return self.repository.lookup_foreign_revision_id(tip,
             mapping=self.mapping)
 
 
 class HgRemoteBranch(HgBranch):
 
+    def __init__(self, hgrepo, name, hgdir, lockfiles):
+        self._format = HgBranchFormat()
+        super(HgRemoteBranch, self).__init__(hgrepo, name, hgdir, lockfiles)
+
+    def supports_tags(self):
+        return getattr(self.repository._hgrepo, "tags", None) is not None
+
     @needs_read_lock
     def last_revision(self):
-        tip = self._hgrepo.lookup("tip")
+        tip = self._tip()
         return self.mapping.revision_id_foreign_to_bzr(tip)
 
 
@@ -234,7 +337,15 @@
         result.old_revno, result.old_revid = self.target.last_revision_info()
         inter = InterRepository.get(self.source.repository,
                                     self.target.repository)
+        if stop_revision is None:
+            stop_revision = self.source.last_revision()
         inter.fetch(revision_id=stop_revision)
+        if overwrite:
+            req_base = None
+        else:
+            req_base = self.target.last_revision()
+        self.target.generate_revision_history(stop_revision,
+            req_base, self.source)
         result.new_revno, result.new_revid = self.target.last_revision_info()
         return result
 
@@ -284,6 +395,8 @@
         self.target.generate_revision_history(self.source.last_revision(),
             req_base, self.source)
         result.new_revno, result.new_revid = self.target.last_revision_info()
+        tags = FileHgTags(self.target, result.new_revid)
+        result.tag_conflicts = tags.merge_to(self.target.tags, overwrite)
         return result
 
     def push(self, overwrite=False, stop_revision=None):
@@ -294,11 +407,18 @@
         result.old_revid = self.target.last_revision()
         inter = InterRepository.get(self.source.repository,
                                     self.target.repository)
+        if stop_revision is not None:
+            stop_revision = self.source.last_revision()
         inter.fetch(revision_id=stop_revision)
-        self.target.generate_revision_history(self.source.last_revision(),
-                                              self.target.last_revision(),
-                                              self.source)
+        if overwrite:
+            req_base = None
+        else:
+            req_base = self.target.last_revision()
+        self.target.generate_revision_history(stop_revision, req_base,
+            self.source)
         result.new_revid = self.target.last_revision()
+        tags = FileHgTags(self.target, result.new_revid)
+        result.tag_conflicts = tags.merge_to(self.target.tags, overwrite)
         return result
 
 
 
=== added file 'dir.py'
--- dir.py	1970-01-01 00:00:00 +0000
+++ dir.py	2011-03-23 21:41:04 +0000
@@ -0,0 +1,395 @@
+# Copyright (C) 2005-2011 Canonical Ltd
+# Copyright (C) 2008-2010 Jelmer Vernooij <[e-mail]>
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+"""Mercurial control directory support.
+
+"""
+
+import bzrlib.bzrdir
+import bzrlib.lockable_files
+from bzrlib import (
+    errors,
+    urlutils,
+    )
+
+from bzrlib.controldir import (
+    ControlDir,
+    ControlDirFormat,
+    )
+try:
+    from bzrlib.controldir import Converter
+except ImportError: # bzr < 2.4
+    from bzrlib.bzrdir import Converter
+from bzrlib.plugins.hg import (
+    lazy_load_mercurial,
+    )
+
+
+class HgControlDirConfig(object):
+
+    def get_default_stack_on(self):
+        return None
+
+    def set_default_stack_on(self, value):
+        raise errors.BzrError("Cannot set configuration")
+
+
+class HgDir(ControlDir):
+    """An adapter to the '.hg' dir used by mercurial."""
+
+    @property
+    def user_transport(self):
+        return self.root_transport
+
+    @property
+    def control_transport(self):
+        return self.transport
+
+    def is_control_filename(self, filename):
+        return (filename == ".hg" or filename.startswith(".hg/"))
+
+    def __init__(self, hgrepo, transport, lockfiles, format):
+        self._format = format
+        self.root_transport = transport
+        self.transport = transport.clone('.hg')
+        self._hgrepo = hgrepo
+        self._lockfiles = lockfiles
+
+    def backup_bzrdir(self):
+        self.root_transport.copy_tree(".hg", ".hg.backup")
+        return (self.root_transport.abspath(".hg"),
+                self.root_transport.abspath(".hg.backup"))
+
+    def break_lock(self):
+        """Mercurial locks never break."""
+        raise NotImplementedError(self.break_lock)
+
+    def clone_on_transport(self, transport, revision_id=None,
+        force_new_repo=False, preserve_stacking=False, stacked_on=None,
+        create_prefix=False, use_existing_dir=True, no_tree=False):
+        """See ControlDir.clone_on_transport."""
+        path = transport.local_abspath(".")
+        result = self._format.initialize(path)
+        result._hgrepo.pull(self._hgrepo)
+        return result
+
+    def create_branch(self, name=None, repository=None):
+        """'create' a branch for this dir."""
+        return self.open_branch(name=name)
+
+    def create_repository(self, shared=False):
+        """'create' a repository for this dir."""
+        if shared:
+            raise errors.IncompatibleFormat(self._format, self._format)
+        return self.open_repository()
+
+    def create_workingtree(self, revision_id=None, from_branch=None,
+            accelerator_tree=None, hardlink=False):
+        """'create' a workingtree for this dir."""
+        if revision_id is not None:
+            raise NotImplementedError("revision_id argument not yet supported")
+        if from_branch is not None:
+            raise NotImplementedError("from_branch argument not yet supported")
+        return self.open_workingtree()
+
+    def destroy_branch(self, name=None):
+        raise errors.UnsupportedOperation(self.destroy_branch, self)
+
+    def destroy_workingtree(self):
+        raise errors.UnsupportedOperation(self.destroy_workingtree, self)
+
+    def destroy_repository(self):
+        raise errors.UnsupportedOperation(self.destroy_repository, self)
+
+    def get_branch_transport(self, branch_format, name=None):
+        if branch_format is None:
+            return self.transport
+        if isinstance(branch_format, HgControlDirFormat):
+            return self.transport
+        raise errors.IncompatibleFormat(branch_format, self._format)
+
+    get_repository_transport = get_branch_transport
+    get_workingtree_transport = get_branch_transport
+
+    def is_supported(self):
+        return True
+
+    def needs_format_conversion(self, format=None):
+        return (format is not HgControlDirFormat)
+
+    def open_branch(self, name=None, unsupported=False,
+            ignore_fallbacks=False):
+        """'create' a branch for this dir."""
+        if name is None:
+            name = 'default'
+        from bzrlib.plugins.hg.branch import HgLocalBranch, HgRemoteBranch
+        if self._hgrepo.local():
+            branch_klass = HgLocalBranch
+        else:
+            branch_klass = HgRemoteBranch
+        return branch_klass(self._hgrepo, name, self, self._lockfiles)
+
+    def find_repository(self, shared=False):
+        return self.open_repository(shared)
+
+    def open_repository(self, shared=False):
+        """'open' a repository for this dir."""
+        from bzrlib.plugins.hg.repository import (
+            HgLocalRepository,
+            HgRemoteRepository,
+            )
+        if self._hgrepo.local():
+            repo_klass = HgLocalRepository
+        else:
+            repo_klass = HgRemoteRepository
+        return repo_klass(self._hgrepo, self, self._lockfiles)
+
+    def open_workingtree(self, shared=False, recommend_upgrade=False):
+        """'open' a workingtree for this dir."""
+        from bzrlib.plugins.hg.workingtree import HgWorkingTree
+        return HgWorkingTree(self._hgrepo, self.open_branch(), self,
+                             self._lockfiles)
+
+    def cloning_metadir(self, stacked=False):
+        return bzrlib.bzrdir.format_registry.make_bzrdir("default-rich-root")
+
+    def get_config(self):
+        return HgControlDirConfig()
+
+    def sprout(self, url, revision_id=None, force_new_repo=False,
+               recurse='down', possible_transports=None,
+               accelerator_tree=None, hardlink=False, stacked=False,
+               source_branch=None, create_tree_if_local=True):
+        from bzrlib.repository import InterRepository
+        from bzrlib.transport.local import LocalTransport
+        from bzrlib.transport import get_transport
+        target_transport = get_transport(url, possible_transports)
+        target_transport.ensure_base()
+        cloning_format = self.cloning_metadir()
+        # Create/update the result branch
+        result = cloning_format.initialize_on_transport(target_transport)
+        source_branch = self.open_branch()
+        source_repository = self.find_repository()
+        try:
+            result_repo = result.find_repository()
+        except errors.NoRepositoryPresent:
+            result_repo = result.create_repository()
+            target_is_empty = True
+        else:
+            target_is_empty = None # Unknown
+        if stacked:
+            raise errors.IncompatibleRepositories(source_repository, result_repo)
+        interrepo = InterRepository.get(source_repository, result_repo)
+        interrepo.fetch(revision_id=revision_id)
+        result_branch = source_branch.sprout(result,
+            revision_id=revision_id, repository=result_repo)
+        if (create_tree_if_local and isinstance(target_transport, LocalTransport)
+            and (result_repo is None or result_repo.make_working_trees())):
+            wt = result.create_workingtree(accelerator_tree=accelerator_tree,
+                hardlink=hardlink, from_branch=result_branch)
+            wt.lock_write()
+            try:
+                if wt.path2id('') is None:
+                    try:
+                        wt.set_root_id(self.open_workingtree.get_root_id())
+                    except errors.NoWorkingTree:
+                        pass
+            finally:
+                wt.unlock()
+        return result
+
+
+class HgToSomethingConverter(Converter):
+    """A class to upgrade an hg dir to something else."""
+
+    def __init__(self, format):
+        self.format = format
+        if self.format is None:
+            self.format = ControlDirFormat.get_default_format()
+
+    def convert(self, bzrdir, pb):
+        source_repo = bzrdir.open_repository()
+        source_branch = bzrdir.open_branch()
+        target = self.format.initialize_on_transport(bzrdir.root_transport)
+        target_repo = target.create_repository()
+        target_repo.fetch(source_repo, pb=pb)
+        target_branch = target.create_branch()
+        target_branch.generate_revision_history(source_branch.last_revision())
+        target_wt = target.create_workingtree()
+        bzrdir.root_transport.delete_tree(".hg")
+        return target
+
+
+LockWarner = bzrlib.lockable_files._LockWarner
+
+
+class HgLockableFiles(bzrlib.lockable_files.LockableFiles):
+    """Hg specific lockable files abstraction."""
+
+    def __init__(self, lock, transport):
+        self.lock_name = "hg lock"
+        self._lock = lock
+        self._transaction = None
+        self._lock_mode = None
+        self._transport = transport
+        self._lock_warner = LockWarner(repr(self))
+
+
+class HgDummyLock(object):
+    """Lock that doesn't actually lock."""
+
+    def __init__(self, hgrepo):
+        self._hgrepo = hgrepo
+
+    def lock_write(self, token=None):
+        if token is not None:
+            raise errors.TokenLockingNotSupported(self)
+        self._lock = self._hgrepo.wlock()
+
+    def lock_read(self):
+        self._lock = None
+
+    def peek(self):
+        raise NotImplementedError(self.peek)
+
+    def unlock(self):
+        if self._lock is not None:
+            self._lock.release()
+
+    def validate_token(self, token):
+        if token is not None:
+            raise errors.TokenLockingNotSupported(self)
+
+
+class HgLock(object):
+    """A lock that thunks through to Hg."""
+
+    def __init__(self, hgrepo):
+        self._hgrepo = hgrepo
+
+    def lock_write(self, token=None):
+        if token is not None:
+            raise errors.TokenLockingNotSupported(self)
+        self._lock = self._hgrepo.wlock()
+
+    def lock_read(self):
+        self._lock = self._hgrepo.lock()
+
+    def peek(self):
+        raise NotImplementedError(self.peek)
+
+    def unlock(self):
+        self._lock.release()
+
+    def validate_token(self, token):
+        if token is not None:
+            raise errors.TokenLockingNotSupported(self)
+
+    def break_lock(self):
+        pass
+
+
+class HgControlDirFormat(ControlDirFormat):
+    """The .hg directory control format."""
+
+    colocated_branches = True
+    fixed_components = True
+
+    def __init__(self):
+        super(HgControlDirFormat, self).__init__()
+        self.workingtree_format = None
+
+    def get_converter(self, format):
+        """We should write a converter."""
+        return HgToSomethingConverter(format)
+
+    def network_name(self):
+        return "hg"
+
+    def get_format_description(self):
+        return "Mercurial Branch"
+
+    def initialize_on_transport_ex(self, transport, use_existing_dir=False,
+        create_prefix=False, force_new_repo=False, stacked_on=None,
+        stack_on_pwd=None, repo_format_name=None, make_working_trees=None,
+        shared_repo=False, vfs_only=False):
+        from bzrlib import trace
+        from bzrlib.bzrdir import CreateRepository
+        from bzrlib.transport import do_catching_redirections
+        def make_directory(transport):
+            transport.mkdir('.')
+            return transport
+        def redirected(transport, e, redirection_notice):
+            trace.note(redirection_notice)
+            return transport._redirected_to(e.source, e.target)
+        try:
+            transport = do_catching_redirections(make_directory, transport,
+                redirected)
+        except errors.FileExists:
+            if not use_existing_dir:
+                raise
+        except errors.NoSuchFile:
+            if not create_prefix:
+                raise
+            transport.create_prefix()
+        controldir = self.initialize_on_transport(transport)
+        repository = controldir.open_repository()
+        repository.lock_write()
+        return (repository, controldir, False, CreateRepository(controldir))
+
+    def get_branch_format(self):
+        from bzrlib.plugins.hg.branch import HgBranchFormat
+        return HgBranchFormat()
+
+    @property
+    def repository_format(self):
+        from bzrlib.plugins.hg.repository import HgRepositoryFormat
+        return HgRepositoryFormat()
+
+    def initialize_on_transport(self, transport):
+        """Initialize a new .not dir in the base directory of a Transport."""
+        return self.open(transport, _create=True)
+
+    def __eq__(self, other):
+        return type(self) == type(other)
+
+    def __hash__(self):
+        return hash((self.__class__,))
+
+    def open(self, transport, _create=False, _found=None):
+        """Open this directory.
+
+        :param _create: create the hg dir on the fly. private to
+            HgControlDirFormat.
+        """
+        # we dont grok readonly - hg isn't integrated with transport.
+        try:
+            url = transport.external_url()
+        except errors.InProcessTransport:
+            raise errors.NotBranchError(transport.base)
+        if url.startswith('file://'):
+            path = transport.local_abspath('.').encode('utf-8')
+            lock_class = HgLock
+        else:
+            path = url
+            lock_class = HgDummyLock
+        lazy_load_mercurial()
+        import mercurial.hg
+        from bzrlib.plugins.hg.ui import ui
+        repository = mercurial.hg.repository(ui(), path, create=_create)
+        lockfiles = HgLockableFiles(lock_class(repository), transport)
+        return HgDir(repository, transport, lockfiles, self)
 
=== modified file 'fetch.py'
--- fetch.py	2010-08-14 00:41:20 +0000
+++ fetch.py	2011-03-23 21:41:04 +0000
@@ -70,6 +70,8 @@
     get_overlay,
     )
 from bzrlib.plugins.hg.parsers import (
+    chunkiter,
+    deserialize_file_text,
     parse_changeset,
     parse_manifest,
     unpack_chunk_iter,
@@ -145,6 +147,12 @@
     # Set of directories that have been created in this delta, their file id
     # as value.
     directories = {}
+    if basis_inv is None:
+        # Root is mandatory
+        extra, root_id = inventory_create_directory(directories,
+            basis_inv, other_inv, "", lookup_file_id, revid)
+        for e in extra:
+            yield e
     # Dictionary of directories that could have been made empty in this delta,
     # with the set of removed children as value.
     maybe_empty_dirs = defaultdict(set)
@@ -209,17 +217,20 @@
                     ie.symlink_target = lookup_symlink((fileid, ie.revision))
             yield (old_path, path, fileid, ie)
     # Remove empty directories
-    for path in sorted(maybe_empty_dirs.keys(), reverse=True):
-        if maybe_empty_dirs[path] is None:
-            # Stuff was added to this directory in this revision, don't bother
-            continue
-        file_id = basis_inv.path2id(path)
-        # Is this directory really empty ?
-        if set(basis_inv[file_id].children.keys()) == maybe_empty_dirs[path]:
-            yield (path, None, file_id, None)
-            dirname = os.path.dirname(path)
-            if maybe_empty_dirs[dirname] is not None:
-                maybe_empty_dirs[dirname].add(basis_inv[file_id].name)
+    while maybe_empty_dirs:
+        for path in sorted(maybe_empty_dirs.keys(), reverse=True):
+            removed_children = maybe_empty_dirs.pop(path)
+            if removed_children is None:
+                # Stuff was added to this directory in this revision,
+                # don't bother
+                continue
+            file_id = basis_inv.path2id(path)
+            # Is this directory really empty ?
+            if set(basis_inv[file_id].children.keys()) == removed_children:
+                yield (path, None, file_id, None)
+                dirname = os.path.dirname(path)
+                if maybe_empty_dirs[dirname] is not None:
+                    maybe_empty_dirs[dirname].add(basis_inv[file_id].name)
 
 
 def create_directory_texts(texts, invdelta):
@@ -231,7 +242,8 @@
     def generate_stream():
         for (old_path, new_path, fileid, ie) in invdelta:
             if old_path is None and ie.kind == "directory":
-                record = FulltextContentFactory((fileid, ie.revision), (), None, "")
+                record = FulltextContentFactory((fileid, ie.revision), (),
+                                                None, "")
                 record.parents = ()
                 yield record
     texts.insert_record_stream(generate_stream())
@@ -264,7 +276,10 @@
     if expected_files != files:
         raise AssertionError
     lookup = [m.__getitem__ for m, f in manifest_parents[:2]]
-    (manifest, flags) = manifest_and_flags_from_tree(parent_trees, tree,
+    for i in range(2):
+        if len(lookup) <= i:
+            lookup.append({}.__getitem__)
+    (manifest, flags, unusual_fileids) = manifest_and_flags_from_tree(parent_trees, tree,
         mapping, lookup)
     if set(manifest.keys()) != set(expected_manifest.keys()):
         raise AssertionError("Different contents in manifests: %r, %r" %
@@ -313,6 +328,18 @@
                 ret.append(self._inventories[revid])
         return ret
 
+    def _lookup_file_target(self, key):
+        return str(self._symlink_targets[key]).decode("utf-8")
+
+    def _lookup_file_metadata(self, key):
+        try:
+            return self._text_metadata[key]
+        except KeyError:
+            (fileid, revision) = key
+            stream = self.target.texts.get_record_stream([key], 'unordered', True)
+            record = stream.next()
+            return (record.sha1, len(record.get_bytes_as("fulltext")))
+
     def _import_manifest_delta(self, manifest, flags, files, rev,
                                mapping):
         parent_invs = self._get_inventories(rev.parent_ids)
@@ -333,8 +360,8 @@
         invdelta = list(manifest_to_inventory_delta(mapping.generate_file_id,
                 basis_inv, other_inv, (basis_manifest, basis_flags),
                 (manifest, flags), rev.revision_id, files,
-                self._text_metadata.__getitem__,
-                self._symlink_targets.__getitem__))
+                self._lookup_file_metadata,
+                self._lookup_file_target))
         return basis_inv, invdelta
 
     def _get_target_fulltext(self, key):
@@ -342,31 +369,37 @@
             return self._symlink_targets[key]
         return self._target_overlay.get_file_fulltext(key)
 
-    def _unpack_texts(self, cg, mapping, filetext_map, pb):
+    def _create_text_record(self, fileid, revision, parents, kind, fulltext):
+        key = (fileid, revision)
+        if kind == "symlink":
+            self._symlink_targets[key] = fulltext
+            bzr_fulltext = ""
+        else:
+            (meta, bzr_fulltext) = deserialize_file_text(str(fulltext))
+        record = FulltextContentFactory(key, [(fileid, p) for p in parents],
+                osutils.sha_string(bzr_fulltext), bzr_fulltext)
+        self._text_metadata[key] = (record.sha1, len(bzr_fulltext))
+        return record
+
+    def _unpack_texts(self, cg, mapping, kind_map, pb):
         i = 0
         # Texts
-        while 1:
+        while True:
             f = mercurial.changegroup.getchunk(cg)
             if not f:
                 break
             i += 1
-            pb.update("fetching texts", i, len(filetext_map))
+            pb.update("fetching texts", i, len(kind_map))
             fileid = mapping.generate_file_id(f)
-            chunkiter = mercurial.changegroup.chunkiter(cg)
+            itertextchunks = chunkiter(cg)
             def get_text(node):
-                key = iter(filetext_map[fileid][node]).next()
+                key = iter(kind_map[fileid][node]).next()
                 return self._get_target_fulltext(key)
-            for fulltext, hgkey, hgparents, csid in unpack_chunk_iter(chunkiter, get_text):
-                for revision, (kind, parents) in filetext_map[fileid][hgkey].iteritems():
-                    key = (fileid, revision)
-                    if kind == "symlink":
-                        self._symlink_targets[key] = fulltext
-                        bzr_fulltext = ""
-                    else:
-                        bzr_fulltext = fulltext
-                    record = FulltextContentFactory(key, [(fileid, p) for p in parents], osutils.sha_string(bzr_fulltext), bzr_fulltext)
-                    self._text_metadata[key] = (record.sha1, len(bzr_fulltext))
-                    yield record
+            for fulltext, hgkey, hgparents, csid in unpack_chunk_iter(itertextchunks, get_text):
+                for revision, kind in kind_map[fileid][hgkey].iteritems():
+                    text_parents = ()
+                    yield self._create_text_record(fileid, revision,
+                            text_parents, kind, fulltext)
 
     def _add_inventories(self, todo, mapping, pb):
         assert isinstance(todo, list)
@@ -444,7 +477,66 @@
                 return r
         raise AssertionError
 
-    def _unpack_manifests(self, chunkiter, mapping, filetext_map, todo, pb):
+    def _determine_text_parents(self, parents, path, fileid, revid, kind_map):
+        ret = []
+        for parent in parents:
+            tp = self._determine_text_parent(parent, path, fileid, revid, kind_map)
+            if tp is not None:
+                ret.append(tp)
+        return ret
+
+    def _determine_text_parent(self, parent, path, fileid, revid, kind_map):
+        path2id = getattr(parent, "path2id", None)
+        if path2id is None: # manifest
+            parent_node = parent.get(path)
+            if parent_node is None:
+                # Didn't exist in parent
+                return None
+            revisions = kind_map[fileid][parent_node].keys()
+            tp = self._find_most_recent_ancestor(revisions, revid)
+            return tp
+        elif path2id(path) == fileid:
+            # FIXME: Handle situation where path is not actually in
+            # parent
+            return parent[fileid].revision
+        else:
+            return None
+
+    def _process_manifest(self, manifest, flags, revid, mapping, kind_map):
+        """Process a manifest.
+
+        :param manifest: Mercurial manifest (dict of path -> node)
+        :param flags: Mercurial manifest flags (dict of path -> mode)
+        :param revid: Bazaar revision id
+        :param mapping: Bzr<->Hg mapping to use
+        :param kind_map: Mapping of (fileid, node, revid) -> kind
+        """
+        self._target_overlay.remember_manifest(revid,
+            self._revisions[revid].parent_ids, (manifest, flags))
+        if not self._files[revid]:
+            # Avoid fetching inventories and parent manifests
+            # unnecessarily
+            return
+        rev = self._revisions[revid]
+        parents = []
+        for previd in rev.parent_ids:
+            try:
+                inv = self.target.get_inventory(previd)
+            except errors.NoSuchRevision:
+                parents.append(self._target_overlay.get_manifest_and_flags_by_revid(previd)[0])
+            else:
+                parents.append(inv)
+        for path in self._files[revid]:
+            assert type(path) is str
+            fileid = mapping.generate_file_id(path)
+            if not path in manifest:
+                # Path no longer exists
+                continue
+            kind = flags_kind(flags, path)
+            node = manifest[path]
+            kind_map[fileid][node][revid] = kind
+
+    def _unpack_manifests(self, chunkiter, mapping, kind_map, todo, pb):
         """Unpack the manifest deltas.
 
         :param chunkiter: Iterator over delta chunks for the manifest.
@@ -458,42 +550,8 @@
             for revid in self._manifest2rev_map[hgkey]:
                 todo.append(revid)
                 yield (revid, self._revisions[revid].parent_ids, fulltext)
-                self._target_overlay.remember_manifest(revid,
-                    self._revisions[revid].parent_ids, (manifest, flags))
-                if not self._files[revid]:
-                    # Avoid fetching inventories and parent manifests
-                    # unnecessarily
-                    continue
-                rev = self._revisions[revid]
-                parents = []
-                for previd in rev.parent_ids:
-                    try:
-                        inv = self.target.get_inventory(previd)
-                    except errors.NoSuchRevision:
-                        parents.append(self._target_overlay.get_manifest_and_flags_by_revid(previd)[0])
-                    else:
-                        parents.append(inv)
-                for path in self._files[revid]:
-                    assert type(path) is str
-                    fileid = mapping.generate_file_id(path)
-                    if not path in manifest:
-                        # Path still has to actually exist..
-                        continue
-                    kind = flags_kind(flags, path)
-                    text_parents = []
-                    for parent in parents:
-                        path2id = getattr(parent, "path2id", None)
-                        if path2id is None: # manifest
-                            node = parent.get(path)
-                            if node is None:
-                                continue
-                            revisions = filetext_map[fileid][node]
-                            tp = self._find_most_recent_ancestor(revisions.keys(), revid)
-                            text_parents.append(tp)
-                        elif path2id(path) == fileid:
-                            # FIXME: Handle situation where path is not actually in parent
-                            text_parents.append(parent[fileid].revision)
-                    filetext_map[fileid][manifest[path]][revid] = (kind, text_parents)
+                self._process_manifest(manifest, flags, revid, mapping,
+                                       kind_map)
 
     def addchangegroup(self, cg, mapping):
         """Import a Mercurial changegroup into the target repository.
@@ -502,26 +560,27 @@
         :param mapping: Mercurial mapping
         """
         # Changesets
-        chunkiter = mercurial.changegroup.chunkiter(cg)
+        changesetchunks = chunkiter(cg)
         pb = ui.ui_factory.nested_progress_bar()
         try:
-            self._unpack_changesets(chunkiter, mapping, pb)
+            self._unpack_changesets(changesetchunks, mapping, pb)
         finally:
             pb.finished()
         # Manifests
-        manifestchunks = mercurial.changegroup.chunkiter(cg)
-        filetext_map = defaultdict(lambda: defaultdict(dict))
+        manifestchunks = chunkiter(cg)
+        kind_map = defaultdict(lambda: defaultdict(dict))
         todo = []
         pb = ui.ui_factory.nested_progress_bar()
         try:
-            self._target_overlay.remember_manifest_texts(self._unpack_manifests(manifestchunks, mapping, filetext_map, todo, pb))
+            self._target_overlay.remember_manifest_texts(
+                self._unpack_manifests(manifestchunks, mapping, kind_map, todo, pb))
         finally:
             pb.finished()
         # Texts
         pb = ui.ui_factory.nested_progress_bar()
         try:
             self.target.texts.insert_record_stream(
-                self._unpack_texts(cg, mapping, filetext_map, pb))
+                self._unpack_texts(cg, mapping, kind_map, pb))
         finally:
             pb.finished()
         # Adding actual data
 
=== modified file 'info.py'
--- info.py	2010-08-05 23:55:52 +0000
+++ info.py	2011-03-23 21:41:04 +0000
@@ -1,7 +1,6 @@
 bzr_plugin_name = 'hg'
 
-bzr_compatible_versions = [(1, x, 0) for x in [13, 14, 15, 16, 17, 18]] + \
-                          [(2, x, 0) for x in [0, 1, 2]]
+bzr_compatible_versions = [(2, x, 0) for x in [3, 4]]
 
 bzr_minimum_version = bzr_compatible_versions[0]
 
@@ -11,4 +10,6 @@
 
 bzr_control_formats = {"Mercurial": {'.hg/': None}}
 
-hg_compatible_versions = ["1.6"]
+hg_compatible_versions = [(1, 6), (1, 7), (1, 8)]
+
+hg_compatible_version_strings = ["%d.%d" % x for x in hg_compatible_versions]
 
=== modified file 'mapping.py'
--- mapping.py	2010-02-08 13:32:23 +0000
+++ mapping.py	2011-03-23 21:41:04 +0000
@@ -42,12 +42,15 @@
     """Convert a Mercurial 'convert_revision' extra to a Bazaar 'converted-from' revprop.
 
     """
-    (kind, revid) = rev.split(":", 1)
+    try:
+        (kind, revid) = rev.split(":", 1)
+    except ValueError:
+        return "unspecified %s\n" % rev
     if kind == "svn":
         url, revnum = revid.rsplit('@', 1)
         revnum = int(revnum)
         parts = url.split('/', 1)
-        uuid = parts.pop(0)[4:]
+        uuid = parts.pop(0)
         mod = ''
         if parts:
             mod = parts[0]
@@ -65,7 +68,9 @@
         (uuid, revnumstr, branchpathstr) = revid.split(":", 2)
         revnum = int(revnumstr)
         branchpath = urllib.unquote(branchpathstr)
-        return "svn:%s%s@%s" % (uuid, branchpath, revnum)
+        return "svn:%s/%s@%s" % (uuid, branchpath, revnum)
+    elif kind == "unspecified":
+        return revid
     else:
         raise KeyError("Unknown VCS '%s'" % kind)
 
@@ -175,6 +180,7 @@
     :param parent_node_lookup: 2-tuple with functions to look up the nodes
         of paths in the tree's parents
     """
+    assert len(parent_node_lookup) == 2
     unusual_fileids = {}
     def get_text_parents(path):
         assert type(path) == str
@@ -184,6 +190,7 @@
                 ret.append(lookup(path))
             except KeyError:
                 ret.append(mercurial.node.nullid)
+        assert len(ret) == 2
         return tuple(ret)
     manifest = {}
     flags = {}
@@ -263,7 +270,7 @@
         elif len(revision_id) == 40:
             hexhgrevid = revision_id
         else:
-            raise AssertionError
+            raise AssertionError("Invalid hg id %r" % revision_id)
         return "%s:%s" % (cls.revid_prefix, hexhgrevid)
 
     @classmethod
 
=== modified file 'overlay.py'
--- overlay.py	2009-11-26 21:33:32 +0000
+++ overlay.py	2011-03-23 21:41:04 +0000
@@ -122,7 +122,7 @@
         """
         if self.manifests_vf is not None:
             self.manifests_vf.insert_record_stream(
-                ((FulltextContentFactory((revid,), [(p,) for p in parent_revids] , None, text) for (revid, parent_revids, text) in entries)))
+                ((FulltextContentFactory((revid,), [(p,) for p in parent_revids], None, str(text)) for (revid, parent_revids, text) in entries)))
 
     def _get_cached_manifest(self, revid):
         """Attempt to retrieve a cached manifest.
 
=== modified file 'parsers.py'
--- parsers.py	2010-02-08 13:32:23 +0000
+++ parsers.py	2011-03-23 21:41:04 +0000
@@ -25,6 +25,7 @@
 """
 
 import mercurial.changelog
+import mercurial.changegroup
 import mercurial.manifest
 import mercurial.mdiff
 import mercurial.node
@@ -81,6 +82,7 @@
     :param text: Text to parse
     :return: Tuple with (manifest, user, (time, timezone), files, desc, extra)
     """
+    text = str(text)
     last = text.index("\n\n")
     desc = text[last + 2:].decode("utf-8")
     l = text[:last].split('\n')
@@ -179,3 +181,34 @@
             node = mercurial.node.hex(node)
         lines.append("%s\0%s%s\n" % (path, node, flags.get(path, "")))
     return "".join(lines)
+
+
+def serialize_file_text(meta, text):
+    if meta or text.startswith('\1\n'):
+        mt = ["%s: %s\n" % (k, v) for k, v in sorted(meta.iteritems())]
+        text = "\1\n%s\1\n%s" % ("".join(mt), text)
+    return text
+
+
+def deserialize_file_text(text):
+    if not text.startswith("\1\n"):
+        return ({}, text)
+    s = text.index('\1\n', 2)
+    mt = text[2:s]
+    meta = {}
+    for l in mt.splitlines():
+        k, v = l.split(": ", 1)
+        meta[k] = v
+    return meta, text[s+2:]
+
+
+def chunkiter(source, progress=None):
+    """iterate through the chunks in source, yielding a sequence of chunks
+    (strings)"""
+    while 1:
+        c = mercurial.changegroup.getchunk(source)
+        if not c:
+            break
+        elif progress is not None:
+            progress()
+        yield c
 
=== modified file 'repository.py'
--- repository.py	2010-07-31 18:38:03 +0000
+++ repository.py	2011-03-23 21:41:04 +0000
@@ -62,8 +62,23 @@
     support the repository format.
     """
     rich_root_data = True
-
-    def initialize(self, url, shared=False, _internal=False):
+    fast_deltas = True
+    supports_leaving_lock = False
+    supports_funky_characters = True
+    supports_external_lookups = False
+    supports_full_versioned_files = False
+
+    @property
+    def _matchingbzrdir(self):
+        from bzrlib.plugins.hg.dir import HgControlDirFormat
+        return HgControlDirFormat()
+
+    def initialize(self, controldir, shared=False, _internal=False):
+        from bzrlib.plugins.hg.dir import HgDir
+        if shared:
+            raise errors.IncompatibleFormat(self, controldir._format)
+        if isinstance(controldir, HgDir):
+            return controldir.open_repository()
         raise errors.UninitializableFormat(self)
 
     def is_supported(self):
@@ -126,6 +141,7 @@
             return ancestry_cache[some_revision_id]
         except KeyError:
             pass
+        assert some_revision_id in all_relevant_revisions
         ancestry = set()
         # add what can be reached from some_revision_id
         # TODO: must factor this trivial iteration in bzrlib.graph cleanly.
@@ -287,6 +303,8 @@
 
     _serializer = None
 
+    chk_bytes = None
+
     def __init__(self, hgrepo, hgdir, lockfiles):
         ForeignRepository.__init__(self, HgRepositoryFormat(), hgdir, lockfiles)
         self._hgrepo = hgrepo
@@ -303,6 +321,9 @@
             self.inventories = None
             self.texts = None
 
+    def revision_graph_can_have_wrong_parents(self):
+        return False
+
     def _warn_if_deprecated(self):
         # This class isn't deprecated
         pass
@@ -341,20 +362,33 @@
 
     def lookup_bzr_revision_id(self, revision_id):
         """See ForeignRepository.lookup_bzr_revision_id()."""
-        assert type(revision_id) is str
+        assert type(revision_id) is str, "invalid revid: %r" % revision_id
         # TODO: Handle round-tripped revisions
         try:
             return mapping_registry.revision_id_bzr_to_foreign(revision_id)
         except errors.InvalidRevisionId:
             raise errors.NoSuchRevision(self, revision_id)
 
+    def get_parent_map(self, revids):
+        ret = {}
+        for revid in revids:
+            hgrevid, mapping = self.lookup_bzr_revision_id(revid)
+            # FIXME: what about extra parents?
+            hgparents = self._hgrepo.changelog.parents(hgrevid)
+            ret[revid] = as_bzr_parents(hgparents, self.lookup_foreign_revision_id)
+        return ret
+
     def get_revision(self, revision_id):
-        assert type(revision_id) is str
+        if not type(revision_id) is str:
+            raise errors.InvalidRevisionId(revision_id, self)
         hgrevid, mapping = self.lookup_bzr_revision_id(revision_id)
+        assert mapping is not None
         hgchange = self._hgrepo.changelog.read(hgrevid)
         hgparents = self._hgrepo.changelog.parents(hgrevid)
         parent_ids = as_bzr_parents(hgparents, self.lookup_foreign_revision_id)
-        return mapping.import_revision(revision_id, parent_ids, hgrevid, hgchange[0], hgchange[1].decode("utf-8"), hgchange[2], hgchange[4].decode("utf-8"), hgchange[5])[0]
+        return mapping.import_revision(revision_id, parent_ids, hgrevid,
+            hgchange[0], hgchange[1].decode("utf-8"), hgchange[2],
+            hgchange[4].decode("utf-8"), hgchange[5])[0]
 
     def iter_inventories(self, revision_ids, ordering=None):
         for revid in revision_ids:
@@ -365,6 +399,7 @@
         log = self._hgrepo.changelog.read(hgid)
         manifest = self._hgrepo.manifest.read(log[0])
         all_relevant_revisions = self.get_ancestry(revision_id)[1:] + [NULL_REVISION]
+
         pb = ui.ui_factory.nested_progress_bar()
         try:
             inv = manifest_to_inventory(self._hgrepo, hgid, log, manifest,
@@ -379,11 +414,18 @@
         return foreign_revid in self._hgrepo.changelog.nodemap
 
     def has_revision(self, revision_id):
+        if revision_id == NULL_REVISION:
+            return True
         try:
             return self.has_foreign_revision(self.lookup_bzr_revision_id(revision_id)[0])
         except errors.NoSuchRevision:
             return False
 
+    def get_commit_builder(self, branch, parents, config, timestamp=None,
+                           timezone=None, committer=None, revprops=None,
+                           revision_id=None):
+        raise NotImplementedError(self.get_commit_builder)
+
 
 class HgRemoteRepository(HgRepository):
 
 
=== modified file 'setup.py'
--- setup.py	2010-03-25 21:08:21 +0000
+++ setup.py	2011-03-23 21:41:04 +0000
@@ -1,4 +1,4 @@
-#!/usr/bin/env python2.4
+#!/usr/bin/env python
 
 from info import *
 
 
=== modified file 'tests/__init__.py'
--- tests/__init__.py	2010-07-31 12:16:16 +0000
+++ tests/__init__.py	2011-03-23 21:41:04 +0000
@@ -30,6 +30,7 @@
         'test_mapping',
         'test_parsers',
         'test_pull',
+        'test_fetch',
         ]
 
     suite.addTest(loader.loadTestsFromModuleNames(["%s.%s" % (__name__, i) for i in testmod_names]))
 
=== modified file 'tests/test_branch.py'
--- tests/test_branch.py	2009-10-12 09:41:47 +0000
+++ tests/test_branch.py	2011-03-23 21:41:04 +0000
@@ -18,8 +18,8 @@
     TestCase,
     )
 
-from bzrlib.plugins.hg import (
-    HgBzrDirFormat,
+from bzrlib.plugins.hg.dir import (
+    HgControlDirFormat,
     )
 from bzrlib.plugins.hg.branch import (
     HgBranchFormat,
@@ -28,13 +28,13 @@
 class BranchFormatTests(TestCase):
 
     def test_description(self):
-        self.assertEquals("Mercurial Branch", 
+        self.assertEquals("Mercurial Branch",
             HgBranchFormat().get_format_description())
 
 
 class ForeignTestsBranchFactory(object):
 
     def make_empty_branch(self, transport):
-        return HgBzrDirFormat().initialize_on_transport(transport).open_branch()
+        return HgControlDirFormat().initialize_on_transport(transport).open_branch()
 
     make_branch = make_empty_branch
 
=== modified file 'tests/test_dir.py'
--- tests/test_dir.py	2010-07-31 12:25:11 +0000
+++ tests/test_dir.py	2011-03-23 21:41:04 +0000
@@ -22,21 +22,28 @@
     TestCase,
     )
 
-from bzrlib.plugins.hg import (
-    HgBzrDirFormat,
+from bzrlib.plugins.hg.dir import (
+    HgControlDirFormat,
     )
 
 
-class HgBzrDirFormatTests(TestCase):
+class HgControlDirFormatTests(TestCase):
 
     def test_eq(self):
-        format1 = HgBzrDirFormat()
-        format2 = HgBzrDirFormat()
+        format1 = HgControlDirFormat()
+        format2 = HgControlDirFormat()
         self.assertEquals(format1, format2)
         self.assertEquals(format1, format1)
         bzr_format = format_registry.make_bzrdir("default")
         self.assertNotEquals(bzr_format, format1)
 
+    def test_hash(self):
+        format1 = HgControlDirFormat()
+        format2 = HgControlDirFormat()
+        self.assertEquals(hash(format1), hash(format2))
+        bzr_format = format_registry.make_bzrdir("default")
+        self.assertNotEquals(hash(bzr_format), hash(format1))
+
     def test_network_name(self):
-        format = HgBzrDirFormat()
+        format = HgControlDirFormat()
         self.assertEquals("hg", format.network_name())
 
=== added file 'tests/test_fetch.py'
--- tests/test_fetch.py	1970-01-01 00:00:00 +0000
+++ tests/test_fetch.py	2011-03-23 21:41:04 +0000
@@ -0,0 +1,53 @@
+# Copyright (C) 2010 Leonid Borisenko <[e-mail]>
+
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+"""Tests for fetching from Mercurial into Bazaar."""
+
+from bzrlib.plugins.hg.dir import HgControlDirFormat
+from bzrlib.plugins.hg.ui import ui as hgui
+from bzrlib.tests import TestCaseWithTransport
+
+import mercurial.localrepo
+
+class TestFetching(TestCaseWithTransport):
+
+    def test_recursive_removing_of_empty_directories(self):
+        # Create files in directory of Mercurial repository.
+        self.build_tree([
+            "hg/",
+            "hg/f1",
+            "hg/d1/",
+            "hg/d1/d2/",
+            "hg/d1/d2/f2",
+        ])
+
+        # Create Mercurial repository itself and fill it's history.
+        hgrepo = mercurial.localrepo.localrepository(hgui(), "hg", create=True)
+        hgrepo[None].add(["f1", "d1/d2/f2"])
+        hgrepo.commit("Initial commit")
+        hgrepo[None].remove(["d1/d2/f2"], unlink=True)
+        hgrepo.commit("Remove file f2, so parent directories d2, d1 are empty")
+
+        # Import history from Mercurial repository into Bazaar repository.
+        bzrtree = self.make_branch_and_tree('bzr')
+        hgdir = HgControlDirFormat().open(self.get_transport('hg'))
+        bzrtree.pull(hgdir.open_branch())
+
+        # As file f2 was deleted, directories d1 and d2 should not exists.
+        self.failIfExists('bzr/d1')
+
+        # Self-assurance check that history was really imported.
+        self.failUnlessExists('bzr/f1')
 
=== modified file 'tests/test_mapping.py'
--- tests/test_mapping.py	2010-02-08 13:32:23 +0000
+++ tests/test_mapping.py	2011-03-23 21:41:04 +0000
@@ -25,6 +25,8 @@
 from bzrlib.plugins.hg.mapping import (
     ExperimentalHgMapping,
     HgMappingv1,
+    convert_converted_from,
+    generate_convert_revision,
     as_bzr_parents,
     as_hg_parents,
     escape_path,
@@ -41,7 +43,7 @@
 from bzrlib.tests import (
     TestCase,
     )
-       
+
 class HgMappingTests(object):
 
     def test_revid_foreign_to_bzr(self):
@@ -168,3 +170,33 @@
         m = {"a" * 20: "reva"}
         self.assertEquals(("reva",), 
                 as_bzr_parents(("a" * 20, nullid), m.__getitem__))
+
+
+class ConvertConvertedFromTests(TestCase):
+
+    def test_unspecified(self):
+        self.assertEquals("unspecified foo\n",
+            convert_converted_from("foo"))
+
+    def test_svn(self):
+        self.assertEquals("svn myuuid:42:path\n",
+            convert_converted_from("svn:myuuid/path@42"))
+
+    def test_unknown(self):
+        self.assertRaises(KeyError,
+            convert_converted_from, "unknown:myuuid:42:path")
+
+
+class GenerateConvertRevisionTests(TestCase):
+
+    def test_generate_convert_revision_svn(self):
+        self.assertEquals("svn:myuuid/path@42",
+            generate_convert_revision("svn myuuid:42:path"))
+
+    def test_generate_convert_revision_unspecified(self):
+        self.assertEquals("bla",
+            generate_convert_revision("unspecified bla"))
+
+    def test_generate_convert_revision_unknown(self):
+        self.assertRaises(KeyError,
+            generate_convert_revision, "bla bla")
 
=== modified file 'tests/test_parsers.py'
--- tests/test_parsers.py	2010-02-08 13:32:23 +0000
+++ tests/test_parsers.py	2011-03-23 21:41:04 +0000
@@ -17,13 +17,15 @@
 import mercurial
 
 from bzrlib.plugins.hg.parsers import (
+    deserialize_file_text,
     format_changeset,
     parse_changeset,
+    serialize_file_text,
     )
 from bzrlib.tests import (
     TestCase,
     )
-       
+
 class ChangesetFormatterTests(TestCase):
 
     def test_simple(self):
@@ -116,3 +118,12 @@
 Some
 commit
 message"""))
+
+
+class TextSerializers(TestCase):
+
+    def test_serialize(self):
+        self.assertEquals("\1\ncopy: bla\n\1\nfoo\n", serialize_file_text({"copy": "bla"}, "foo\n"))
+
+    def test_deserialize(self):
+        self.assertEquals(({"copy": "bla"}, "foo\n"), deserialize_file_text("\1\ncopy: bla\n\1\nfoo\n"))
 
=== modified file 'tests/test_pull.py'
--- tests/test_pull.py	2009-10-18 21:57:36 +0000
+++ tests/test_pull.py	2011-03-23 21:41:04 +0000
@@ -15,7 +15,7 @@
 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
 from bzrlib.inventory import Inventory
-from bzrlib.plugins.hg import HgBzrDirFormat
+from bzrlib.plugins.hg.dir import HgControlDirFormat
 from bzrlib.tests import TestCaseWithTransport
 
 import base64
@@ -30,7 +30,7 @@
     def setUp(self):
         super(TestPulling, self).setUp()
         self.build_tree(['hg/', 'hg/a', 'hg/b', 'hg/dir/', 'hg/dir/c'])
-        hgdir = HgBzrDirFormat().initialize('hg')
+        hgdir = HgControlDirFormat().initialize('hg')
         self.tree = hgdir.open_workingtree()
         mode = os.lstat('hg/b').st_mode
         os.chmod('hg/b', mode | stat.S_IEXEC)
@@ -53,7 +53,7 @@
             file_id='hg:dir')
         entry.revision = tip
         entry = revone_inventory.add_path('dir/c', kind='file',
-            file_id='hg:dir:c')
+            file_id='hg:dir_sc')
         entry.revision = tip
         entry.text_size = len('contents of hg/dir/c\n')
         entry.text_sha1 = "958be752affac0fee70471331b96fb3fc1809425"
@@ -68,7 +68,7 @@
         self.revtwo_inventory = copy.deepcopy(revone_inventory)
         tip = self.tree.last_revision()
         entry = self.revtwo_inventory.add_path('dir/d', kind='file',
-            file_id='hg:dir:d')
+            file_id='hg:dir_sd')
         entry.revision = tip
         entry.text_size = len('contents of hg/dir/d\n')
         entry.text_sha1 = "f48fc342f707bfb4711790e1813c0df4d44e1a23"
@@ -91,7 +91,7 @@
         self.tree.commit('change dir/c')
         self.revfour_inventory = copy.deepcopy(self.revthree_inventory)
         tip = self.tree.last_revision()
-        entry = self.revfour_inventory['hg:dir:c']
+        entry = self.revfour_inventory['hg:dir_sc']
         entry.revision = tip
         entry.text_size = len('new contents')
         entry.text_sha1 = "7ffa72b76d5d66da37f4b614b7a822c01f23c183"
 
=== modified file 'tests/test_repository.py'
--- tests/test_repository.py	2009-11-12 22:57:40 +0000
+++ tests/test_repository.py	2011-03-23 21:41:04 +0000
@@ -15,11 +15,11 @@
 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
 
-from bzrlib.plugins.hg import (
-    HgBzrDirFormat,
+from bzrlib.plugins.hg.dir import (
+    HgControlDirFormat,
     )
 
 class ForeignTestsRepositoryFactory(object):
 
     def make_repository(self, transport):
-        return HgBzrDirFormat().initialize_on_transport(transport).open_repository()
+        return HgControlDirFormat().initialize_on_transport(transport).open_repository()
 
=== modified file 'ui.py'
--- ui.py	2009-09-29 14:41:23 +0000
+++ ui.py	2011-03-23 21:41:04 +0000
@@ -27,19 +27,19 @@
 
     def debug(self, *msg):
         for x in msg:
-            trace.mutter("hg: %s" % x)
+            trace.mutter("hg: %s" % x.rstrip())
 
     def warn(self, *msg):
         for x in msg:
-            trace.warning("hg: %s" % x)
+            trace.warning("hg: %s" % x.rstrip())
 
     def note(self, *msg):
         for x in msg:
-            trace.mutter("hg: %s" % x)
+            trace.mutter("hg: %s" % x.rstrip())
 
     def status(self, *msg):
         for x in msg:
-            trace.mutter("hg: %s" % x)
+            trace.mutter("hg: %s" % x.rstrip())
 
     def username(self):
         return config.GlobalConfig().username()
 
=== modified file 'util.py'
--- util.py	2009-10-15 17:27:10 +0000
+++ util.py	2011-03-23 21:41:04 +0000
@@ -1,4 +1,4 @@
-# Copyright (C) 2009 Jelmer Vernooij <[e-mail]>
+# Copyright (C) 2009-2010 Jelmer Vernooij <[e-mail]>
 #
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
 
=== modified file 'versionedfiles.py'
--- versionedfiles.py	2009-12-05 01:58:37 +0000
+++ versionedfiles.py	2011-03-23 21:41:04 +0000
@@ -75,6 +75,8 @@
                     ret[(revid, )] = tuple((x,) for x in as_bzr_parents(self._revlog.parents(hg_ref), self._reverse_lookup_id))
                 except LookupError:
                     ret[(revid, )] = None
+                if ret[(revid,)] == ():
+                    ret[(revid,)] = (NULL_REVISION,)
         return ret
 
     def keys(self):
 
=== modified file 'workingtree.py'
--- workingtree.py	2010-08-05 23:55:52 +0000
+++ workingtree.py	2011-03-23 21:41:04 +0000
@@ -16,6 +16,11 @@
 
 """Mercurial working tree support."""
 
+from bzrlib import osutils
+
+from bzrlib.errors import (
+    IncompatibleFormat,
+    )
 from bzrlib.inventory import (
     Inventory,
     )
@@ -38,10 +43,21 @@
     support the working tree format.
     """
 
+    @property
+    def _matchingbzrdir(self):
+        from bzrlib.plugins.hg.dir import HgControlDirFormat
+        return HgControlDirFormat()
+
     def get_format_description(self):
         """See WorkingTreeFormat.get_format_description()."""
         return "Mercurial Working Tree"
 
+    def initialize(self, to_bzrdir):
+        from bzrlib.plugins.hg.dir import HgDir
+        if not isinstance(to_bzrdir, HgDir):
+            raise IncompatibleFormat(self, to_bzrdir._format)
+        return to_bzrdir.create_workingtree()
+
 
 class HgWorkingTree(bzrlib.workingtree.WorkingTree):
     """An adapter to mercurial repositories for bzr WorkingTree obejcts."""
@@ -50,30 +66,44 @@
         self._inventory = Inventory()
         self._hgrepo = hgrepo
         self.bzrdir = hgdir
+        self.repository = hgdir.open_repository()
         self._control_files = lockfiles
         self._branch = hgbranch
         self._format = HgWorkingTreeFormat()
         self._transport = hgdir.get_workingtree_transport(None)
         self.basedir = hgdir.root_transport.local_abspath(".")
+        self._detect_case_handling()
+        self._rules_searcher = None
         self.views = self._make_views()
 
+    def flush(self):
+        pass
+
     @needs_write_lock
-    def add(self, files, ids=None):
+    def add(self, files, ids=None, kinds=None):
         # hg does not use ids, toss them out
         if isinstance(files, basestring):
             files = [files]
+        if kinds is None:
+            kinds = [osutils.file_kind(self.abspath(f)) for f in files]
+        hg_files = []
+        for file, kind in zip(files, kinds):
+            if kind == "directory":
+                continue
+            hg_files.append(file.encode('utf-8'))
+
         # hg does not canonicalise paths : make them absolute
-        paths = [(file).encode('utf8') for file in files]
-        self._hgrepo[None].add(paths)
+        self._hgrepo[None].add(hg_files)
 
     @needs_write_lock
-    def commit(self, message, revprops=None, *args, **kwargs):
+    def commit(self, message=None, revprops=None, *args, **kwargs):
         # TODO: selected file lists -> match function
         if revprops is None:
             extra = {}
         else:
             extra = revprops
-        self._hgrepo.commit(message, extra=extra)
+        hgid = self._hgrepo.commit(message.encode("utf-8"), extra=extra, force=True)
+        return self.bzrdir.open_repository().lookup_foreign_revision_id(hgid)
 
     def _reset_data(self):
         """Reset all cached data."""