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

[Jelmer Vernooij]

Fix compatibility with 2.4 by providing a custom ControlDir.sprout() implementation.

Fetch all revisions referenced by tags, even if those revisions are not in the
ancestry of tip.

Unmerged revisions

=== modified file '.bzrignore'
--- .bzrignore	2009-01-30 14:58:20 +0000
+++ .bzrignore	2011-03-23 20:12:35 +0000
@@ -5,3 +5,4 @@
 build
 .plugins
 ./_lib
+.testrepository

=== added file '.testr.conf'
--- .testr.conf	1970-01-01 00:00:00 +0000
+++ .testr.conf	2011-03-23 20:12:35 +0000
@@ -0,0 +1,4 @@
+[DEFAULT]
+test_command=BZR_PLUGINS_AT=git@`pwd` bzr selftest ^bzrlib.plugins.git. Git --subunit $IDOPTION $LISTOPT
+test_id_option=--load-list $IDFILE
+test_list_option=--list

=== modified file 'NEWS'
--- NEWS	2010-08-12 20:25:43 +0000
+++ NEWS	2011-03-23 20:12:35 +0000
@@ -1,17 +1,68 @@
-0.5.3	UNRELEASED
+0.5.5	UNRELEASED
+
+ BUG FIXES
+
+  * Fix encoding handling in Git working trees. (Jelmer Vernooij, #393038)
+
+  * Use transports internally in "bzr git-import".
+    (Jelmer Vernooij, #733919)
+
+  * Provide custom GitDir.sprout() implementation for compatibility with bzr 2.4.
+    (Jelmer Vernooij, #717937)
+
+  * Revisions attached to tags that are not in the tips ancestry are now fetched.
+    (Jelmer Vernooij, #309682)
+
+ API COMPLETENESS
+
+  * Implement LocalGitControlDir.clone_on_transport. (Jelmer Vernooij, #721899)
+
+ COMPATIBILITY
+
+  * Drop support for Bazaar < 2.3. (Jelmer Vernooij)
+
+0.5.4	2011-02-10
+
+ BUG FIXES
+
+  * Fix test suite compatibility with Bazaar 2.2. (Max Bowsher, #707434)
+
+  * Fix compatibility with older versions of python-tdb.
+    (Jelmer Vernooij, #707735)
+
+  * Fix 'bzr git-import' from remote repositories. (Jelmer Vernooij, #706990)
+
+  * Cope with tags when doing local fetches. (Jelmer Vernooij, #675637)
+
+0.5.3	2011-01-21
 
  BUG FIXES
 
   * Add in an empty git repository now works. (Jelmer Vernooij, #603823)
 
   * Support opening of repositories over HTTP where the HTTP server
-    doesn't allow directory access. (Jelmer Vernooij)
+    doesn't allow directory access. (Jelmer Vernooij, #617078)
 
   * Support non-ascii characters in tag names. (Jelmer Vernooij, #616995)
 
+  * Mark as compatible with bzr 2.3, 2.4. (Jelmer Vernooij)
+
+  * Cope with unknown refs. (Jelmer Vernooij, #666443)
+
+  * Don't peel tags automatically when pushing back.
+    (Jelmer Vernooij, #675231)
+
+  * Fix `bzr-receive-pack` and `bzr-upload-pack`. (Jelmer Vernooij, #681193)
+
  FEATURES
 
-  * Remove all remaining dependencies on C git. (Jelmer Vernooij)
+  * Remove all remaining dependencies on C git. (Jelmer Vernooij, #348238)
+
+  * Add some basic documentation in 'bzr help git'. (Jelmer Vernooij, #605394)
+
+  * Add --signoff option to 'bzr git-apply'. (Jelmer Vernooij)
+
+  * Add --force option to 'bzr git-apply'. (Jelmer Vernooij)
 
 0.5.2	2010-07-30
 

=== modified file 'README'
--- README	2009-05-09 14:22:48 +0000
+++ README	2011-03-23 20:12:35 +0000
@@ -1,9 +1,9 @@
 bzr-git, a plugin for bzr that adds git support.
 
-This was originally written as a proof of concept at Europython 2006 by 
-Robert Collins, using stgit's convenience methods for accessing gits head 
-and parsing git output. Later, it was adapted to use James Westby's Python 
-Git module (which had by then be renamed to "Dulwich") and extended to support 
+This was originally written as a proof of concept at Europython 2006 by
+Robert Collins, using stgit's convenience methods for accessing gits head
+and parsing git output. Later, it was adapted to use James Westby's Python
+Git module (which had by then be renamed to "Dulwich") and extended to support
 push and pull by Jelmer Vernooij.
 
 Please see INSTALL for installation instructions, and TODO for future plans.

=== modified file 'TODO'
--- TODO	2009-05-09 14:22:48 +0000
+++ TODO	2011-03-23 20:12:35 +0000
@@ -1,2 +1,2 @@
-- Push into git
-- Tests
+- "Roundtripping" push into git
+- More tests

=== modified file '__init__.py'
--- __init__.py	2010-08-12 20:25:43 +0000
+++ __init__.py	2011-03-23 20:12:35 +0000
@@ -43,16 +43,27 @@
 
 
 from bzrlib import (
-    bzrdir,
     errors as bzr_errors,
+<<<<<<< TREE
     osutils,
     transport,
     )
+=======
+    )
+
+from bzrlib.controldir import (
+    ControlDirFormat,
+    Prober,
+    format_registry,
+    network_format_registry as controldir_network_format_registry,
+    )
+
+>>>>>>> MERGE-SOURCE
 from bzrlib.foreign import (
     foreign_vcs_registry,
     )
-from bzrlib.lockable_files import (
-    TransportLock,
+from bzrlib.help_topics import (
+    topic_registry,
     )
 from bzrlib.transport import (
     register_lazy_transport,
@@ -61,9 +72,6 @@
 from bzrlib.commands import (
     plugin_cmds,
     )
-from bzrlib.version_info_formats.format_rio import (
-    RioVersionInfoBuilder,
-    )
 from bzrlib.send import (
     format_registry as send_format_registry,
     )
@@ -96,43 +104,36 @@
     import_dulwich()
     _versions_checked = True
 
-
-class GitBzrDirFormat(bzrdir.BzrDirFormat):
-
-    _lock_class = TransportLock
-
-    colocated_branches = True
-
-    def __eq__(self, other):
-        return type(self) == type(other)
-
-    def is_supported(self):
-        return True
-
-    def network_name(self):
-        return "git"
-
-
-class LocalGitBzrDirFormat(GitBzrDirFormat):
-    """The .git directory control format."""
-
-    @classmethod
-    def _known_formats(self):
-        return set([LocalGitBzrDirFormat()])
-
-    def open(self, transport, _found=None):
-        """Open this directory.
-
-        """
-        lazy_check_versions()
-        from bzrlib.plugins.git.transportgit import TransportRepo
-        gitrepo = TransportRepo(transport)
-        from bzrlib.plugins.git.dir import LocalGitDir, GitLockableFiles, GitLock
-        lockfiles = GitLockableFiles(transport, GitLock())
-        return LocalGitDir(transport, lockfiles, gitrepo, self)
-
-    @classmethod
-    def probe_transport(klass, transport):
+<<<<<<< TREE
+=======
+format_registry.register_lazy('git',
+    "bzrlib.plugins.git.dir", "LocalGitControlDirFormat",
+    help='GIT repository.', native=False, experimental=False,
+    )
+
+format_registry.register_lazy('git-bare',
+    "bzrlib.plugins.git.dir", "BareLocalGitControlDirFormat",
+    help='Bare GIT repository (no working tree).', native=False,
+    experimental=False,
+    )
+
+from bzrlib.revisionspec import revspec_registry
+revspec_registry.register_lazy("git:", "bzrlib.plugins.git.revspec",
+    "RevisionSpec_git")
+
+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.git.revspec", "RevisionSpec_git")
+else: # bzr < 2.4
+    from bzrlib.plugins.git.revspec import RevisionSpec_git
+    dwim_revspecs.append(RevisionSpec_git)
+
+>>>>>>> MERGE-SOURCE
+
+class LocalGitProber(Prober):
+
+    def probe_transport(self, transport):
         try:
             if not transport.has_any(['info/refs', '.git/branches',
                                       'branches']):
@@ -144,73 +145,46 @@
             raise bzr_errors.NotBranchError(path=transport.base)
         lazy_check_versions()
         import dulwich
-        format = klass()
+        from bzrlib.plugins.git.transportgit import TransportRepo
         try:
-            format.open(transport)
-            return format
+            gitrepo = TransportRepo(transport)
         except dulwich.errors.NotGitRepository, e:
             raise bzr_errors.NotBranchError(path=transport.base)
-        raise bzr_errors.NotBranchError(path=transport.base)
-
-    def get_format_description(self):
-        return "Local Git Repository"
-
-    def get_format_string(self):
-        return "Local Git Repository"
-
-    def initialize_on_transport(self, transport):
-        from bzrlib.transport.local import LocalTransport
-
-        if not isinstance(transport, LocalTransport):
-            raise NotImplementedError(self.initialize,
-                "Can't create Git Repositories/branches on "
-                "non-local transports")
-        lazy_check_versions()
-        from dulwich.repo import Repo
-        Repo.init(transport.local_abspath(".").encode(osutils._fs_enc))
-        return self.open(transport)
-
-    def is_supported(self):
-        return True
-
-
-class RemoteGitBzrDirFormat(GitBzrDirFormat):
-    """The .git directory control format."""
-
-    @classmethod
-    def _known_formats(self):
-        return set([RemoteGitBzrDirFormat()])
-
-    def open(self, transport, _found=None):
-        """Open this directory.
-
-        """
-        # we dont grok readonly - git isn't integrated with transport.
-        url = transport.base
-        if url.startswith('readonly+'):
-            url = url[len('readonly+'):]
-        if (not url.startswith("git://") and not url.startswith("git+")):
-            raise bzr_errors.NotBranchError(transport.base)
-        from bzrlib.plugins.git.remote import RemoteGitDir, GitSmartTransport
-        if not isinstance(transport, GitSmartTransport):
-            raise bzr_errors.NotBranchError(transport.base)
-        from bzrlib.plugins.git.dir import GitLockableFiles, GitLock
-        lockfiles = GitLockableFiles(transport, GitLock())
-        return RemoteGitDir(transport, lockfiles, self)
-
-    @classmethod
-    def probe_transport(klass, transport):
-        """Our format is present if the transport ends in '.not/'."""
+        else:
+            from bzrlib.plugins.git.dir import (
+                BareLocalGitControlDirFormat,
+                LocalGitControlDirFormat,
+                )
+            if gitrepo.bare:
+                return BareLocalGitControlDirFormat()
+            else:
+                return LocalGitControlDirFormat()
+
+    @classmethod
+    def known_formats(cls):
+        from bzrlib.plugins.git.dir import (
+            BareLocalGitControlDirFormat,
+            LocalGitControlDirFormat,
+            )
+        return set([BareLocalGitControlDirFormat(), LocalGitControlDirFormat()])
+
+
+class RemoteGitProber(Prober):
+
+    def probe_transport(self, transport):
         url = transport.base
         if url.startswith('readonly+'):
             url = url[len('readonly+'):]
         if (not url.startswith("git://") and not url.startswith("git+")):
             raise bzr_errors.NotBranchError(transport.base)
         # little ugly, but works
-        format = klass()
-        from bzrlib.plugins.git.remote import GitSmartTransport
+        from bzrlib.plugins.git.remote import (
+            GitSmartTransport,
+            RemoteGitControlDirFormat,
+            )
         if not isinstance(transport, GitSmartTransport):
             raise bzr_errors.NotBranchError(transport.base)
+<<<<<<< TREE
         return format
 
     def get_format_description(self):
@@ -223,18 +197,76 @@
         raise bzr_errors.UninitializableFormat(self)
 
 
+=======
+        return RemoteGitControlDirFormat()
+
+    @classmethod
+    def known_formats(cls):
+        from bzrlib.plugins.git.remote import RemoteGitControlDirFormat
+        return set([RemoteGitControlDirFormat()])
+
+
+if not getattr(Prober, "known_formats", None): # bzr < 2.4
+    from bzrlib.plugins.git.dir import (
+        LocalGitControlDirFormat, BareLocalGitControlDirFormat,
+        )
+    from bzrlib.plugins.git.remote import RemoteGitControlDirFormat
+    ControlDirFormat.register_format(LocalGitControlDirFormat())
+    ControlDirFormat.register_format(BareLocalGitControlDirFormat())
+    ControlDirFormat.register_format(RemoteGitControlDirFormat())
+ControlDirFormat.register_prober(LocalGitProber)
+ControlDirFormat.register_prober(RemoteGitProber)
+
+register_transport_proto('git://',
+        help="Access using the Git smart server protocol.")
+register_transport_proto('git+ssh://',
+        help="Access using the Git smart server protocol over SSH.")
+
+register_lazy_transport("git://", 'bzrlib.plugins.git.remote',
+                        'TCPGitSmartTransport')
+register_lazy_transport("git+ssh://", 'bzrlib.plugins.git.remote',
+                        'SSHGitSmartTransport')
+
+foreign_vcs_registry.register_lazy("git",
+    "bzrlib.plugins.git.mapping", "foreign_git", "Stupid content tracker")
+
+plugin_cmds.register_lazy("cmd_git_import", [], "bzrlib.plugins.git.commands")
+plugin_cmds.register_lazy("cmd_git_object", ["git-objects", "git-cat"],
+    "bzrlib.plugins.git.commands")
+plugin_cmds.register_lazy("cmd_git_refs", [], "bzrlib.plugins.git.commands")
+plugin_cmds.register_lazy("cmd_git_apply", [], "bzrlib.plugins.git.commands")
+
+>>>>>>> MERGE-SOURCE
 def update_stanza(rev, stanza):
     mapping = getattr(rev, "mapping", None)
     if mapping is not None and mapping.revid_prefix.startswith("git-"):
         stanza.add("git-commit", rev.foreign_revid)
 
+<<<<<<< TREE
 
 from bzrlib.revisionspec import revspec_registry
 try:
     from bzrlib.revisionspec import dwim_revspecs
 except ImportError:
     dwim_revspecs = None
+=======
+try:
+    from bzrlib.hooks import install_lazy_named_hook
+except ImportError: # Compatibility with bzr < 2.4
+    from bzrlib.version_info_formats.format_rio import (
+        RioVersionInfoBuilder,
+        )
+    RioVersionInfoBuilder.hooks.install_named_hook('revision', update_stanza,
+        "git commits")
+else:
+    install_lazy_named_hook("bzrlib.version_info_formats.format_rio",
+        "RioVersionInfoBuilder.hooks", "revision", update_stanza,
+        "git commits")
+
+
+>>>>>>> MERGE-SOURCE
 from bzrlib.transport import transport_server_registry
+<<<<<<< TREE
 from bzrlib.repository import network_format_registry as repository_network_format_registry
 from bzrlib.bzrdir import network_format_registry as bzrdir_network_format_registry
 
@@ -340,14 +372,72 @@
     unregister(send_format_registry, 'git')
     __registered = False
 
-
-try:
-    from bzrlib.diff import format_registry as diff_format_registry
-except ImportError:
-    pass
-else:
-    diff_format_registry.register_lazy('git', 'bzrlib.plugins.git.send',
-        'GitDiffTree', 'Git am-style diff format')
+=======
+transport_server_registry.register_lazy('git',
+    'bzrlib.plugins.git.server',
+    'serve_git',
+    'Git Smart server protocol over TCP. (default port: 9418)')
+
+
+from bzrlib.repository import (
+    format_registry as repository_format_registry,
+    network_format_registry as repository_network_format_registry,
+    )
+repository_network_format_registry.register_lazy('git',
+    'bzrlib.plugins.git.repository', 'GitRepositoryFormat')
+
+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.git.repository',
+        'GitRepositoryFormat')
+
+from bzrlib.branch import (
+    network_format_registry as branch_network_format_registry,
+    )
+branch_network_format_registry.register_lazy('git',
+    'bzrlib.plugins.git.branch', 'GitBranchFormat')
+
+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.git.branch',
+        'GitBranchFormat',
+        )
+
+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.git.workingtree',
+        'GitWorkingTreeFormat',
+        )
+
+controldir_network_format_registry.register_lazy('git',
+    "bzrlib.plugins.git.dir", "GitControlDirFormat")
+
+send_format_registry.register_lazy('git', 'bzrlib.plugins.git.send',
+                                   'send_git', 'Git am-style diff format')
+>>>>>>> MERGE-SOURCE
+
+topic_registry.register_lazy('git', 'bzrlib.plugins.git.help', 'help_git',
+    'Using Bazaar with Git')
+
+from bzrlib.diff import format_registry as diff_format_registry
+diff_format_registry.register_lazy('git', 'bzrlib.plugins.git.send',
+    'GitDiffTree', 'Git am-style diff format')
 
 def test_suite():
     from bzrlib.plugins.git import tests

=== modified file 'branch.py'
--- branch.py	2010-08-08 16:01:26 +0000
+++ branch.py	2011-03-23 20:12:35 +0000
@@ -17,17 +17,20 @@
 
 """An adapter between a Git Branch and a Bazaar Branch"""
 
+from collections import defaultdict
+
 from dulwich.objects import (
     Commit,
     Tag,
     )
+from dulwich.protocol import ZERO_SHA
 
 from bzrlib import (
     branch,
     bzrdir,
     config,
     errors,
-    repository,
+    repository as _mod_repository,
     revision,
     tag,
     transport,
@@ -51,9 +54,13 @@
     NoSuchRef,
     )
 from bzrlib.plugins.git.refs import (
+    branch_name_to_ref,
+    extract_tags,
+    is_tag,
     ref_to_branch_name,
-    extract_tags,
+    ref_to_tag_name,
     tag_name_to_ref,
+    UnpeelMap,
     )
 
 from bzrlib.foreign import ForeignBranch
@@ -76,48 +83,136 @@
         return self._lookup_revno(self.new_revid)
 
 
-class LocalGitTagDict(tag.BasicTags):
-    """Dictionary with tags in a local repository."""
+class GitTags(tag.BasicTags):
+    """Ref-based tag dictionary."""
 
     def __init__(self, branch):
         self.branch = branch
         self.repository = branch.repository
 
+    def get_refs(self):
+        raise NotImplementedError(self.get_refs)
+
+    def _iter_tag_refs(self, refs):
+        raise NotImplementedError(self._iter_tag_refs)
+
+    def _merge_to_git(self, to_tags, refs, overwrite=False):
+        target_repo = to_tags.repository
+        conflicts = []
+        for k, v in refs.iteritems():
+            if not is_tag(k):
+                continue
+            if overwrite or not k in target_repo._git.refs:
+                target_repo._git.refs[k] = v
+            elif target_repo._git.refs[k] == v:
+                pass
+            else:
+                conflicts.append((ref_to_tag_name(k), v, target_repo.refs[k]))
+        return conflicts
+
+    def _merge_to_non_git(self, to_tags, refs, overwrite=False):
+        unpeeled_map = defaultdict(set)
+        conflicts = []
+        result = dict(to_tags.get_tag_dict())
+        for n, peeled, unpeeled, bzr_revid in self._iter_tag_refs(refs):
+            if unpeeled is not None:
+                unpeeled_map[peeled].add(unpeeled)
+            if n not in result or overwrite:
+                result[n] = bzr_revid
+            elif result[n] == bzr_revid:
+                pass
+            else:
+                conflicts.append((n, result[n], bzr_revid))
+        to_tags._set_tag_dict(result)
+        if len(unpeeled_map) > 0:
+            map_file = UnpeelMap.from_repository(to_tags.branch.repository)
+            map_file.update(unpeeled_map)
+            map_file.save_in_repository(to_tags.branch.repository)
+        return conflicts
+
+    def merge_to(self, to_tags, overwrite=False, ignore_master=False,
+                 source_refs=None):
+        """See Tags.merge_to."""
+        if source_refs is None:
+            source_refs = self.get_refs()
+        if self == to_tags:
+            return
+        if isinstance(to_tags, GitTags):
+            return self._merge_to_git(to_tags, source_refs,
+                                      overwrite=overwrite)
+        else:
+            if ignore_master:
+                master = None
+            else:
+                master = to_tags.branch.get_master_branch()
+            conflicts = self._merge_to_non_git(to_tags, source_refs,
+                                              overwrite=overwrite)
+            if master is not None:
+                conflicts += self.merge_to(master.tags, overwrite=overwrite,
+                                           source_refs=source_refs,
+                                           ignore_master=ignore_master)
+            return conflicts
+
     def get_tag_dict(self):
         ret = {}
-        for k,v in extract_tags(self.repository._git.get_refs()).iteritems():
+        refs = self.get_refs()
+        for (name, peeled, unpeeled, bzr_revid) in self._iter_tag_refs(refs):
+            ret[name] = bzr_revid
+        return ret
+
+
+class LocalGitTagDict(GitTags):
+    """Dictionary with tags in a local repository."""
+
+    def __init__(self, branch):
+        super(LocalGitTagDict, self).__init__(branch)
+        self.refs = self.repository._git.refs
+
+    def get_refs(self):
+        return self.repository._git.get_refs()
+
+    def _iter_tag_refs(self, refs):
+        """Iterate over the tag refs.
+
+        :param refs: Refs dictionary (name -> git sha1)
+        :return: iterator over (name, peeled_sha1, unpeeled_sha1, bzr_revid)
+        """
+        for k, (peeled, unpeeled) in extract_tags(refs).iteritems():
             try:
-                obj = self.repository._git[v]
+                obj = self.repository._git[peeled]
             except KeyError:
-                mutter("Tag %s points at unknown object %s, ignoring", v, obj)
+                mutter("Tag %s points at unknown object %s, ignoring", peeled,
+                       obj)
                 continue
+            # FIXME: this shouldn't really be necessary, the repository
+            # already should have these unpeeled.
             while isinstance(obj, Tag):
-                v = obj.object[1]
-                obj = self.repository._git[v]
+                peeled = obj.object[1]
+                obj = self.repository._git[peeled]
             if not isinstance(obj, Commit):
                 mutter("Tag %s points at object %r that is not a commit, "
                        "ignoring", k, obj)
                 continue
-            ret[k] = self.branch.lookup_foreign_revision_id(v)
-        return ret
+            yield (k, peeled, unpeeled,
+                   self.branch.lookup_foreign_revision_id(peeled))
 
     def _set_tag_dict(self, to_dict):
-        extra = set(self.repository._git.get_refs().keys())
+        extra = set(self.get_refs().keys())
         for k, revid in to_dict.iteritems():
             name = tag_name_to_ref(k)
             if name in extra:
                 extra.remove(name)
             self.set_tag(k, revid)
         for name in extra:
-            if name.startswith("refs/tags/"):
+            if is_tag(name):
                 del self.repository._git[name]
 
     def set_tag(self, name, revid):
-        self.repository._git.refs[tag_name_to_ref(name)], _ = \
-            self.branch.mapping.revision_id_bzr_to_foreign(revid)
-
-
-class DictTagDict(LocalGitTagDict):
+        self.refs[tag_name_to_ref(name)], _ = \
+            self.branch.lookup_bzr_revision_id(revid)
+
+
+class DictTagDict(tag.BasicTags):
 
     def __init__(self, branch, tags):
         super(DictTagDict, self).__init__(branch)
@@ -138,6 +233,14 @@
     def supports_tags(self):
         return True
 
+    def supports_leaving_lock(self):
+        return False
+
+    @property
+    def _matchingbzrdir(self):
+        from bzrlib.plugins.git.dir import LocalGitControlDirFormat
+        return LocalGitControlDirFormat()
+
     def get_foreign_tests_branch_factory(self):
         from bzrlib.plugins.git.tests.test_branch import ForeignTestsBranchFactory
         return ForeignTestsBranchFactory()
@@ -149,6 +252,16 @@
         else:
             return LocalGitTagDict(branch)
 
+    def initialize(self, a_bzrdir, name=None, repository=None):
+        from bzrlib.plugins.git.dir import LocalGitDir
+        if not isinstance(a_bzrdir, LocalGitDir):
+            raise errors.IncompatibleFormat(self, a_bzrdir._format)
+        if repository is None:
+            repository = a_bzrdir.open_repository()
+        ref = branch_name_to_ref(name, "HEAD")
+        repository._git[ref] = ZERO_SHA
+        return LocalGitBranch(a_bzrdir, repository, ref, a_bzrdir._lockfiles)
+
 
 class GitReadLock(object):
 
@@ -165,6 +278,10 @@
 class GitBranch(ForeignBranch):
     """An adapter to git repositories for bzr Branch objects."""
 
+    @property
+    def control_transport(self):
+        return self.bzrdir.control_transport
+
     def __init__(self, bzrdir, repository, ref, lockfiles, tagsdict=None):
         self.repository = repository
         self._format = GitBranchFormat()
@@ -208,8 +325,11 @@
             self.ref or "HEAD")
 
     def generate_revision_history(self, revid, old_revid=None):
-        # FIXME: Check that old_revid is in the ancestry of revid
-        newhead, self.mapping = self.mapping.revision_id_bzr_to_foreign(revid)
+        if revid == NULL_REVISION:
+            newhead = ZERO_SHA
+        else:
+            # FIXME: Check that old_revid is in the ancestry of revid
+            newhead, self.mapping = self.mapping.revision_id_bzr_to_foreign(revid)
         self._set_head(newhead)
 
     def lock_write(self):
@@ -257,15 +377,19 @@
         return self.repository.lookup_foreign_revision_id(foreign_revid,
             self.mapping)
 
+    def lookup_bzr_revision_id(self, revid):
+        return self.repository.lookup_bzr_revision_id(
+            revid, mapping=self.mapping)
+
 
 class LocalGitBranch(GitBranch):
     """A local Git branch."""
 
-    def __init__(self, bzrdir, repository, name, lockfiles, tagsdict=None):
-        super(LocalGitBranch, self).__init__(bzrdir, repository, name,
+    def __init__(self, bzrdir, repository, ref, lockfiles, tagsdict=None):
+        super(LocalGitBranch, self).__init__(bzrdir, repository, ref,
               lockfiles, tagsdict)
         refs = repository._git.get_refs()
-        if not (name in refs.keys() or "HEAD" in refs.keys()):
+        if not (ref in refs.keys() or "HEAD" in refs.keys()):
             raise errors.NotBranchError(self.base)
 
     def create_checkout(self, to_location, revision_id=None, lightweight=False,
@@ -347,6 +471,20 @@
         return True
 
 
+def _quick_lookup_revno(local_branch, remote_branch, revid):
+    assert isinstance(revid, str), "was %r" % revid
+    # Try in source branch first, it'll be faster
+    try:
+        return local_branch.revision_id_to_revno(revid)
+    except errors.NoSuchRevision:
+        graph = local_branch.repository.get_graph()
+        try:
+            return graph.find_distance_to_null(revid)
+        except errors.GhostRevisionsHaveNoRevno:
+            # FIXME: Check using graph.find_distance_to_null() ?
+            return remote_branch.revision_id_to_revno(revid)
+
+
 class GitBranchPullResult(branch.PullResult):
 
     def __init__(self):
@@ -367,13 +505,7 @@
         self._show_tag_conficts(to_file)
 
     def _lookup_revno(self, revid):
-        assert isinstance(revid, str), "was %r" % revid
-        # Try in source branch first, it'll be faster
-        try:
-            return self.source_branch.revision_id_to_revno(revid)
-        except errors.NoSuchRevision:
-            # FIXME: Check using graph.find_distance_to_null() ?
-            return self.target_branch.revision_id_to_revno(revid)
+        return _quick_lookup_revno(self.target_branch, self.source_branch, revid)
 
     def _get_old_revno(self):
         if self._old_revno is not None:
@@ -399,13 +531,7 @@
 class GitBranchPushResult(branch.BranchPushResult):
 
     def _lookup_revno(self, revid):
-        assert isinstance(revid, str), "was %r" % revid
-        # Try in source branch first, it'll be faster
-        try:
-            return self.source_branch.revision_id_to_revno(revid)
-        except errors.NoSuchRevision:
-            # FIXME: Check using graph.find_distance_to_null() ?
-            return self.target_branch.revision_id_to_revno(revid)
+        return _quick_lookup_revno(self.source_branch, self.target_branch, revid)
 
     @property
     def old_revno(self):
@@ -413,6 +539,11 @@
 
     @property
     def new_revno(self):
+        new_original_revno = getattr(self, "new_original_revno", None)
+        if new_original_revno:
+            return new_original_revno
+        if getattr(self, "new_original_revid", None) is not None:
+            return self._lookup_revno(self.new_original_revid)
         return self._lookup_revno(self.new_revid)
 
 
@@ -421,12 +552,17 @@
 
     @staticmethod
     def _get_branch_formats_to_test():
-        return []
+        try:
+            default_format = branch.format_registry.get_default()
+        except AttributeError:
+            default_format = branch.BranchFormat._default_format
+        return [
+            (GitBranchFormat(), GitBranchFormat()),
+            (GitBranchFormat(), default_format)]
 
     @classmethod
     def _get_interrepo(self, source, target):
-        return repository.InterRepository.get(source.repository,
-            target.repository)
+        return _mod_repository.InterRepository.get(source.repository, target.repository)
 
     @classmethod
     def is_compatible(cls, source, target):
@@ -440,25 +576,24 @@
 
         Compared to the `update_revisions()` below, this function takes a
         `limit` argument that limits how many git commits will be converted
-        and returns the new git head.
+        and returns the new git head and remote refs.
         """
         interrepo = self._get_interrepo(self.source, self.target)
         def determine_wants(heads):
             if self.source.ref is not None and not self.source.ref in heads:
                 raise NoSuchRef(self.source.ref, heads.keys())
-            if stop_revision is not None:
-                self._last_revid = stop_revision
-                head, mapping = self.source.repository.lookup_bzr_revision_id(
-                    stop_revision)
-            else:
+
+            if stop_revision is None:
                 if self.source.ref is not None:
                     head = heads[self.source.ref]
                 else:
                     head = heads["HEAD"]
                 self._last_revid = self.source.lookup_foreign_revision_id(head)
-            if self.target.repository.has_revision(self._last_revid):
-                return []
-            return [head]
+            else:
+                self._last_revid = stop_revision
+            real = interrepo.get_determine_wants_revids(
+                [self._last_revid], include_tags=True)
+            return real(heads)
         pack_hint, head, refs = interrepo.fetch_objects(
             determine_wants, self.source.mapping, limit=limit)
         if (pack_hint is not None and
@@ -471,8 +606,8 @@
         else:
             prev_last_revid = self.target.last_revision()
         self.target.generate_revision_history(self._last_revid,
-            prev_last_revid)
-        return head
+            prev_last_revid, self.source)
+        return head, refs
 
     def update_revisions(self, stop_revision=None, overwrite=False,
                          graph=None):
@@ -510,7 +645,7 @@
             graph = self.target.repository.get_graph(self.source.repository)
             (result.old_revno, result.old_revid) = \
                 self.target.last_revision_info()
-            result.new_git_head = self._update_revisions(
+            result.new_git_head, remote_refs = self._update_revisions(
                 stop_revision, overwrite=overwrite, graph=graph, limit=limit)
             result.tag_conflicts = self.source.tags.merge_to(self.target.tags,
                 overwrite)
@@ -535,7 +670,7 @@
         result.target_branch = self.target
         graph = self.target.repository.get_graph(self.source.repository)
         result.old_revno, result.old_revid = self.target.last_revision_info()
-        result.new_git_head = self._update_revisions(
+        result.new_git_head, remote_refs = self._update_revisions(
             stop_revision, overwrite=overwrite, graph=graph)
         result.tag_conflicts = self.source.tags.merge_to(self.target.tags,
             overwrite)
@@ -552,6 +687,7 @@
 
     @staticmethod
     def _get_branch_formats_to_test():
+        # FIXME
         return []
 
     @classmethod
@@ -561,7 +697,6 @@
                 isinstance(target, RemoteGitBranch))
 
     def _basic_push(self, overwrite=False, stop_revision=None):
-        from dulwich.protocol import ZERO_SHA
         result = GitBranchPushResult()
         result.source_branch = self.source
         result.target_branch = self.target
@@ -585,6 +720,7 @@
 
     @staticmethod
     def _get_branch_formats_to_test():
+        # FIXME
         return []
 
     @classmethod
@@ -600,17 +736,13 @@
         result.old_revid = self.target.last_revision()
         refs, stop_revision = self.update_refs(stop_revision)
         self.target.generate_revision_history(stop_revision, result.old_revid)
-        self.update_tags(refs)
+        result.tag_conflicts = self.source.tags.merge_to(self.target.tags,
+            source_refs=refs, overwrite=overwrite)
         result.new_revid = self.target.last_revision()
         return result
 
-    def update_tags(self, refs):
-        for name, v in extract_tags(refs).iteritems():
-            revid = self.target.lookup_foreign_revision_id(v)
-            self.target.tags.set_tag(name, revid)
-
     def update_refs(self, stop_revision=None):
-        interrepo = repository.InterRepository.get(self.source.repository,
+        interrepo = _mod_repository.InterRepository.get(self.source.repository,
             self.target.repository)
         if stop_revision is None:
             refs = interrepo.fetch(branches=["HEAD"])
@@ -630,7 +762,8 @@
         result.old_revid = self.target.last_revision()
         refs, stop_revision = self.update_refs(stop_revision)
         self.target.generate_revision_history(stop_revision, result.old_revid)
-        self.update_tags(refs)
+        result.tag_conflicts = self.source.tags.merge_to(self.target.tags,
+            overwrite=overwrite, source_refs=refs)
         result.new_revid = self.target.last_revision()
         return result
 
@@ -640,12 +773,16 @@
 
     def __init__(self, source, target):
         super(InterToGitBranch, self).__init__(source, target)
-        self.interrepo = repository.InterRepository.get(source.repository,
+        self.interrepo = _mod_repository.InterRepository.get(source.repository,
                                            target.repository)
 
     @staticmethod
     def _get_branch_formats_to_test():
-        return []
+        try:
+            default_format = branch.format_registry.get_default()
+        except AttributeError:
+            default_format = branch.BranchFormat._default_format
+        return [(default_format, GitBranchFormat())]
 
     @classmethod
     def is_compatible(self, source, target):
@@ -657,56 +794,56 @@
 
     def _get_new_refs(self, stop_revision=None):
         if stop_revision is None:
-            stop_revision = self.source.last_revision()
+            (stop_revno, stop_revision) = self.source.last_revision_info()
         assert type(stop_revision) is str
         main_ref = self.target.ref or "refs/heads/master"
         refs = { main_ref: (None, stop_revision) }
         for name, revid in self.source.tags.get_tag_dict().iteritems():
             if self.source.repository.has_revision(revid):
                 refs[tag_name_to_ref(name)] = (None, revid)
-        return refs, main_ref
+        return refs, main_ref, (stop_revno, stop_revision)
 
     def pull(self, overwrite=False, stop_revision=None, local=False,
-             possible_transports=None):
-        from dulwich.protocol import ZERO_SHA
+             possible_transports=None, run_hooks=True):
         result = GitBranchPullResult()
         result.source_branch = self.source
         result.target_branch = self.target
-        new_refs, main_ref = self._get_new_refs(stop_revision)
+        new_refs, main_ref, stop_revinfo = self._get_new_refs(stop_revision)
         def update_refs(old_refs):
             refs = dict(old_refs)
             # FIXME: Check for diverged branches
             refs.update(new_refs)
             return refs
         old_refs, new_refs = self.interrepo.fetch_refs(update_refs)
-        result.old_revid = self.target.lookup_foreign_revision_id(
-            old_refs.get(main_ref, ZERO_SHA))
-        result.new_revid = new_refs[main_ref]
+        (result.old_revid, old_sha1) = old_refs.get(main_ref, (ZERO_SHA, NULL_REVISION))
+        if result.old_revid is None:
+            result.old_revid = self.target.lookup_foreign_revision_id(old_sha1)
+        result.new_revid = new_refs[main_ref][1]
         return result
 
     def push(self, overwrite=False, stop_revision=None,
              _override_hook_source_branch=None):
-        from dulwich.protocol import ZERO_SHA
         result = GitBranchPushResult()
         result.source_branch = self.source
         result.target_branch = self.target
-        new_refs, main_ref = self._get_new_refs(stop_revision)
+        new_refs, main_ref, stop_revinfo = self._get_new_refs(stop_revision)
         def update_refs(old_refs):
             refs = dict(old_refs)
             # FIXME: Check for diverged branches
             refs.update(new_refs)
             return refs
         old_refs, new_refs = self.interrepo.fetch_refs(update_refs)
-        result.old_revid = self.target.lookup_foreign_revision_id(
-            old_refs.get(main_ref, ZERO_SHA))
-        result.new_revid = new_refs[main_ref]
+        (result.old_revid, old_sha1) = old_refs.get(main_ref, (ZERO_SHA, NULL_REVISION))
+        if result.old_revid is None:
+            result.old_revid = self.target.lookup_foreign_revision_id(old_sha1)
+        result.new_revid = new_refs[main_ref][1]
         return result
 
     def lossy_push(self, stop_revision=None):
         result = GitBranchPushResult()
         result.source_branch = self.source
         result.target_branch = self.target
-        new_refs, main_ref = self._get_new_refs(stop_revision)
+        new_refs, main_ref, stop_revinfo = self._get_new_refs(stop_revision)
         def update_refs(old_refs):
             refs = dict(old_refs)
             # FIXME: Check for diverged branches
@@ -716,6 +853,7 @@
             update_refs)
         result.old_revid = old_refs.get(self.target.ref, (None, NULL_REVISION))[1]
         result.new_revid = new_refs[main_ref][1]
+        (result.new_original_revno, result.new_original_revid) = stop_revinfo
         return result
 
 

=== modified file 'bzr-receive-pack'
--- bzr-receive-pack	2009-09-10 13:13:15 +0000
+++ bzr-receive-pack	2011-03-23 20:12:35 +0000
@@ -1,20 +1,15 @@
 #!/usr/bin/env python
+
 import bzrlib
 from bzrlib.plugin import load_plugins
 load_plugins()
 from bzrlib.plugins.git.server import BzrBackend
-from dulwich.server import ReceivePackHandler
+from dulwich.server import ReceivePackHandler, serve_command
 import sys, os
 
-if len(sys.argv) != 2 or not os.path.isdir(sys.argv[1]):
-    print "usage: git-receive-pack <git-dir>"
+if len(sys.argv) < 2:
+    print >>sys.stderr, "usage: %s <git-dir>" % os.path.basename(sys.argv[0])
     sys.exit(1)
- 
-backend = BzrBackend(bzrlib.transport.get_transport(sys.argv[1]))
-
-def write_fn(data):
-    sys.stdout.write(data)
-    sys.stdout.flush()
-
-server = ReceivePackHandler(backend, sys.stdin.read, write_fn)
-server.handle()
+
+backend = BzrBackend(bzrlib.transport.get_transport("/"))
+sys.exit(serve_command(ReceivePackHandler, backend=backend))

=== modified file 'bzr-upload-pack'
--- bzr-upload-pack	2009-09-10 13:13:15 +0000
+++ bzr-upload-pack	2011-03-23 20:12:35 +0000
@@ -1,25 +1,15 @@
 #!/usr/bin/env python
+
 import bzrlib
 from bzrlib.plugin import load_plugins
 load_plugins ()
 from bzrlib.plugins.git.server import BzrBackend
-from dulwich.server import UploadPackHandler
-import sys, os, optparse
-
-parser = optparse.OptionParser(usage="usage: git-upload-pack [--strict] [--timeout=nn] <dir>")
-parser.add_option("--strict", action="store_true", dest="strict", default=False)
-parser.add_option("--timeout", type="int", dest="timeout", default=-1)
-options, args = parser.parse_args()
-
-if len(args) != 1 or not os.path.isdir(args[0]):
-    print "usage: " + parser.usage
+from dulwich.server import UploadPackHandler, serve_command
+import sys, os
+
+if len(sys.argv) < 2:
+    print "usage: %s <git-dir>" % os.path.basename(sys.argv[0])
     sys.exit(1)
 
-backend = BzrBackend(bzrlib.transport.get_transport(sys.argv[1]))
-
-def write_fn(data):
-    sys.stdout.write(data)
-    sys.stdout.flush()
-
-server = UploadPackHandler(backend, sys.stdin.read, write_fn)
-server.handle()
+backend = BzrBackend(bzrlib.transport.get_transport("/"))
+sys.exit(serve_command(UploadPackHandler, backend=backend))

=== modified file 'cache.py'
--- cache.py	2010-06-28 21:30:29 +0000
+++ cache.py	2011-03-23 20:12:35 +0000
@@ -55,6 +55,9 @@
 
 
 def get_remote_cache_transport():
+    """Retrieve the transport to use when accessing (unwritable) remote 
+    repositories.
+    """
     return get_transport(get_cache_dir())
 
 
@@ -98,7 +101,9 @@
         """Lookup a Git sha in the database.
         :param sha: Git object sha
         :return: (type, type_data) with type_data:
-            revision: revid, tree sha
+            commit: revid, tree_sha, verifiers
+            blob: fileid, revid
+            tree: fileid, revid
         """
         raise NotImplementedError(self.lookup_git_sha)
 
@@ -115,6 +120,11 @@
         """
         raise NotImplementedError(self.lookup_tree_id)
 
+    def lookup_commit(self, revid):
+        """Retrieve a Git commit SHA by Bazaar revision id.
+        """
+        raise NotImplementedError(self.lookup_commit)
+
     def revids(self):
         """List the revision ids known."""
         raise NotImplementedError(self.revids)
@@ -217,6 +227,13 @@
     """Base class for objects that can update a bzr-git cache."""
 
     def add_object(self, obj, ie, path):
+        """Add an object.
+
+        :param obj: Object type ("commit", "blob" or "tree")
+        :param ie: Inventory entry (for blob/tree) or testament_sha in case
+            of commit
+        :param path: Path of the object (optional)
+        """
         raise NotImplementedError(self.add_object)
 
     def finish(self):
@@ -254,8 +271,8 @@
     def add_object(self, obj, ie, path):
         if obj.type_name == "commit":
             self._commit = obj
-            assert ie is None
-            type_data = (self.revid, self._commit.tree)
+            assert type(ie) is dict
+            type_data = (self.revid, self._commit.tree, ie)
             self.cache.idmap._by_revid[self.revid] = obj.id
         elif obj.type_name in ("blob", "tree"):
             if ie is not None:
@@ -264,8 +281,7 @@
                 else:
                     revision = self.revid
                 type_data = (ie.file_id, revision)
-                self.cache.idmap._by_fileid.setdefault(type_data[1], {})[type_data[0]] =\
-                    obj.id
+                self.cache.idmap._by_fileid.setdefault(type_data[1], {})[type_data[0]] = obj.id
         else:
             raise AssertionError
         self.cache.idmap._by_sha[obj.id] = (obj.type_name, type_data)
@@ -318,7 +334,8 @@
     def add_object(self, obj, ie, path):
         if obj.type_name == "commit":
             self._commit = obj
-            assert ie is None
+            self._testament3_sha1 = ie["testament3-sha1"]
+            assert type(ie) is dict
         elif obj.type_name == "tree":
             if ie is not None:
                 self._trees.append((obj.id, ie.file_id, self.revid))
@@ -338,8 +355,8 @@
             "replace into blobs (sha1, fileid, revid) values (?, ?, ?)",
             self._blobs)
         self.db.execute(
-            "replace into commits (sha1, revid, tree_sha) values (?, ?, ?)",
-            (self._commit.id, self.revid, self._commit.tree))
+            "replace into commits (sha1, revid, tree_sha, testament3_sha1) values (?, ?, ?, ?)",
+            (self._commit.id, self.revid, self._commit.tree, self._testament3_sha1))
         return self._commit
 
 
@@ -394,10 +411,15 @@
         create unique index if not exists trees_sha1 on trees(sha1);
         create unique index if not exists trees_fileid_revid on trees(fileid, revid);
 """)
+        try:
+            self.db.executescript(
+                "ALTER TABLE commits ADD testament3_sha1 TEXT;")
+        except sqlite3.OperationalError:
+            pass # Column already exists.
 
     def __repr__(self):
         return "%s(%r)" % (self.__class__.__name__, self.path)
-    
+
     def lookup_commit(self, revid):
         cursor = self.db.execute("select sha1 from commits where revid = ?", 
             (revid,))
@@ -426,11 +448,13 @@
 
         :param sha: Git object sha
         :return: (type, type_data) with type_data:
-            revision: revid, tree sha
+            commit: revid, tree sha, verifiers
+            tree: fileid, revid
+            blob: fileid, revid
         """
-        row = self.db.execute("select revid, tree_sha from commits where sha1 = ?", (sha,)).fetchone()
+        row = self.db.execute("select revid, tree_sha, testament3_sha1 from commits where sha1 = ?", (sha,)).fetchone()
         if row is not None:
-            return ("commit", row)
+            return ("commit", (row[0], row[1], {"testament3-sha1": row[2]}))
         row = self.db.execute("select fileid, revid from blobs where sha1 = ?", (sha,)).fetchone()
         if row is not None:
             return ("blob", row)
@@ -465,9 +489,9 @@
         sha = obj.sha().digest()
         if obj.type_name == "commit":
             self.db["commit\0" + self.revid] = "\0".join((sha, obj.tree))
-            type_data = (self.revid, obj.tree)
+            assert type(ie) is dict, "was %r" % ie
+            type_data = (self.revid, obj.tree, ie["testament3-sha1"])
             self._commit = obj
-            assert ie is None
         elif obj.type_name == "blob":
             if ie is None:
                 return
@@ -489,6 +513,7 @@
 
 TdbBzrGitCache = lambda p: BzrGitCache(TdbGitShaMap(p), None, TdbCacheUpdater)
 
+
 class TdbGitCacheFormat(BzrGitCacheFormat):
     """Cache format for tdb-based caches."""
 
@@ -497,9 +522,10 @@
 
     def open(self, transport):
         try:
-            basepath = transport.local_abspath(".")
+            basepath = transport.local_abspath(".").encode(osutils._fs_enc)
         except bzrlib.errors.NotLocalUrl:
             basepath = get_cache_dir()
+        assert isinstance(basepath, str)
         try:
             return TdbBzrGitCache(os.path.join(basepath, "idmap.tdb"))
         except ImportError:
@@ -528,6 +554,7 @@
         if path is None:
             self.db = {}
         else:
+            assert isinstance(path, str)
             if not mapdbs().has_key(path):
                 mapdbs()[path] = tdb.Tdb(path, self.TDB_HASH_SIZE, tdb.DEFAULT,
                                           os.O_RDWR|os.O_CREAT)
@@ -561,18 +588,26 @@
 
     def lookup_blob_id(self, fileid, revision):
         return sha_to_hex(self.db["\0".join(("blob", fileid, revision))])
-                
+
     def lookup_git_sha(self, sha):
         """Lookup a Git sha in the database.
 
         :param sha: Git object sha
         :return: (type, type_data) with type_data:
-            revision: revid, tree sha
+            commit: revid, tree sha
+            blob: fileid, revid
+            tree: fileid, revid
         """
         if len(sha) == 40:
             sha = hex_to_sha(sha)
         data = self.db["git\0" + sha].split("\0")
-        return (data[0], (data[1], data[2]))
+        if data[0] == "commit":
+            if len(data) == 3:
+                return (data[0], (data[1], data[2], {}))
+            else:
+                return (data[0], (data[1], data[2], {"testament3-sha1": data[3]}))
+        else:
+            return (data[0], tuple(data[1:]))
 
     def missing_revisions(self, revids):
         ret = set()
@@ -640,9 +675,9 @@
     def add_object(self, obj, ie, path):
         if obj.type_name == "commit":
             self._commit = obj
-            assert ie is None
+            assert type(ie) is dict
             self.cache.idmap._add_git_sha(obj.id, "commit",
-                (self.revid, obj.tree))
+                (self.revid, obj.tree, ie))
             self.cache.idmap._add_node(("commit", self.revid, "X"),
                 " ".join((obj.id, obj.tree)))
             self._cache_objs.add((obj, path))
@@ -808,8 +843,11 @@
     def _add_git_sha(self, hexsha, type, type_data):
         if hexsha is not None:
             self._name.update(hexsha)
-            self._add_node(("git", hexsha, "X"),
-                " ".join((type, type_data[0], type_data[1])))
+            if type == "commit":
+                td = (type_data[0], type_data[1], type_data[2]["testament3-sha1"])
+            else:
+                td = type_data
+            self._add_node(("git", hexsha, "X"), " ".join((type,) + td))
         else:
             # This object is not represented in Git - perhaps an empty
             # directory?
@@ -821,8 +859,11 @@
     def lookup_git_sha(self, sha):
         if len(sha) == 20:
             sha = sha_to_hex(sha)
-        data = self._get_entry(("git", sha, "X")).split(" ", 2)
-        return (data[0], (data[1], data[2]))
+        data = self._get_entry(("git", sha, "X")).split(" ", 3)
+        if data[0] == "commit":
+            return ("commit", (data[1], data[2], {"testament3-sha1": data[3]}))
+        else:
+            return (data[0], tuple(data[1:]))
 
     def revids(self):
         """List the revision ids known."""

=== modified file 'commands.py'
--- commands.py	2010-08-08 16:01:26 +0000
+++ commands.py	2011-03-23 20:12:35 +0000
@@ -37,10 +37,12 @@
     takes_args = ["src_location", "dest_location?"]
 
     def run(self, src_location, dest_location=None):
+        from collections import defaultdict
         import os
         from bzrlib import (
+            controldir,
+            trace,
             ui,
-            urlutils,
             )
         from bzrlib.bzrdir import (
             BzrDir,
@@ -54,22 +56,29 @@
             InterRepository,
             Repository,
             )
+        from bzrlib.transport import get_transport
         from bzrlib.plugins.git.branch import (
             GitBranch,
             extract_tags,
             )
+        from bzrlib.plugins.git.refs import ref_to_branch_name
         from bzrlib.plugins.git.repository import GitRepository
 
+        dest_format = controldir.ControlDirFormat.get_default_format()
+
         if dest_location is None:
             dest_location = os.path.basename(src_location.rstrip("/\\"))
 
+        dest_transport = get_transport(dest_location)
+
         source_repo = Repository.open(src_location)
         if not isinstance(source_repo, GitRepository):
             raise BzrCommandError("%r is not a git repository" % src_location)
         try:
-            target_bzrdir = BzrDir.open(dest_location)
+            target_bzrdir = BzrDir.open_from_transport(dest_transport)
         except NotBranchError:
-            target_bzrdir = BzrDir.create(dest_location)
+            target_bzrdir = dest_format.initialize_on_transport_ex(
+                dest_transport, shared_repo=True)[1]
         try:
             target_repo = target_bzrdir.find_repository()
         except NoRepositoryPresent:
@@ -81,23 +90,28 @@
         interrepo = InterRepository.get(source_repo, target_repo)
         mapping = source_repo.get_mapping()
         refs = interrepo.fetch()
+        unpeeled_tags = defaultdict(set)
         tags = {}
-        for k, v in extract_tags(refs).iteritems():
-            tags[k] = mapping.revision_id_foreign_to_bzr(v)
+        for k, (peeled, unpeeled) in extract_tags(refs).iteritems():
+            tags[k] = mapping.revision_id_foreign_to_bzr(peeled)
+            if unpeeled is not None:
+                unpeeled_tags[peeled].add(unpeeled)
+        # FIXME: Store unpeeled tag map
         pb = ui.ui_factory.nested_progress_bar()
         try:
             for i, (name, ref) in enumerate(refs.iteritems()):
-                if name.startswith("refs/tags/"):
+                try:
+                    ref_to_branch_name(name)
+                except ValueError:
+                    # Not a branch, ignore
                     continue
                 pb.update("creating branches", i, len(refs))
-                head_loc = os.path.join(dest_location, name)
+                head_transport = dest_transport.clone(name)
                 try:
-                    head_bzrdir = BzrDir.open(head_loc)
+                    head_bzrdir = BzrDir.open_from_transport(head_transport)
                 except NotBranchError:
-                    parent_path = urlutils.dirname(head_loc)
-                    if not os.path.isdir(parent_path):
-                        os.makedirs(parent_path)
-                    head_bzrdir = BzrDir.create(head_loc)
+                    head_bzrdir = dest_format.initialize_on_transport_ex(
+                        head_transport, create_prefix=True)[1]
                 try:
                     head_branch = head_bzrdir.open_branch()
                 except NotBranchError:
@@ -111,6 +125,9 @@
                 source_branch.tags.merge_to(head_branch.tags)
         finally:
             pb.finished()
+        trace.note("Use 'bzr checkout' to create a working tree in "
+                   "the newly created branches.")
+
 
 
 class cmd_git_object(Command):
@@ -204,27 +221,49 @@
     "bzr pull".
     """
 
+    takes_options = [
+        Option('signoff', short_name='s', help='Add a Signed-off-by line.'),
+        'force']
     takes_args = ["patches*"]
 
-    def _apply_patch(self, wt, f):
+    def _apply_patch(self, wt, f, signoff):
+        """Apply a patch.
+
+        :param wt: A Bazaar working tree object.
+        :param f: Patch file to read.
+        :param signoff: Add Signed-Off-By flag.
+        """
+        from bzrlib.errors import BzrCommandError
         from dulwich.patch import git_am_patch_split
+        import subprocess
         (c, diff, version) = git_am_patch_split(f)
-        # FIXME: Process diff
-        wt.commit(committer=c.committer,
-                  message=c.message)
+        # FIXME: Cope with git-specific bits in patch
+        p = subprocess.Popen(["patch", "-p1"], stdin=subprocess.PIPE, cwd=wt.basedir)
+        p.communicate(diff)
+        exitcode = p.wait()
+        if exitcode != 0:
+            raise BzrCommandError("error running patch")
+        message = c.message
+        if signoff:
+            signed_off_by = wt.branch.get_config().username()
+            message += "Signed-off-by: %s\n" % signed_off_by.encode('utf-8')
+        wt.commit(authors=[c.author], message=message)
 
-    def run(self, patches_list=None):
+    def run(self, patches_list=None, signoff=False, force=False):
+        from bzrlib.errors import UncommittedChanges
         from bzrlib.workingtree import WorkingTree
         if patches_list is None:
             patches_list = []
-        
+
         tree, _ = WorkingTree.open_containing(".")
+        if tree.basis_tree().changes_from(tree).has_changed() and not force:
+            raise UncommittedChanges(tree)
         tree.lock_write()
         try:
             for patch in patches_list:
                 f = open(patch, 'r')
                 try:
-                    self._apply_patch(tree, f)
+                    self._apply_patch(tree, f, signoff=signoff)
                 finally:
                     f.close()
         finally:

=== modified file 'commit.py'
--- commit.py	2010-08-05 23:44:17 +0000
+++ commit.py	2011-03-23 20:12:35 +0000
@@ -21,9 +21,11 @@
 from dulwich.index import (
     commit_tree,
     )
-import os
 import stat
 
+from bzrlib.errors import (
+    RootMissing,
+    )
 from bzrlib.repository import (
     CommitBuilder,
     )
@@ -41,6 +43,9 @@
 
 
 class GitCommitBuilder(CommitBuilder):
+    """Commit builder for Git repositories."""
+
+    supports_record_entry_contents = False
 
     def __init__(self, *args, **kwargs):
         super(GitCommitBuilder, self).__init__(*args, **kwargs)
@@ -70,11 +75,14 @@
                 blob = Blob()
                 blob.data = workingtree.get_file_text(file_id, path)
                 return blob.id
+        seen_root = False
         for (file_id, path, changed_content, versioned, parent, name, kind,
              executable) in iter_changes:
             if kind[1] in ("directory",):
                 if kind[0] in ("file", "symlink"):
                     self.record_delete(path[0], file_id)
+                if path[1] == "":
+                    seen_root = True
                 continue
             if path[1] is None:
                 self.record_delete(path[0], file_id)
@@ -87,7 +95,7 @@
                 sha = link_sha1(path[1], file_id)
             elif kind[1] == "tree-reference":
                 mode = S_IFGITLINK
-                sha = "FIXME"
+                sha = "FIXME" # FIXME
             else:
                 raise AssertionError("Unknown kind %r" % kind[1])
             if executable[1]:
@@ -95,10 +103,14 @@
             self._any_changes = True
             self._blobs[path[1].encode("utf-8")] = (mode, sha)
             file_sha1 = workingtree.get_file_sha1(file_id, path[1])
-            yield file_id, path[1], (file_sha1, os.lstat(workingtree.abspath(path[1])))
+            _, st = workingtree.get_file_with_stat(file_id, path[1])
+            yield file_id, path[1], (file_sha1, st)
+        if not seen_root and len(self.parents) == 0:
+            raise RootMissing()
         # Fill in entries that were not changed
         basis_tree = workingtree.basis_tree()
-        assert basis_tree.get_revision_id() == basis_revid
+        assert basis_tree.get_revision_id() == basis_revid, "expected %r == %r" % (
+            basis_tree.get_revision_id(), basis_revid)
         for path, entry in basis_tree.iter_entries_by_dir():
             if entry.kind not in ("file", "symlink"):
                 continue
@@ -109,6 +121,7 @@
                 else:
                     blob.data = basis_tree.get_file_text(entry.file_id)
                 self._blobs[path.encode("utf-8")] = (entry_mode(entry), blob.id)
+        self.new_inventory = None
 
     def finish_inventory(self):
         # eliminate blobs that were removed
@@ -132,6 +145,7 @@
         c.encoding = 'utf-8'
         c.message = message.encode("utf-8")
         self.store.add_object(c)
+        assert len(c.id) == 40
         self._new_revision_id = self.repository.get_mapping().revision_id_foreign_to_bzr(c.id)
         self.repository.commit_write_group()
         return self._new_revision_id

=== modified file 'dir.py'
--- dir.py	2010-08-06 10:51:21 +0000
+++ dir.py	2011-03-23 20:12:35 +0000
@@ -15,26 +15,33 @@
 # along with this program; if not, write to the Free Software
 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
-"""An adapter between a Git control dir and a Bazaar BzrDir."""
+"""An adapter between a Git control dir and a Bazaar ControlDir."""
 
 from bzrlib import (
-    bzrdir,
     errors as bzr_errors,
     lockable_files,
+    trace,
     urlutils,
     version_info as bzrlib_version,
     )
+from bzrlib.bzrdir import CreateRepository
+from bzrlib.transport import do_catching_redirections
 
 LockWarner = getattr(lockable_files, "_LockWarner", None)
 
-from bzrlib.plugins.git import (
-    LocalGitBzrDirFormat,
+from bzrlib.controldir import (
+    ControlDir,
+    ControlDirFormat,
+    format_registry,
     )
 
 
 class GitLock(object):
     """A lock that thunks through to Git."""
 
+    def __init__(self):
+        self.lock_name = "git lock"
+
     def lock_write(self, token=None):
         pass
 
@@ -69,7 +76,33 @@
             self._lock_warner = LockWarner(repr(self))
 
 
-class GitDir(bzrdir.BzrDir):
+class GitDirConfig(object):
+
+    def get_default_stack_on(self):
+        return None
+
+    def set_default_stack_on(self, value):
+        raise bzr_errors.BzrError("Cannot set configuration")
+
+
+class GitControlDirFormat(ControlDirFormat):
+
+    _lock_class = lockable_files.TransportLock
+
+    colocated_branches = True
+    fixed_components = True
+
+    def __eq__(self, other):
+        return type(self) == type(other)
+
+    def is_supported(self):
+        return True
+
+    def network_name(self):
+        return "git"
+
+
+class GitDir(ControlDir):
     """An adapter to the '.git' dir used by git."""
 
     def is_supported(self):
@@ -78,21 +111,171 @@
     def can_convert_format(self):
         return False
 
+    def break_lock(self):
+        pass
+
     def cloning_metadir(self, stacked=False):
-        return bzrdir.format_registry.make_bzrdir("default")
+        return format_registry.make_bzrdir("default")
 
     def _branch_name_to_ref(self, name):
         raise NotImplementedError(self._branch_name_to_ref)
 
-    if bzrlib_version >= (2, 2):
-        def open_branch(self, name=None, unsupported=False, 
-            ignore_fallbacks=None):
-            return self._open_branch(name=name,
-                ignore_fallbacks=ignore_fallbacks, unsupported=unsupported)
-    else:
-        def open_branch(self, ignore_fallbacks=None, unsupported=False):
-            return self._open_branch(name=None,
-                ignore_fallbacks=ignore_fallbacks, unsupported=unsupported)
+    def get_config(self):
+        return GitDirConfig()
+
+    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 bzr_errors.NoRepositoryPresent:
+            result_repo = result.create_repository()
+            target_is_empty = True
+        else:
+            target_is_empty = None # Unknown
+        if stacked:
+            raise bzr_errors.IncompatibleRepositories(source_repository, result_repo)
+        interrepo = InterRepository.get(source_repository, result_repo)
+
+        if revision_id is not None:
+            determine_wants = interrepo.get_determine_wants_revids(
+                [revision_id], include_tags=True)
+        else:
+            determine_wants = interrepo.determine_wants_all
+        interrepo.fetch_objects(determine_wants=determine_wants,
+            mapping=source_branch.mapping)
+        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 bzr_errors.NoWorkingTree:
+                        pass
+            finally:
+                wt.unlock()
+        return result
+
+    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):
+        from dulwich.protocol import ZERO_SHA
+        """See ControlDir.clone_on_transport."""
+        if no_tree:
+            format = BareLocalGitControlDirFormat()
+        else:
+            format = LocalGitControlDirFormat()
+        (target_repo, target_controldir, stacking, repo_policy) = format.initialize_on_transport_ex(transport, use_existing_dir=use_existing_dir, create_prefix=create_prefix, force_new_repo=force_new_repo)
+        target_git_repo = target_repo._git
+        source_repo = self.open_repository()
+        source_git_repo = source_repo._git
+        if revision_id is not None:
+            determine_wants = source_repo.determine_wants_revid_and_tags(revision_id)
+        else:
+            determine_wants = target_git_repo.object_store.determine_wants_all
+        refs = source_git_repo.fetch(target_git_repo, determine_wants)
+        for name, val in refs.iteritems():
+            target_git_repo.refs[name] = val
+        lockfiles = GitLockableFiles(transport, GitLock())
+        return self.__class__(transport, lockfiles, target_git_repo, format)
+
+    def find_repository(self):
+        """Find the repository that should be used.
+
+        This does not require a branch as we use it to find the repo for
+        new branches as well as to hook existing branches up to their
+        repository.
+        """
+        return self.open_repository()
+
+
+class LocalGitControlDirFormat(GitControlDirFormat):
+    """The .git directory control format."""
+
+    bare = False
+
+    @classmethod
+    def _known_formats(self):
+        return set([LocalGitControlDirFormat()])
+
+    @property
+    def repository_format(self):
+        from bzrlib.plugins.git.repository import GitRepositoryFormat
+        return GitRepositoryFormat()
+
+    def get_branch_format(self):
+        from bzrlib.plugins.git.branch import GitBranchFormat
+        return GitBranchFormat()
+
+    def open(self, transport, _found=None):
+        """Open this directory.
+
+        """
+        from bzrlib.plugins.git.transportgit import TransportRepo
+        gitrepo = TransportRepo(transport)
+        lockfiles = GitLockableFiles(transport, GitLock())
+        return LocalGitDir(transport, lockfiles, gitrepo, self)
+
+    def get_format_description(self):
+        return "Local Git Repository"
+
+    def initialize_on_transport(self, transport):
+        from bzrlib.plugins.git.transportgit import TransportRepo
+        TransportRepo.init(transport, bare=self.bare)
+        return self.open(transport)
+
+    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):
+        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 bzr_errors.FileExists:
+            if not use_existing_dir:
+                raise
+        except bzr_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 is_supported(self):
+        return True
+
+
+class BareLocalGitControlDirFormat(LocalGitControlDirFormat):
+
+    bare = True
+    supports_workingtrees = False
+
+    def get_format_description(self):
+        return "Local Git Repository (bare)"
 
 
 class LocalGitDir(GitDir):
@@ -104,9 +287,18 @@
 
     _gitrepository_class = property(_get_gitrepository_class)
 
+    @property
+    def user_transport(self):
+        return self.root_transport
+
+    @property
+    def control_transport(self):
+        return self.transport
+
     def __init__(self, transport, lockfiles, gitrepo, format):
         self._format = format
         self.root_transport = transport
+        self._mode_check_done = False
         self._git = gitrepo
         if gitrepo.bare:
             self.transport = transport
@@ -126,30 +318,30 @@
         return ref
 
     def is_control_filename(self, filename):
-        return filename == '.git' or filename.startswith('.git/')
+        return (filename == '.git' or filename.startswith('.git/'))
 
     def get_branch_transport(self, branch_format, name=None):
         if branch_format is None:
             return self.transport
-        if isinstance(branch_format, LocalGitBzrDirFormat):
+        if isinstance(branch_format, LocalGitControlDirFormat):
             return self.transport
         raise bzr_errors.IncompatibleFormat(branch_format, self._format)
 
     def get_repository_transport(self, format):
         if format is None:
             return self.transport
-        if isinstance(format, LocalGitBzrDirFormat):
+        if isinstance(format, LocalGitControlDirFormat):
             return self.transport
         raise bzr_errors.IncompatibleFormat(format, self._format)
 
     def get_workingtree_transport(self, format):
         if format is None:
             return self.transport
-        if isinstance(format, LocalGitBzrDirFormat):
+        if isinstance(format, LocalGitControlDirFormat):
             return self.transport
         raise bzr_errors.IncompatibleFormat(format, self._format)
 
-    def _open_branch(self, name=None, ignore_fallbacks=None, unsupported=False):
+    def open_branch(self, name=None, unsupported=False, ignore_fallbacks=None):
         """'create' a branch for this dir."""
         repo = self.open_repository()
         from bzrlib.plugins.git.branch import LocalGitBranch
@@ -179,7 +371,7 @@
                 ret.append(self.open_branch(name=name))
         return ret
 
-    def open_repository(self, shared=False):
+    def open_repository(self):
         """'open' a repository for this dir."""
         return self._gitrepository_class(self, self._lockfiles)
 
@@ -203,9 +395,12 @@
         raise bzr_errors.NoWorkingTree(loc)
 
     def create_repository(self, shared=False):
+        from bzrlib.plugins.git.repository import GitRepositoryFormat
+        if shared:
+            raise bzr_errors.IncompatibleFormat(GitRepositoryFormat(), self._format)
         return self.open_repository()
 
-    def create_branch(self, name=None):
+    def create_branch(self, name=None, repository=None):
         refname = self._branch_name_to_ref(name)
         from dulwich.protocol import ZERO_SHA
         self._git.refs[refname or "HEAD"] = ZERO_SHA
@@ -222,7 +417,7 @@
     def create_workingtree(self, revision_id=None, from_branch=None,
         accelerator_tree=None, hardlink=False):
         if self._git.bare:
-            raise bzr_errors.BzrError("Can't create working tree in a bare repo")
+            raise bzr_errors.UnsupportedOperation(self.create_workingtree, self)
         from dulwich.index import write_index
         from dulwich.pack import SHA1Writer
         f = open(self.transport.local_abspath("index"), 'w+')
@@ -232,3 +427,51 @@
         finally:
             f.close()
         return self.open_workingtree()
+
+    def _find_or_create_repository(self, force_new_repo=None):
+        return self.create_repository(shared=False)
+
+    def _find_creation_modes(self):
+        """Determine the appropriate modes for files and directories.
+
+        They're always set to be consistent with the base directory,
+        assuming that this transport allows setting modes.
+        """
+        # TODO: Do we need or want an option (maybe a config setting) to turn
+        # this off or override it for particular locations? -- mbp 20080512
+        if self._mode_check_done:
+            return
+        self._mode_check_done = True
+        try:
+            st = self.transport.stat('.')
+        except bzr_errors.TransportNotPossible:
+            self._dir_mode = None
+            self._file_mode = None
+        else:
+            # Check the directory mode, but also make sure the created
+            # directories and files are read-write for this user. This is
+            # mostly a workaround for filesystems which lie about being able to
+            # write to a directory (cygwin & win32)
+            if (st.st_mode & 07777 == 00000):
+                # FTP allows stat but does not return dir/file modes
+                self._dir_mode = None
+                self._file_mode = None
+            else:
+                self._dir_mode = (st.st_mode & 07777) | 00700
+                # Remove the sticky and execute bits for files
+                self._file_mode = self._dir_mode & ~07111
+
+    def _get_file_mode(self):
+        """Return Unix mode for newly created files, or None.
+        """
+        if not self._mode_check_done:
+            self._find_creation_modes()
+        return self._file_mode
+
+    def _get_dir_mode(self):
+        """Return Unix mode for newly created directories, or None.
+        """
+        if not self._mode_check_done:
+            self._find_creation_modes()
+        return self._dir_mode
+

=== modified file 'fetch.py'
--- fetch.py	2010-08-08 17:40:33 +0000
+++ fetch.py	2011-03-23 20:12:35 +0000
@@ -22,6 +22,7 @@
     )
 from dulwich.object_store import (
     tree_lookup_path,
+    ZERO_SHA,
     )
 from itertools import (
     imap,
@@ -56,6 +57,9 @@
 from bzrlib.revisiontree import (
     RevisionTree,
     )
+from bzrlib.testament import (
+    StrictTestament3,
+    )
 from bzrlib.tsort import (
     topo_sort,
     )
@@ -74,6 +78,7 @@
     LRUTreeCache,
     _tree_to_objects,
     )
+from bzrlib.plugins.git.refs import extract_tags
 from bzrlib.plugins.git.remote import (
     RemoteGitRepository,
     )
@@ -257,7 +262,7 @@
     # Remember for next time
     existing_children = set()
     child_modes = {}
-    for child_mode, name, child_hexsha in tree.entries():
+    for name, child_mode, child_hexsha in tree.iteritems():
         existing_children.add(name)
         child_path = posixpath.join(path, name)
         if type(base_tree) is Tree:
@@ -272,7 +277,7 @@
         if stat.S_ISDIR(child_mode):
             subinvdelta, grandchildmodes = import_git_tree(texts, mapping,
                 child_path, name, (child_base_hexsha, child_hexsha), base_inv,
-                file_id, revision_id, parent_invs, lookup_object, 
+                file_id, revision_id, parent_invs, lookup_object,
                 (child_base_mode, child_mode), store_updater, lookup_file_id,
                 allow_submodules=allow_submodules)
         elif S_ISGITLINK(child_mode): # submodule
@@ -302,13 +307,14 @@
 
 
 def verify_commit_reconstruction(target_git_object_retriever, lookup_object,
-    o, rev, ret_tree, parent_trees, mapping, unusual_modes):
+    o, rev, ret_tree, parent_trees, mapping, unusual_modes, verifiers):
     new_unusual_modes = mapping.export_unusual_file_modes(rev)
     if new_unusual_modes != unusual_modes:
         raise AssertionError("unusual modes don't match: %r != %r" % (
             unusual_modes, new_unusual_modes))
     # Verify that we can reconstruct the commit properly
-    rec_o = target_git_object_retriever._reconstruct_commit(rev, o.tree, True)
+    rec_o = target_git_object_retriever._reconstruct_commit(rev, o.tree, True,
+        verifiers)
     if rec_o != o:
         raise AssertionError("Reconstructed commit differs: %r != %r" % (
             rec_o, o))
@@ -341,7 +347,7 @@
 def import_git_commit(repo, mapping, head, lookup_object,
                       target_git_object_retriever, trees_cache):
     o = lookup_object(head)
-    rev = mapping.import_commit(o,
+    rev, roundtrip_revid, verifiers = mapping.import_commit(o,
             lambda x: target_git_object_retriever.lookup_git_sha(x)[1][0])
     # We have to do this here, since we have to walk the tree and
     # we need to make sure to import the blobs / trees with the right
@@ -356,7 +362,6 @@
         base_tree = lookup_object(o.parents[0]).tree
         base_mode = stat.S_IFDIR
     store_updater = target_git_object_retriever._get_updater(rev)
-    store_updater.add_object(o, None, None)
     fileid_map = mapping.get_fileid_map(lookup_object, o.tree)
     inv_delta, unusual_modes = import_git_tree(repo.texts,
             mapping, "", "", (base_tree, o.tree), base_inv,
@@ -364,7 +369,6 @@
             lookup_object, (base_mode, stat.S_IFDIR), store_updater,
             fileid_map.lookup_file_id,
             allow_submodules=getattr(repo._format, "supports_tree_reference", False))
-    store_updater.finish()
     if unusual_modes != {}:
         for path, mode in unusual_modes.iteritems():
             warn_unusual_mode(rev.foreign_revid, path, mode)
@@ -376,13 +380,26 @@
         base_inv = None
     rev.inventory_sha1, inv = repo.add_inventory_by_delta(basis_id,
               inv_delta, rev.revision_id, rev.parent_ids, base_inv)
+    # Check verifiers
+    testament = StrictTestament3(rev, inv)
+    calculated_verifiers = { "testament3-sha1": testament.as_sha1() }
+    if roundtrip_revid is not None:
+        original_revid = rev.revision_id
+        rev.revision_id = roundtrip_revid
+        if calculated_verifiers != verifiers:
+            trace.mutter("Testament SHA1 %r for %r did not match %r.",
+                         calculated_verifiers["testament3-sha1"],
+                         rev.revision_id, verifiers["testament3-sha1"])
+            rev.revision_id = original_revid
+    store_updater.add_object(o, calculated_verifiers, None)
+    store_updater.finish()
     ret_tree = RevisionTree(repo, inv, rev.revision_id)
     trees_cache.add(ret_tree)
     repo.add_revision(rev.revision_id, rev)
     if "verify" in debug.debug_flags:
         verify_commit_reconstruction(target_git_object_retriever, 
             lookup_object, o, rev, ret_tree, parent_trees, mapping,
-            unusual_modes)
+            unusual_modes, verifiers)
 
 
 def import_git_objects(repo, mapping, object_iter,
@@ -414,8 +431,10 @@
         except KeyError:
             continue
         if isinstance(o, Commit):
-            rev = mapping.import_commit(o, lambda x: None)
-            if repo.has_revision(rev.revision_id):
+            rev, roundtrip_revid, verifiers = mapping.import_commit(o,
+                lambda x: None)
+            if (repo.has_revision(rev.revision_id) or
+                (roundtrip_revid and repo.has_revision(roundtrip_revid))):
                 continue
             graph.append((o.id, o.parents))
             heads.extend([p for p in o.parents if p not in checked])
@@ -479,6 +498,30 @@
     """Base InterRepository that copies revisions from a Git into a non-Git
     repository."""
 
+    def _target_has_shas(self, shas):
+        revids = [self.source.lookup_foreign_revision_id(sha) for sha in shas]
+        return self.target.has_revisions(revids)
+
+    def get_determine_wants_heads(self, wants, include_tags=False):
+        wants = set(wants)
+        def determine_wants(refs):
+            potential = set(wants)
+            if include_tags:
+                potential.update([v[0] for v in extract_tags(refs).itervalues()])
+            return list(potential - self._target_has_shas(potential))
+        return determine_wants
+
+    def get_determine_wants_revids(self, revids, include_tags=False):
+        wants = set()
+        for revid in set(revids):
+            git_sha, mapping = self.source.lookup_bzr_revision_id(revid)
+            wants.add(git_sha)
+        return self.get_determine_wants_heads(wants, include_tags=include_tags)
+
+    def determine_wants_all(self, refs):
+        potential = set([sha for (ref, sha) in refs.iteritems() if not ref.endswith("^{}")])
+        return list(potential - self._target_has_shas(potential))
+
     def fetch_objects(self, determine_wants, mapping, pb=None, limit=None):
         """Fetch objects from a remote server.
 
@@ -497,16 +540,22 @@
         if revision_id is not None:
             interesting_heads = [revision_id]
         elif fetch_spec is not None:
-            interesting_heads = fetch_spec.heads
+            recipe = fetch_spec.get_recipe()
+            if recipe[0] in ("search", "proxy-search"):
+                interesting_heads = recipe[1]
+            else:
+                raise AssertionError("Unsupported search result type %s" % recipe[0])
         else:
             interesting_heads = None
-        def determine_wants(refs):
-            if interesting_heads is None:
-                ret = [sha for (ref, sha) in refs.iteritems() if not ref.endswith("^{}")]
-            else:
-                ret = [self.source.lookup_bzr_revision_id(revid)[0] for revid in interesting_heads if revid not in (None, NULL_REVISION)]
-            return [rev for rev in ret if not self.target.has_revision(self.source.lookup_foreign_revision_id(rev))]
-        (pack_hint, _, remote_refs) = self.fetch_objects(determine_wants, mapping, pb)
+
+        if interesting_heads is not None:
+            determine_wants = self.get_determine_wants_revids(interesting_heads,
+                include_tags=False)
+        else:
+            determine_wants = self.determine_wants_all
+
+        (pack_hint, _, remote_refs) = self.fetch_objects(determine_wants,
+            mapping, pb)
         if pack_hint is not None and self.target._format.pack_compresses:
             self.target.pack(hint=pack_hint)
         return remote_refs
@@ -567,6 +616,7 @@
                 objects_iter = self.source.fetch_objects(
                     wants_recorder, graph_walker, store.get_raw,
                     progress)
+                trace.mutter("Importing %d new revisions", len(wants_recorder.wants))
                 (pack_hint, last_rev) = import_git_objects(self.target, mapping,
                     objects_iter, store, wants_recorder.wants, pb, limit)
                 return (pack_hint, last_rev, wants_recorder.remote_refs)
@@ -656,7 +706,12 @@
         if revision_id is not None:
             args = [mapping.revision_id_bzr_to_foreign(revision_id)[0]]
         elif fetch_spec is not None:
-            args = [mapping.revision_id_bzr_to_foreign(revid)[0] for revid in fetch_spec.heads]
+            recipe = fetch_spec.get_recipe()
+            if recipe[0] in ("search", "proxy-search"):
+                heads = recipe[1]
+            else:
+                raise AssertionError("Unsupported search result type %s" % recipe[0])
+            args = [mapping.revision_id_bzr_to_foreign(revid)[0] for revid in heads]
         if branches is not None:
             determine_wants = lambda x: [x[y] for y in branches if not x[y] in r.object_store]
         elif fetch_spec is None and revision_id is None:

=== added file 'help.py'
--- help.py	1970-01-01 00:00:00 +0000
+++ help.py	2011-03-23 20:12:35 +0000
@@ -0,0 +1,33 @@
+# Copyright (C) 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, see <http://www.gnu.org/licenses/>.
+
+"""Help information."""
+
+help_git = """Using Bazaar with Git.
+
+The bzr-git plugin provides support for using Bazaar with local and remote
+Git repositories, as just another format. You can clone, pull from and 
+push to git repositories as you would with any native Bazaar branch.
+
+The bzr-git plugin also adds two new bzr subcommands:
+
+ * bzr git-objects: Extracts Git objects out of a Bazaar repository
+ * bzr git-refs: Display Git refs from a Bazaar branch or repository
+ * bzr svn-import: Imports a local or remote Git repository to a set of Bazaar
+                   branches
+
+The 'git:' revision specifier can be used to find revisions by short or long
+GIT SHA1.
+"""

=== modified file 'info.py'
--- info.py	2010-08-05 23:42:42 +0000
+++ info.py	2011-03-23 20:12:35 +0000
@@ -1,15 +1,15 @@
 bzr_plugin_name = "git"
 
-dulwich_minimum_version = (0, 6, 1)
+dulwich_minimum_version = (0, 6, 2)
 
 # versions ending in 'exp' mean experimental mappings
 # versions ending in 'dev' mean development version
 # versions ending in 'final' mean release (well tested, etc)
-bzr_plugin_version = (0, 5, 3, 'dev', 0)
+bzr_plugin_version = (0, 5, 5, 'dev', 0)
 
 bzr_commands = ["git-import", "git-object", "git-refs", "git-apply"]
 
-bzr_compatible_versions = [(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]
 

=== modified file 'inventory.py'
--- inventory.py	2010-08-03 19:47:30 +0000
+++ inventory.py	2011-03-23 20:12:35 +0000
@@ -176,7 +176,7 @@
 
     def _retrieve_children(self):
         self._children = {}
-        for mode, name, hexsha in self.object.entries():
+        for name, mode, hexsha in self.object.iteritems():
             basename = name.decode("utf-8")
             child_path = osutils.pathjoin(self.path, basename)
             if self._inventory.mapping.is_control_file(child_path):
@@ -241,7 +241,6 @@
         path = self.fileid_map.lookup_path(file_id)
         try:
             ie = self._get_ie(path)
-            assert ie.path == path
         except KeyError:
             raise errors.NoSuchId(None, file_id)
 
@@ -313,8 +312,9 @@
     def path2id(self, path):
         if type(path) in (list, tuple):
             path = "/".join(path)
-        if path in self.index:
-            file_id = self.fileid_map.lookup_file_id(path)
+        encoded_path = path.encode("utf-8")
+        if encoded_path in self.index:
+            file_id = self.fileid_map.lookup_file_id(encoded_path)
         else:
             self._read_contents()
             file_id = super(GitIndexInventory, self).path2id(path)
@@ -357,7 +357,7 @@
                     self.add_parents(path)
                     self.add(old_ie)
                 else:
-                    ie = self.add_path(path, kind, file_id,
+                    ie = self.add_path(path.decode("utf-8"), kind, file_id,
                         self.add_parents(path))
                     data = self.store[sha].data
                     if kind == "symlink":
@@ -370,6 +370,7 @@
             pb.finished()
 
     def add_parents(self, path):
+        assert isinstance(path, str)
         dirname, _ = osutils.split(path)
         file_id = super(GitIndexInventory, self).path2id(dirname)
         if file_id is None:
@@ -377,7 +378,7 @@
                 parent_fid = None
             else:
                 parent_fid = self.add_parents(dirname)
-            ie = self.add_path(dirname, 'directory',
+            ie = self.add_path(dirname.decode("utf-8"), 'directory',
                     self.fileid_map.lookup_file_id(dirname), parent_fid)
             if self.basis_inv is not None and ie.file_id in self.basis_inv:
                 ie.revision = self.basis_inv[ie.file_id].revision

=== modified file 'mapping.py'
--- mapping.py	2010-08-01 22:29:21 +0000
+++ mapping.py	2011-03-23 20:12:35 +0000
@@ -104,7 +104,7 @@
         super(BzrGitMapping, self).__init__(foreign_git)
 
     def __eq__(self, other):
-        return (type(self) == type(other) and 
+        return (type(self) == type(other) and
                 self.revid_prefix == other.revid_prefix)
 
     @classmethod
@@ -185,7 +185,7 @@
 
     def _extract_git_svn_metadata(self, rev, message):
         lines = message.split("\n")
-        if not (lines[-1] == "" and lines[-2].startswith("git-svn-id:")):
+        if not (lines[-1] == "" and len(lines) >= 2 and lines[-2].startswith("git-svn-id:")):
             return message
         git_svn_id = lines[-2].split(": ", 1)[1]
         rev.properties['git-svn-id'] = git_svn_id
@@ -227,12 +227,15 @@
         b.set_raw_chunks(serialize_fileid_map(fileid_map))
         return b
 
-    def export_commit(self, rev, tree_sha, parent_lookup, roundtrip):
+    def export_commit(self, rev, tree_sha, parent_lookup, roundtrip,
+                      verifiers):
         """Turn a Bazaar revision in to a Git commit
 
         :param tree_sha: Tree sha for the commit
         :param parent_lookup: Function for looking up the GIT sha equiv of a
             bzr revision
+        :param roundtrip: Whether to store roundtripping information.
+        :param verifiers: Verifiers info
         :return dulwich.objects.Commit represent the revision:
         """
         from dulwich.objects import Commit
@@ -240,6 +243,7 @@
         commit.tree = tree_sha
         if roundtrip:
             metadata = BzrGitRevisionMetadata()
+            metadata.verifiers = verifiers
         else:
             metadata = None
         parents = []
@@ -307,8 +311,8 @@
     def import_commit(self, commit, lookup_parent_revid):
         """Convert a git commit to a bzr revision.
 
-        :return: a `bzrlib.revision.Revision` object and a 
-            dictionary of path -> file ids
+        :return: a `bzrlib.revision.Revision` object, foreign revid and a
+            testament sha1
         """
         if commit is None:
             raise AssertionError("Commit object can't be None")
@@ -347,12 +351,15 @@
         rev.timezone = commit.commit_timezone
         if rev.git_metadata is not None:
             md = rev.git_metadata
-            if md.revision_id:
-                rev.revision_id = md.revision_id
+            roundtrip_revid = md.revision_id
             if md.explicit_parent_ids:
                 rev.parent_ids = md.explicit_parent_ids
             rev.properties.update(md.properties)
-        return rev
+            verifiers = md.verifiers
+        else:
+            roundtrip_revid = None
+            verifiers = {}
+        return rev, roundtrip_revid, verifiers
 
     def get_fileid_map(self, lookup_object, tree_sha):
         """Obtain a fileid map for a particular tree.
@@ -400,9 +407,9 @@
         return ret
 
     def import_commit(self, commit, lookup_parent_revid):
-        rev, file_ids = super(BzrGitMappingExperimental, self).import_commit(commit, lookup_parent_revid)
+        rev, roundtrip_revid, verifiers = super(BzrGitMappingExperimental, self).import_commit(commit, lookup_parent_revid)
         rev.properties['converted_revision'] = "git %s\n" % commit.id
-        return rev, file_ids
+        return rev, roundtrip_revid, verifiers
 
 
 class GitMappingRegistry(VcsMappingRegistry):

=== modified file 'object_store.py'
--- object_store.py	2010-08-03 19:43:59 +0000
+++ object_store.py	2011-03-23 20:12:35 +0000
@@ -18,6 +18,7 @@
 
 from dulwich.objects import (
     Blob,
+    Commit,
     Tree,
     sha_to_hex,
     )
@@ -35,6 +36,9 @@
 from bzrlib.revision import (
     NULL_REVISION,
     )
+from bzrlib.testament import(
+    StrictTestament3,
+    )
 
 from bzrlib.plugins.git.mapping import (
     default_mapping,
@@ -104,7 +108,7 @@
         self._cache.add(tree.get_revision_id(), tree)
 
 
-def _find_missing_bzr_revids(get_parent_map, want, have):
+def _find_missing_bzr_revids(graph, want, have):
     """Find the revisions that have to be pushed.
 
     :param get_parent_map: Function that returns the parents for a sequence
@@ -113,19 +117,9 @@
     :param have: Revisions the target already has
     :return: Set of revisions to fetch
     """
-    pending = want - have
-    processed = set()
     todo = set()
-    while pending:
-        processed.update(pending)
-        next_map = get_parent_map(pending)
-        next_pending = set()
-        for item in next_map.iteritems():
-            if item[0] in have:
-                continue
-            todo.add(item[0])
-            next_pending.update(p for p in item[1] if p not in processed)
-        pending = next_pending
+    for rev in want:
+        todo.update(graph.find_unique_ancestors(rev, have))
     if NULL_REVISION in todo:
         todo.remove(NULL_REVISION)
     return todo
@@ -220,7 +214,9 @@
             new_trees[posixpath.dirname(path[1])] = parent[1]
         elif kind[1] not in (None, "directory"):
             raise AssertionError(kind[1])
-        if path[0] is not None and parent[0] in tree.inventory and tree.inventory[parent[0]].kind == "directory":
+        if (path[0] not in (None, "") and
+            parent[0] in tree.inventory and
+            tree.inventory[parent[0]].kind == "directory"):
             # Removal
             new_trees[posixpath.dirname(path[0])] = parent[0]
     
@@ -336,14 +332,22 @@
         self._update_sha_map()
         return iter(self._cache.idmap.sha1s())
 
-    def _reconstruct_commit(self, rev, tree_sha, roundtrip):
+    def _reconstruct_commit(self, rev, tree_sha, roundtrip, verifiers):
+        """Reconstruct a Commit object.
+
+        :param rev: Revision object
+        :param tree_sha: SHA1 of the root tree object
+        :param roundtrip: Whether or not to roundtrip bzr metadata
+        :param verifiers: Verifiers for the commits
+        :return: Commit object
+        """
         def parent_lookup(revid):
             try:
                 return self._lookup_revision_sha1(revid)
             except errors.NoSuchRevision:
                 return None
         return self.mapping.export_commit(rev, tree_sha, parent_lookup,
-            roundtrip)
+            roundtrip, verifiers)
 
     def _create_fileid_map_blob(self, inv):
         # FIXME: This can probably be a lot more efficient, 
@@ -388,8 +392,13 @@
                 root_tree[self.mapping.BZR_FILE_IDS_FILE] = ((stat.S_IFREG | 0644), b.id)
                 yield self.mapping.BZR_FILE_IDS_FILE, b, None
         yield "", root_tree, root_ie
+        if roundtrip:
+            testament3 = StrictTestament3(rev, tree.inventory)
+            verifiers = { "testament3-sha1": testament3.as_sha1() }
+        else:
+            verifiers = {}
         commit_obj = self._reconstruct_commit(rev, root_tree.id,
-            roundtrip=roundtrip)
+            roundtrip=roundtrip, verifiers=verifiers)
         try:
             foreign_revid, mapping = mapping_registry.parse_revision_id(
                 rev.revision_id)
@@ -408,6 +417,9 @@
         updater = self._get_updater(rev)
         for path, obj, ie in self._revision_to_objects(rev, tree,
             roundtrip=True):
+            if isinstance(obj, Commit):
+                testament3 = StrictTestament3(rev, tree.inventory)
+                ie = { "testament3-sha1": testament3.as_sha1() }
             updater.add_object(obj, ie, path)
         commit_obj = updater.finish()
         return commit_obj.id
@@ -525,7 +537,7 @@
         ret = {}
         for sha in shas:
             if sha == ZERO_SHA:
-                ret[sha] = ("commit", (NULL_REVISION, None))
+                ret[sha] = ("commit", (NULL_REVISION, None, {}))
                 continue
             try:
                 ret[sha] = self._cache.idmap.lookup_git_sha(sha)
@@ -553,14 +565,15 @@
         (type, type_data) = self.lookup_git_sha(sha)
         # convert object to git object
         if type == "commit":
-            (revid, tree_sha) = type_data
+            (revid, tree_sha, verifiers) = type_data
             try:
                 rev = self.repository.get_revision(revid)
             except errors.NoSuchRevision:
                 trace.mutter('entry for %s %s in shamap: %r, but not found in '
                              'repository', type, sha, type_data)
                 raise KeyError(sha)
-            commit = self._reconstruct_commit(rev, tree_sha, roundtrip=True)
+            commit = self._reconstruct_commit(rev, tree_sha, roundtrip=True,
+                verifiers=verifiers)
             _check_expected_sha(sha, commit)
             return commit
         elif type == "blob":
@@ -599,7 +612,7 @@
         ret = self.lookup_git_shas(have + want)
         for commit_sha in have:
             try:
-                (type, (revid, tree_sha)) = ret[commit_sha]
+                (type, (revid, tree_sha, verifiers)) = ret[commit_sha]
             except KeyError:
                 pass
             else:
@@ -610,22 +623,25 @@
             if commit_sha in have:
                 continue
             try:
-                (type, (revid, tree_sha)) = ret[commit_sha]
+                (type, (revid, tree_sha, verifiers)) = ret[commit_sha]
             except KeyError:
                 pass
             else:
                 assert type == "commit"
                 pending.add(revid)
 
-        todo = _find_missing_bzr_revids(self.repository.get_parent_map, 
-                                        pending, processed)
+        graph = self.repository.get_graph()
+        todo = _find_missing_bzr_revids(graph, pending, processed)
         trace.mutter('sending revisions %r', todo)
         ret = []
         pb = ui.ui_factory.nested_progress_bar()
         try:
             for i, revid in enumerate(todo):
                 pb.update("generating git objects", i, len(todo))
-                rev = self.repository.get_revision(revid)
+                try:
+                    rev = self.repository.get_revision(revid)
+                except errors.NoSuchRevision:
+                    continue
                 tree = self.tree_cache.revision_tree(revid)
                 for path, obj, ie in self._revision_to_objects(rev, tree,
                     roundtrip=not lossy):

=== modified file 'push.py'
--- push.py	2010-07-24 11:15:11 +0000
+++ push.py	2011-03-23 20:12:35 +0000
@@ -20,9 +20,6 @@
     errors,
     ui,
     )
-from bzrlib.graph import (
-    PendingAncestryResult,
-    )
 from bzrlib.repository import (
     InterRepository,
     )
@@ -44,6 +41,9 @@
 from bzrlib.plugins.git.remote import (
     RemoteGitRepository,
     )
+from bzrlib.plugins.git.refs import (
+    UnpeelMap,
+    )
 
 
 class MissingObjectsIterator(object):
@@ -116,7 +116,7 @@
     def dfetch_refs(self, update_refs):
         """Fetch non-roundtripped revisions into the target repository.
 
-        :param update_refs: Generate refs to fetch. Receives dictionary 
+        :param update_refs: Generate refs to fetch. Receives dictionary
             with old names to old git shas. Should return a dictionary
             of new names to Bazaar revision ids.
         :return: revision id map, old refs dictionary and new refs dictionary
@@ -126,8 +126,8 @@
     def fetch_refs(self, update_refs):
         """Fetch possibly roundtripped revisions into the target repository.
 
-        :param update_refs: Generate refs to fetch. Receives dictionary 
-            with old refs (git shas), returns dictionary of new names to 
+        :param update_refs: Generate refs to fetch. Receives dictionary
+            with old refs (git shas), returns dictionary of new names to
             git shas.
         :return: old refs, new refs
         """
@@ -142,13 +142,14 @@
         self.target_store = self.target._git.object_store
         self.target_refs = self.target._git.refs
 
-    def _revision_needs_fetching(self, revid):
+    def _revision_needs_fetching(self, sha_id, revid):
         if revid == NULL_REVISION:
             return False
-        try:
-            sha_id = self.source_store._lookup_revision_sha1(revid)
-        except KeyError:
-            raise errors.NoSuchRevision(self.source, revid)
+        if sha_id is None:
+            try:
+                sha_id = self.source_store._lookup_revision_sha1(revid)
+            except KeyError:
+                return False
         try:
             return (sha_id not in self.target_store)
         except errors.NoSuchRevision:
@@ -158,22 +159,43 @@
     def missing_revisions(self, stop_revisions):
         """Find the revisions that are missing from the target repository.
 
-        :param stop_revisions: Revisions to check for
+        :param stop_revisions: Revisions to check for (tuples with
+            Git SHA1, bzr revid)
         :return: sequence of missing revisions, in topological order
         :raise: NoSuchRevision if the stop_revisions are not present in
             the source
         """
+        revid_sha_map = {}
+        stop_revids = []
+        stop_sha1s = []
+        for (sha1, revid) in stop_revisions:
+            if sha1 is not None and revid is not None:
+                revid_sha_map[revid] = sha1
+            elif sha1 is not None:
+                stop_sha1s.append(sha1)
+            else:
+                assert revid is not None
+                stop_revids.append(revid)
         missing = []
         graph = self.source.get_graph()
         pb = ui.ui_factory.nested_progress_bar()
         try:
-            for revid, _ in graph.iter_ancestry(stop_revisions):
+            for revid, _ in graph.iter_ancestry(stop_revids):
                 assert type(revid) is str
                 pb.update("determining revisions to fetch", len(missing))
-                if self._revision_needs_fetching(revid):
+                sha1 = revid_sha_map.get(revid)
+                if self._revision_needs_fetching(sha1, revid):
                     missing.append(revid)
         finally:
             pb.finished()
+        for sha1 in stop_sha1s:
+            try:
+                (kind, (revid, tree_sha, verifiers)) = self.source_store.lookup_git_sha(sha1)
+            except KeyError:
+                continue
+            else:
+                missing.append(revid)
+                revid_sha_map[revid] = sha1
         return graph.iter_topo_order(missing)
 
     def _get_target_bzr_refs(self):
@@ -186,9 +208,14 @@
         refs = self.target._git.get_refs()
         for k, v in refs.iteritems():
             try:
-                (kind, (revid, treesha)) = self.source_store.lookup_git_sha(v)
+                (kind, type_data) = self.source_store.lookup_git_sha(v)
             except KeyError:
                 revid = None
+            else:
+                if kind == "commit":
+                    revid = type_data[0]
+                else:
+                    revid = None
             bzr_refs[k] = (v, revid)
         return bzr_refs
 
@@ -197,10 +224,7 @@
         try:
             old_refs = self._get_target_bzr_refs()
             new_refs = update_refs(old_refs)
-            # FIXME: Keep track of already looked up revid<->sha mappings
-            fetch_spec = PendingAncestryResult(
-                [revid for sha, revid in new_refs.values()], self.source)
-            self.fetch(fetch_spec=fetch_spec)
+            self.fetch(mapped_refs=new_refs.values())
         finally:
             self.source.unlock()
         return old_refs, new_refs
@@ -232,7 +256,7 @@
         revidmap = {}
         self.source.lock_read()
         try:
-            todo = list(self.missing_revisions([revid for sha, revid in stop_revisions]))
+            todo = list(self.missing_revisions(stop_revisions))
             pb = ui.ui_factory.nested_progress_bar()
             try:
                 object_generator = self._get_missing_objects_iterator(pb)
@@ -249,13 +273,15 @@
         return revidmap, gitidmap
 
     def fetch(self, revision_id=None, pb=None, find_ghosts=False,
-            fetch_spec=None):
-        if revision_id is not None:
-            stop_revisions = [revision_id]
+            fetch_spec=None, mapped_refs=None):
+        if mapped_refs is not None:
+            stop_revisions = mapped_refs
+        elif revision_id is not None:
+            stop_revisions = [(None, revision_id)]
         elif fetch_spec is not None:
-            stop_revisions = fetch_spec.heads
+            stop_revisions = [(None, revid) for revid in fetch_spec.heads]
         else:
-            stop_revisions = self.source.all_revision_ids()
+            stop_revisions = [(None, revid) for revid in self.source.all_revision_ids()]
         self.source.lock_read()
         try:
             todo = list(self.missing_revisions(stop_revisions))
@@ -285,14 +311,15 @@
 
     def dfetch_refs(self, update_refs):
         """Import the gist of the ancestry of a particular revision."""
+        unpeel_map = UnpeelMap.from_repository(self.source)
         revidmap = {}
         def determine_wants(old_refs):
             ret = {}
-            self.old_refs = old_refs
+            self.old_refs = dict([(k, (v, None)) for (k, v) in old_refs.iteritems()])
             self.new_refs = update_refs(self.old_refs)
             for name, (gitid, revid) in self.new_refs.iteritems():
                 if gitid is None:
-                    ret[name] = self.source_store._lookup_revision_sha1(revid)
+                    ret[name] = unpeel_map.re_unpeel_tag(self.source_store._lookup_revision_sha1(revid), old_refs.get(name))
                 else:
                     ret[name] = gitid
             return ret

=== modified file 'refs.py'
--- refs.py	2010-08-12 19:36:37 +0000
+++ refs.py	2011-03-23 20:12:35 +0000
@@ -16,31 +16,43 @@
 
 """Conversion between refs and Bazaar revision pointers."""
 
+from collections import defaultdict
+from cStringIO import StringIO
+
 from dulwich.repo import (
     RefsContainer,
     )
 
 from bzrlib import (
     errors,
+    trace,
     )
 
+is_tag = lambda x: x.startswith("refs/tags/")
+
 
 def extract_tags(refs):
     """Extract the tags from a refs dictionary.
 
     :param refs: Refs to extract the tags from.
-    :return: Dictionary mapping tag names to SHA1s.
+    :return: Dictionary mapping tag names to SHA1s of the actual object
+        and unpeeled object SHA1s.
     """
     ret = {}
-    for k,v in refs.iteritems():
-        if k.startswith("refs/tags/") and not k.endswith("^{}"):
-            v = refs.get(k+"^{}", v)
+    for k, v in refs.iteritems():
+        if is_tag(k) and not k.endswith("^{}"):
+            try:
+                peeled = refs[k+"^{}"]
+                unpeeled = v
+            except KeyError:
+                peeled = v
+                unpeeled = None
             try:
                 tagname = ref_to_tag_name(k)
             except UnicodeDecodeError:
                 pass
             else:
-                ret[tagname] = v
+                ret[tagname] = (peeled, unpeeled)
     return ret
 
 
@@ -85,7 +97,7 @@
 def ref_to_tag_name(ref):
     if ref.startswith("refs/tags/"):
         return ref[len('refs/tags/'):].decode("utf-8")
-    raise ValueError("unable to map ref %s back to branch name" % ref)
+    raise ValueError("unable to map ref %s back to tag name" % ref)
 
 
 class BazaarRefsContainer(RefsContainer):
@@ -169,3 +181,62 @@
             target_branch.generate_revision_history(rev_id)
         finally:
             target_branch.unlock()
+
+
+class UnpeelMap(object):
+    """Unpeel map.
+
+    Keeps track of the unpeeled object id of tags.
+    """
+
+    def __init__(self):
+        self._map = defaultdict(set)
+
+    def update(self, m):
+        for k, v in m.iteritems():
+            self._map[k].update(v)
+
+    def load(self, f):
+        firstline = f.readline()
+        if firstline != "unpeel map version 1\n":
+            raise AssertionError("invalid format for unpeel map: %r" % firstline)
+        for l in f.readlines():
+            (k, v) = l.split(":", 1)
+            self._map[k.strip()].add(v.strip())
+
+    def save(self, f):
+        f.write("unpeel map version 1\n")
+        for k, vs in self._map.iteritems():
+            for v in vs:
+                f.write("%s: %s\n" % (k, v))
+
+    def save_in_repository(self, repository):
+        f = StringIO()
+        try:
+            self.save(f)
+            f.seek(0)
+            repository.control_transport.put_file("git-unpeel-map", f)
+        finally:
+            f.close()
+
+    def re_unpeel_tag(self, new_git_sha, old_git_sha):
+        """Re-unpeel tags.
+
+        Bazaar can't store unpeeled refs so in order to prevent peeling
+        existing tags when pushing they are "re-peeled" here.
+        """
+        if old_git_sha is not None and old_git_sha in self._map[new_git_sha]:
+            trace.mutter("re-unpeeling %r to %r", new_git_sha, old_git_sha)
+            return old_git_sha
+        return new_git_sha
+
+    @classmethod
+    def from_repository(cls, repository):
+        """Load the unpeel map for a repository.
+        """
+        m = UnpeelMap()
+        try:
+            m.load(repository.control_transport.get("git-unpeel-map"))
+        except errors.NoSuchFile:
+            pass
+        return m

=== modified file 'remote.py'
--- remote.py	2010-06-28 19:52:39 +0000
+++ remote.py	2011-03-23 20:12:35 +0000
@@ -1,4 +1,4 @@
-# Copyright (C) 2007-2009 Jelmer Vernooij <[e-mail]>
+# Copyright (C) 2007-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
@@ -17,7 +17,6 @@
 from bzrlib import (
     config,
     debug,
-    tag,
     trace,
     ui,
     urlutils,
@@ -27,7 +26,9 @@
     InvalidRevisionId,
     NoSuchFile,
     NoSuchRevision,
+    NotBranchError,
     NotLocalUrl,
+    UninitializableFormat,
     )
 from bzrlib.transport import (
     Transport,
@@ -40,14 +41,18 @@
 
 from bzrlib.plugins.git.branch import (
     GitBranch,
+    GitTags,
+    )
+from bzrlib.plugins.git.dir import (
+    GitControlDirFormat,
+    GitDir,
+    GitLockableFiles,
+    GitLock,
     )
 from bzrlib.plugins.git.errors import (
     GitSmartRemoteNotSupported,
     NoSuchRef,
     )
-from bzrlib.plugins.git.dir import (
-    GitDir,
-    )
 from bzrlib.plugins.git.mapping import (
     mapping_registry,
     )
@@ -204,14 +209,17 @@
         self._lockfiles = lockfiles
         self._mode_check_done = None
 
+    @property
+    def user_url(self):
+        return self.control_url
+
     def _branch_name_to_ref(self, name, default=None):
         return branch_name_to_ref(name, default=default)
 
     def open_repository(self):
         return RemoteGitRepository(self, self._lockfiles)
 
-    def _open_branch(self, name=None, ignore_fallbacks=False, 
-                    unsupported=False):
+    def open_branch(self, name=None, unsupported=False, ignore_fallbacks=False):
         repo = self.open_repository()
         refname = self._branch_name_to_ref(name)
         return RemoteGitBranch(self, repo, refname, self._lockfiles)
@@ -262,6 +270,37 @@
             os.remove(self._data_path)
 
 
+class RemoteGitControlDirFormat(GitControlDirFormat):
+    """The .git directory control format."""
+
+    supports_workingtrees = False
+
+    @classmethod
+    def _known_formats(self):
+        return set([RemoteGitControlDirFormat()])
+
+    def open(self, transport, _found=None):
+        """Open this directory.
+
+        """
+        # we dont grok readonly - git isn't integrated with transport.
+        url = transport.base
+        if url.startswith('readonly+'):
+            url = url[len('readonly+'):]
+        if (not url.startswith("git://") and not url.startswith("git+")):
+            raise NotBranchError(transport.base)
+        if not isinstance(transport, GitSmartTransport):
+            raise NotBranchError(transport.base)
+        lockfiles = GitLockableFiles(transport, GitLock())
+        return RemoteGitDir(transport, lockfiles, self)
+
+    def get_format_description(self):
+        return "Remote Git Repository"
+
+    def initialize_on_transport(self, transport):
+        raise UninitializableFormat(self)
+
+
 class RemoteGitRepository(GitRepository):
 
     def __init__(self, gitdir, lockfiles):
@@ -269,6 +308,10 @@
         self._refs = None
 
     @property
+    def user_url(self):
+        return self.control_url
+
+    @property
     def inventories(self):
         raise GitSmartRemoteNotSupported()
 
@@ -322,17 +365,15 @@
         return mapping.revision_id_foreign_to_bzr(foreign_revid)
 
 
-class RemoteGitTagDict(tag.BasicTags):
-
-    def __init__(self, branch):
-        self.branch = branch
-        self.repository = branch.repository
-
-    def get_tag_dict(self):
-        tags = {}
-        for k, v in extract_tags(self.repository.get_refs()).iteritems():
-            tags[k] = self.branch.mapping.revision_id_foreign_to_bzr(v)
-        return tags
+class RemoteGitTagDict(GitTags):
+
+    def get_refs(self):
+        return self.repository.get_refs()
+
+    def _iter_tag_refs(self, refs):
+        for k, (peeled, unpeeled) in extract_tags(refs).iteritems():
+            yield (k, peeled, unpeeled,
+                  self.branch.mapping.revision_id_foreign_to_bzr(peeled))
 
     def set_tag(self, name, revid):
         # FIXME: Not supported yet, should do a push of a new ref
@@ -346,6 +387,14 @@
         super(RemoteGitBranch, self).__init__(bzrdir, repository, name,
                 lockfiles)
 
+    @property
+    def user_url(self):
+        return self.control_url
+
+    @property
+    def control_url(self):
+        return self.base
+
     def revision_history(self):
         raise GitSmartRemoteNotSupported()
 

=== modified file 'repository.py'
--- repository.py	2010-06-28 22:30:34 +0000
+++ repository.py	2011-03-23 20:12:35 +0000
@@ -47,6 +47,7 @@
 
 from dulwich.objects import (
     Commit,
+    Tag,
     )
 
 
@@ -56,10 +57,10 @@
     _serializer = None
     _commit_builder_class = GitCommitBuilder
     vcs = foreign_git
+    chk_bytes = None
 
     def __init__(self, gitdir, lockfiles):
-        ForeignRepository.__init__(self, GitRepositoryFormat(), gitdir,
-            lockfiles)
+        ForeignRepository.__init__(self, GitRepositoryFormat(), gitdir, lockfiles)
         from bzrlib.plugins.git import fetch, push
         for optimiser in [fetch.InterRemoteGitNonGitRepository,
                           fetch.InterLocalGitNonGitRepository,
@@ -74,7 +75,7 @@
     def supports_rich_root(self):
         return True
 
-    def _warn_if_deprecated(self, branch=None):
+    def _warn_if_deprecated(self, branch=None): # for bzr < 2.4
         # This class isn't deprecated
         pass
 
@@ -82,7 +83,7 @@
         return default_mapping
 
     def make_working_trees(self):
-        return True
+        return not self._git.bare
 
     def revision_graph_can_have_wrong_parents(self):
         return False
@@ -105,18 +106,21 @@
         self.texts = GitTexts(self)
 
     def _iter_revision_ids(self):
+        mapping = self.get_mapping()
         for sha in self._git.object_store:
             o = self._git.object_store[sha]
             if not isinstance(o, Commit):
                 continue
-            rev = self.get_mapping().import_commit(o,
+            rev, roundtrip_revid, verifiers = mapping.import_commit(o,
                 self.lookup_foreign_revision_id)
-            yield o.id, rev.revision_id
+            yield o.id, rev.revision_id, roundtrip_revid
 
     def all_revision_ids(self):
         ret = set([])
-        for git_sha, revid in self._iter_revision_ids():
+        for git_sha, revid, roundtrip_revid in self._iter_revision_ids():
             ret.add(revid)
+            if roundtrip_revid:
+                ret.add(roundtrip_revid)
         return ret
 
     def get_parent_map(self, revids):
@@ -131,7 +135,12 @@
                 commit = self._git[hexsha]
             except KeyError:
                 continue
-            parent_map[revision_id] = [self.lookup_foreign_revision_id(p, mapping) for p in commit.parents]
+            parents = [
+                self.lookup_foreign_revision_id(p, mapping)
+                for p in commit.parents]
+            if parents == []:
+                parents = [revision.NULL_REVISION]
+            parent_map[revision_id] = tuple(parents)
         return parent_map
 
     def get_ancestry(self, revision_id, topo_sorted=True):
@@ -144,6 +153,8 @@
         graph = self.get_graph()
         for rev, parents in graph.iter_ancestry([revision_id]):
             ancestry.append(rev)
+        if revision.NULL_REVISION in ancestry:
+            ancestry.remove(revision.NULL_REVISION)
         ancestry.reverse()
         return [None] + ancestry
 
@@ -157,6 +168,7 @@
         """Lookup a revision id.
 
         """
+        assert type(foreign_revid) is str
         if mapping is None:
             mapping = self.get_mapping()
         from dulwich.protocol import (
@@ -165,8 +177,15 @@
         if foreign_revid == ZERO_SHA:
             return revision.NULL_REVISION
         commit = self._git[foreign_revid]
-        rev = mapping.import_commit(commit, lambda x: None)
-        return rev.revision_id
+        while isinstance(commit, Tag):
+            commit = self._git[commit.object[1]]
+        rev, roundtrip_revid, verifiers = mapping.import_commit(commit,
+            lambda x: None)
+        # FIXME: check testament before doing this?
+        if roundtrip_revid:
+            return roundtrip_revid
+        else:
+            return rev.revision_id
 
     def has_signature_for_revision_id(self, revision_id):
         return False
@@ -178,29 +197,39 @@
             if mapping is None:
                 mapping = self.get_mapping()
             try:
-                return self._git.refs[mapping.revid_as_refname(bzr_revid)], mapping
+                return (self._git.refs[mapping.revid_as_refname(bzr_revid)], mapping)
             except KeyError:
                 # Update refs from Git commit objects
                 # FIXME: Hitting this a lot will be very inefficient...
-                for git_sha, revid in self._iter_revision_ids():
-                    self._git.refs[mapping.revid_as_refname(revid)] = git_sha
-                    if revid == bzr_revid:
+                for git_sha, revid, roundtrip_revid in self._iter_revision_ids():
+                    if not roundtrip_revid:
+                        continue
+                    refname = mapping.revid_as_refname(roundtrip_revid)
+                    self._git.refs[refname] = git_sha
+                    if roundtrip_revid == bzr_revid:
                         return git_sha, mapping
                 raise errors.NoSuchRevision(self, bzr_revid)
 
     def get_revision(self, revision_id):
+        if not isinstance(revision_id, str):
+            raise errors.InvalidRevisionId(revision_id, self)
         git_commit_id, mapping = self.lookup_bzr_revision_id(revision_id)
         try:
             commit = self._git[git_commit_id]
         except KeyError:
             raise errors.NoSuchRevision(self, revision_id)
-        # print "fetched revision:", git_commit_id
-        revision = mapping.import_commit(commit,
-            self.lookup_foreign_revision_id)
+        revision, roundtrip_revid, verifiers = mapping.import_commit(
+            commit, self.lookup_foreign_revision_id)
         assert revision is not None
+        # FIXME: check verifiers ?
+        if roundtrip_revid:
+            revision.revision_id = roundtrip_revid
         return revision
 
     def has_revision(self, revision_id):
+        """See Repository.has_revision."""
+        if revision_id == revision.NULL_REVISION:
+            return True
         try:
             git_commit_id, mapping = self.lookup_bzr_revision_id(revision_id)
         except errors.NoSuchRevision:
@@ -208,16 +237,20 @@
         return (git_commit_id in self._git)
 
     def has_revisions(self, revision_ids):
+        """See Repository.has_revisions."""
         return set(filter(self.has_revision, revision_ids))
 
     def get_revisions(self, revids):
+        """See Repository.get_revisions."""
         return [self.get_revision(r) for r in revids]
 
     def revision_trees(self, revids):
+        """See Repository.revision_trees."""
         for revid in revids:
             yield self.revision_tree(revid)
 
     def revision_tree(self, revision_id):
+        """See Repository.revision_tree."""
         revision_id = revision.ensure_null(revision_id)
         if revision_id == revision.NULL_REVISION:
             inv = inventory.Inventory(root_id=None)
@@ -230,17 +263,16 @@
         return self.revision_tree(revision_id).inventory
 
     def set_make_working_trees(self, trees):
-        pass
+        raise NotImplementedError(self.set_make_working_trees)
 
     def fetch_objects(self, determine_wants, graph_walker, resolve_ext_ref,
         progress=None):
         return self._git.fetch_objects(determine_wants, graph_walker, progress)
 
-    def _get_versioned_file_checker(self, text_key_references=None,
-                        ancestors=None):
+    def _get_versioned_file_checker(self, text_key_references=None, ancestors=None):
         return GitVersionedFileChecker(self,
             text_key_references=text_key_references, ancestors=ancestors)
-    
+
 
 class GitVersionedFileChecker(repository._VersionedFileChecker):
 
@@ -255,12 +287,25 @@
 
     supports_tree_reference = False
     rich_root_data = True
+    supports_leaving_lock = False
+    fast_deltas = True
+    supports_funky_characters = True
+    supports_external_lookups = False
+    supports_full_versioned_files = False
+
+    @property
+    def _matchingbzrdir(self):
+        from bzrlib.plugins.git.dir import LocalGitControlDirFormat
+        return LocalGitControlDirFormat()
 
     def get_format_description(self):
         return "Git Repository"
 
-    def initialize(self, url, shared=False, _internal=False):
-        raise errors.UninitializableFormat(self)
+    def initialize(self, controldir, shared=False, _internal=False):
+        from bzrlib.plugins.git.dir import GitDir
+        if not isinstance(controldir, GitDir):
+            raise errors.UninitializableFormat(self)
+        return controldir.open_repository()
 
     def check_conversion_target(self, target_repo_format):
         return target_repo_format.rich_root_data

=== modified file 'roundtrip.py'
--- roundtrip.py	2010-05-13 08:40:18 +0000
+++ roundtrip.py	2011-03-23 20:12:35 +0000
@@ -22,16 +22,19 @@
 
 class BzrGitRevisionMetadata(object):
     """Metadata for a Bazaar revision roundtripped into Git.
-    
+
     :ivar revision_id: Revision id, as string
     :ivar properties: Revision properties, as dictionary
     :ivar explicit_parent_ids: Parent ids (needed if there are ghosts)
+    :ivar verifiers: Verifier information
     """
 
     revision_id = None
 
     explicit_parent_ids = None
 
+    verifiers = {}
+
     def __init__(self):
         self.properties = {}
 
@@ -49,6 +52,8 @@
             ret.revision_id = value.strip()
         elif key == "parent-ids":
             ret.explicit_parent_ids = tuple(value.strip().split(" "))
+        elif key == "testament3-sha1":
+            ret.verifiers["testament3-sha1"] = value.strip()
         elif key.startswith("property-"):
             ret.properties[key[len("property-"):]] = value[1:].rstrip("\n")
         else:
@@ -69,6 +74,9 @@
         lines.append("parent-ids: %s\n" % " ".join(metadata.explicit_parent_ids))
     for key in sorted(metadata.properties.keys()):
         lines.append("property-%s: %s\n" % (key.encode(encoding), metadata.properties[key].encode(encoding)))
+    if "testament3-sha1" in metadata.verifiers:
+        lines.append("testament3-sha1: %s\n" %
+                     metadata.verifiers["testament3-sha1"])
     return "".join(lines)
 
 
@@ -88,20 +96,24 @@
     if not metadata:
         return message
     rt_data = generate_roundtripping_metadata(metadata, encoding)
+    if not rt_data:
+        return message
     assert type(rt_data) == str
     return message + "\n--BZR--\n" + rt_data
 
 
 def serialize_fileid_map(file_ids):
+    """Serialize a file id map."""
     lines = []
     for path in sorted(file_ids.keys()):
         lines.append("%s\0%s\n" % (path, file_ids[path]))
     return lines
 
 
-def deserialize_fileid_map(file):
+def deserialize_fileid_map(filetext):
+    """Deserialize a file id map."""
     ret = {}
-    f = StringIO(file)
+    f = StringIO(filetext)
     lines = f.readlines()
     for l in lines:
         (path, file_id) = l.rstrip("\n").split("\0")

=== modified file 'send.py'
--- send.py	2010-03-13 02:48:37 +0000
+++ send.py	2011-03-23 20:12:35 +0000
@@ -30,12 +30,7 @@
     revision as _mod_revision,
     )
 
-try:
-    from bzrlib.merge_directive import BaseMergeDirective
-except ImportError:
-    from bzrlib.merge_directive import (
-        _BaseMergeDirective as BaseMergeDirective,
-        )
+from bzrlib.merge_directive import BaseMergeDirective
 
 from bzrlib.plugins.git import (
     version_info as bzr_git_version_info,

=== modified file 'tests/__init__.py'
--- tests/__init__.py	2010-08-03 21:37:59 +0000
+++ tests/__init__.py	2011-03-23 20:12:35 +0000
@@ -27,6 +27,9 @@
 from bzrlib.plugins.git import (
     import_dulwich,
     )
+from fastimport import (
+    commands,
+    )
 
 TestCase = tests.TestCase
 TestCaseInTempDir = tests.TestCaseInTempDir
@@ -73,11 +76,8 @@
 
     def _create_blob(self, content):
         self._counter += 1
-        self._write('blob\n')
-        self._write('mark :%d\n' % (self._counter,))
-        self._write('data %d\n' % (len(content),))
-        self._write(content)
-        self._write('\n')
+        blob = commands.BlobCommand(str(self._counter), content)
+        self._write(str(blob)+"\n")
         return self._counter
 
     def set_symlink(self, path, content):
@@ -136,11 +136,11 @@
             commit.
         """
         self._counter += 1
-        mark = self._counter
+        mark = str(self._counter)
         if timestamp is None:
             timestamp = int(time.time())
         self._write('commit %s\n' % (self._branch,))
-        self._write('mark :%d\n' % (mark,))
+        self._write('mark :%s\n' % (mark,))
         self._write('committer %s %s %s\n'
                     % (committer, timestamp, timezone))
         message = message.encode('UTF-8')
@@ -148,10 +148,10 @@
         self._write(message)
         self._write('\n')
         if base is not None:
-            self._write('from :%d\n' % (base,))
+            self._write('from :%s\n' % (base,))
         if merge is not None:
             for m in merge:
-                self._write('merge :%d\n' % (m,))
+                self._write('merge :%s\n' % (m,))
         self._writelines(self.commit_info)
         self._write('\n')
         self.commit_info = []
@@ -167,7 +167,7 @@
             ref = self._branch
         self._write('reset %s\n' % (ref,))
         if mark is not None:
-            self._write('from :%d\n' % mark)
+            self._write('from :%s\n' % mark)
         self._write('\n')
 
     def finish(self):
@@ -176,15 +176,15 @@
         if self.orig_stream is None:
             from dulwich.repo import Repo
             r = Repo(".")
-            from dulwich.fastexport import FastImporter
-            importer = FastImporter(r)
+            from dulwich.fastexport import GitImportProcessor
+            importer = GitImportProcessor(r)
             return importer.import_stream(self.stream)
 
 
 def test_suite():
-    loader = tests.TestLoader()
+    loader = tests.TestUtil.TestLoader()
 
-    suite = tests.TestSuite()
+    suite = tests.TestUtil.TestSuite()
 
     testmod_names = [
         'test_blackbox',
@@ -202,6 +202,7 @@
         'test_revspec',
         'test_roundtrip',
         'test_transportgit',
+        'test_versionedfiles',
         ]
     testmod_names = ['%s.%s' % (__name__, t) for t in testmod_names]
     suite.addTests(loader.loadTestsFromModuleNames(testmod_names))

=== modified file 'tests/test_blackbox.py'
--- tests/test_blackbox.py	2010-05-22 22:55:03 +0000
+++ tests/test_blackbox.py	2011-03-23 20:12:35 +0000
@@ -76,7 +76,7 @@
         self.assertEqual(output, "a\n")
 
     def test_init(self):
-        self.run_bzr("init-repo --git repo") 
+        self.run_bzr("init --git repo") 
 
     def test_info_verbose(self):
         self.simple_commit()
@@ -128,11 +128,12 @@
 
         output, error = self.run_bzr(["tag", "bar"])
 
-        self.assertEquals(error, '')
-        self.assertEquals(output, 'Created tag bar.\n')
+        # bzr <= 2.2 emits this message in the output stream
+        # bzr => 2.3 emits this message in the error stream
+        self.assertEquals(error + output, 'Created tag bar.\n')
 
     def test_init_repo(self):
-        output, error = self.run_bzr(["init-repo", "--git", "bla.git"])
+        output, error = self.run_bzr(["init", "--git", "bla.git"])
         self.assertEquals(error, '')
-        self.assertEquals(output, 'Unshared repository with trees (format: git)\nLocation:\n  repository: bla.git\n')
+        self.assertEquals(output, 'Created a standalone tree (format: git)\n')
 

=== modified file 'tests/test_branch.py'
--- tests/test_branch.py	2010-08-03 20:14:44 +0000
+++ tests/test_branch.py	2011-03-23 20:12:35 +0000
@@ -45,10 +45,12 @@
     )
 
 from bzrlib.plugins.git import (
-    LocalGitBzrDirFormat,
     branch,
     tests,
     )
+from bzrlib.plugins.git.dir import (
+    LocalGitControlDirFormat,
+    )
 from bzrlib.plugins.git.mapping import (
     default_mapping,
     )
@@ -248,11 +250,24 @@
         inter_branch.pull(limit=1)
         self.assertEquals(revid2, newbranch.last_revision())
 
+    def test_interbranch_pull_with_tags(self):
+        path, (gitsha1, gitsha2) = self.make_tworev_branch()
+        gitrepo = GitRepo(path)
+        gitrepo.refs["refs/tags/sometag"] = gitsha2
+        oldrepo = Repository.open(path)
+        revid1 = oldrepo.get_mapping().revision_id_foreign_to_bzr(gitsha1)
+        revid2 = oldrepo.get_mapping().revision_id_foreign_to_bzr(gitsha2)
+        newbranch = self.make_branch('g')
+        inter_branch = InterBranch.get(Branch.open(path), newbranch)
+        inter_branch.pull(stop_revision=revid1)
+        self.assertEquals(revid1, newbranch.last_revision())
+        self.assertTrue(newbranch.repository.has_revision(revid2))
+
 
 class ForeignTestsBranchFactory(object):
 
     def make_empty_branch(self, transport):
-        d = LocalGitBzrDirFormat().initialize_on_transport(transport)
+        d = LocalGitControlDirFormat().initialize_on_transport(transport)
         return d.create_branch()
 
     make_branch = make_empty_branch

=== modified file 'tests/test_builder.py'
--- tests/test_builder.py	2010-08-03 20:14:44 +0000
+++ tests/test_builder.py	2011-03-23 20:12:35 +0000
@@ -112,7 +112,7 @@
         builder = tests.GitBranchBuilder(stream)
 
         builder.set_file(u'f\xb5/bar', 'contents\nbar\n', False)
-        self.assertEqual(2, builder.commit('Joe Foo <[e-mail]>',
+        self.assertEqual('2', builder.commit('Joe Foo <[e-mail]>',
                                            u'committing f\xb5/bar',
                                            timestamp=1194586400,
                                            timezone='+0100'))
@@ -253,6 +253,6 @@
         r1 = builder.commit('Joe Foo <[e-mail]>', u'first',
                             timestamp=1194586400)
         mapping = builder.finish()
-        self.assertEqual({1:'44411e8e9202177dd19b6599d7a7991059fa3cb4',
-                          2: 'b0b62e674f67306fddcf72fa888c3b56df100d64',
+        self.assertEqual({'1':'44411e8e9202177dd19b6599d7a7991059fa3cb4',
+                          '2': 'b0b62e674f67306fddcf72fa888c3b56df100d64',
                          }, mapping)

=== modified file 'tests/test_cache.py'
--- tests/test_cache.py	2010-06-28 21:30:29 +0000
+++ tests/test_cache.py	2011-03-23 20:12:35 +0000
@@ -25,6 +25,8 @@
 import os
 import stat
 
+from bzrlib import osutils
+
 from bzrlib.inventory import (
     InventoryFile,
     InventoryDirectory,
@@ -70,11 +72,16 @@
         self.map.start_write_group()
         updater = self.cache.get_updater(Revision("myrevid"))
         c = self._get_test_commit()
-        updater.add_object(c, None, None)
+        updater.add_object(c, {
+            "testament3-sha1": "cc9462f7f8263ef5adf8eff2fb936bb36b504cba"},
+            None)
         updater.finish()
         self.map.commit_write_group()
         self.assertEquals(
-            ("commit", ("myrevid", "cc9462f7f8263ef5adfbeff2fb936bb36b504cba")),
+            ("commit", ("myrevid",
+                "cc9462f7f8263ef5adfbeff2fb936bb36b504cba",
+                {"testament3-sha1": "cc9462f7f8263ef5adf8eff2fb936bb36b504cba"},
+                )),
             self.map.lookup_git_sha(c.id))
         self.assertEquals(c.id, self.map.lookup_commit("myrevid"))
 
@@ -85,7 +92,7 @@
     def test_blob(self):
         self.map.start_write_group()
         updater = self.cache.get_updater(Revision("myrevid"))
-        updater.add_object(self._get_test_commit(), None, None)
+        updater.add_object(self._get_test_commit(), { "testament3-sha1": "Test" }, None)
         b = Blob()
         b.data = "TEH BLOB"
         ie = InventoryFile("myfileid", "somename", ROOT_ID)
@@ -102,7 +109,8 @@
     def test_tree(self):
         self.map.start_write_group()
         updater = self.cache.get_updater(Revision("myrevid"))
-        updater.add_object(self._get_test_commit(), None, None)
+        updater.add_object(self._get_test_commit(), {
+            "testament3-sha1": "mytestamentsha" }, None)
         t = Tree()
         t.add(stat.S_IFREG, "somename", Blob().id)
         ie = InventoryDirectory("fileid", "myname", ROOT_ID)
@@ -123,7 +131,7 @@
         self.map.start_write_group()
         updater = self.cache.get_updater(Revision("myrevid"))
         c = self._get_test_commit()
-        updater.add_object(c, None, None)
+        updater.add_object(c, {"testament3-sha1": "mtestament"}, None)
         updater.finish()
         self.map.commit_write_group()
         self.assertEquals(["myrevid"], list(self.map.revids()))
@@ -132,7 +140,7 @@
         self.map.start_write_group()
         updater = self.cache.get_updater(Revision("myrevid"))
         c = self._get_test_commit()
-        updater.add_object(c, None, None)
+        updater.add_object(c, {"testament3-sha1": "testament"}, None)
         updater.finish()
         self.map.commit_write_group()
         self.assertEquals(set(["lala", "bla"]),
@@ -160,7 +168,8 @@
     def setUp(self):
         TestCaseInTempDir.setUp(self)
         try:
-            self.cache = TdbBzrGitCache(os.path.join(self.test_dir, 'foo.tdb'))
+            self.cache = TdbBzrGitCache(
+                os.path.join(self.test_dir, 'foo.tdb').encode(osutils._fs_enc))
         except ImportError:
             raise UnavailableFeature("Missing tdb")
         self.map = self.cache.idmap

=== modified file 'tests/test_dir.py'
--- tests/test_dir.py	2010-08-03 20:14:44 +0000
+++ tests/test_dir.py	2011-03-23 20:12:35 +0000
@@ -58,14 +58,14 @@
 
     def setUp(self):
         super(TestGitDirFormat, self).setUp()
-        self.format = dir.LocalGitBzrDirFormat()
+        self.format = dir.LocalGitControlDirFormat()
 
     def test_get_format_description(self):
         self.assertEquals("Local Git Repository",
                           self.format.get_format_description())
 
     def test_eq(self):
-        format2 = dir.LocalGitBzrDirFormat()
+        format2 = dir.LocalGitControlDirFormat()
         self.assertEquals(self.format, format2)
         self.assertEquals(self.format, self.format)
         bzr_format = bzrdir.format_registry.make_bzrdir("default")

=== modified file 'tests/test_fetch.py'
--- tests/test_fetch.py	2010-06-28 21:30:29 +0000
+++ tests/test_fetch.py	2011-03-23 20:12:35 +0000
@@ -56,7 +56,7 @@
     )
 
 
-class RepositoryFetchTests:
+class RepositoryFetchTests(object):
 
     def make_git_repo(self, path):
         os.mkdir(path)

=== modified file 'tests/test_mapping.py'
--- tests/test_mapping.py	2010-07-30 20:42:27 +0000
+++ tests/test_mapping.py	2011-03-23 20:12:35 +0000
@@ -97,7 +97,10 @@
         c.author_timezone = 60 * 3
         c.author = "Author"
         mapping = BzrGitMappingv1()
-        rev = mapping.import_commit(c, mapping.revision_id_foreign_to_bzr)
+        rev, roundtrip_revid, verifiers = mapping.import_commit(c,
+            mapping.revision_id_foreign_to_bzr)
+        self.assertEquals(None, roundtrip_revid)
+        self.assertEquals({}, verifiers)
         self.assertEquals("Some message", rev.message)
         self.assertEquals("Committer", rev.committer)
         self.assertEquals("Author", rev.properties['author'])
@@ -119,7 +122,10 @@
         c.author = u"Authér".encode("iso8859-1")
         c.encoding = "iso8859-1"
         mapping = BzrGitMappingv1()
-        rev = mapping.import_commit(c, mapping.revision_id_foreign_to_bzr)
+        rev, roundtrip_revid, verifiers = mapping.import_commit(c,
+            mapping.revision_id_foreign_to_bzr)
+        self.assertEquals(None, roundtrip_revid)
+        self.assertEquals({}, verifiers)
         self.assertEquals(u"Authér", rev.properties['author'])
         self.assertEquals("iso8859-1", rev.properties["git-explicit-encoding"])
         self.assertTrue("git-implicit-encoding" not in rev.properties)
@@ -135,7 +141,10 @@
         c.author_timezone = 60 * 3
         c.author = u"Authér".encode("latin1")
         mapping = BzrGitMappingv1()
-        rev = mapping.import_commit(c, mapping.revision_id_foreign_to_bzr)
+        rev, roundtrip_revid, verifiers = mapping.import_commit(c,
+            mapping.revision_id_foreign_to_bzr)
+        self.assertEquals(None, roundtrip_revid)
+        self.assertEquals({}, verifiers)
         self.assertEquals(u"Authér", rev.properties['author'])
         self.assertEquals("latin1", rev.properties["git-implicit-encoding"])
         self.assertTrue("git-explicit-encoding" not in rev.properties)
@@ -151,7 +160,10 @@
         c.author_timezone = 60 * 3
         c.author = u"Authér".encode("utf-8")
         mapping = BzrGitMappingv1()
-        rev = mapping.import_commit(c, mapping.revision_id_foreign_to_bzr)
+        rev, roundtrip_revid, verifiers = mapping.import_commit(c,
+            mapping.revision_id_foreign_to_bzr)
+        self.assertEquals(None, roundtrip_revid)
+        self.assertEquals({}, verifiers)
         self.assertEquals(u"Authér", rev.properties['author'])
         self.assertTrue("git-explicit-encoding" not in rev.properties)
         self.assertTrue("git-implicit-encoding" not in rev.properties)
@@ -167,17 +179,22 @@
 
     def assertRoundtripRevision(self, orig_rev):
         commit = self.mapping.export_commit(orig_rev, "mysha",
-            self._lookup_parent, True)
-        rev = self.mapping.import_commit(commit,
-            self.mapping.revision_id_foreign_to_bzr)
+            self._lookup_parent, True, "testamentsha")
+        rev, roundtrip_revid, verifiers = self.mapping.import_commit(
+            commit, self.mapping.revision_id_foreign_to_bzr)
+        self.assertEquals(rev.revision_id,
+            self.mapping.revision_id_foreign_to_bzr(commit.id))
         if self.mapping.roundtripping:
-            self.assertEquals(orig_rev.revision_id, rev.revision_id)
+            self.assertEquals({"testament3-sha1": "testamentsha"} , verifiers)
+            self.assertEquals(orig_rev.revision_id, roundtrip_revid)
             self.assertEquals(orig_rev.properties, rev.properties)
             self.assertEquals(orig_rev.committer, rev.committer)
             self.assertEquals(orig_rev.timestamp, rev.timestamp)
             self.assertEquals(orig_rev.timezone, rev.timezone)
             self.assertEquals(orig_rev.message, rev.message)
             self.assertEquals(list(orig_rev.parent_ids), list(rev.parent_ids))
+        else:
+            self.assertEquals({}, verifiers)
 
     def test_simple_commit(self):
         r = Revision(self.mapping.revision_id_foreign_to_bzr("edf99e6c56495c620f20d5dacff9859ff7119261"))
@@ -233,10 +250,10 @@
         raise NotImplementedError(self.assertRoundtripBlob)
 
     def assertRoundtripCommit(self, commit1):
-        rev = self.mapping.import_commit(commit1,
-            self.mapping.revision_id_foreign_to_bzr)
+        rev, roundtrip_revid, verifiers = self.mapping.import_commit(
+            commit1, self.mapping.revision_id_foreign_to_bzr)
         commit2 = self.mapping.export_commit(rev, "12341212121212", None,
-            True)
+            True, None)
         self.assertEquals(commit1.committer, commit2.committer)
         self.assertEquals(commit1.commit_time, commit2.commit_time)
         self.assertEquals(commit1.commit_timezone, commit2.commit_timezone)

=== modified file 'tests/test_object_store.py'
--- tests/test_object_store.py	2010-07-24 08:40:21 +0000
+++ tests/test_object_store.py	2011-03-23 20:12:35 +0000
@@ -28,17 +28,22 @@
     )
 from bzrlib.graph import (
     DictParentsProvider,
+    Graph,
     )
 from bzrlib.tests import (
     TestCase,
     TestCaseWithTransport,
     )
 
+from bzrlib.plugins.git.cache import (
+    DictGitShaMap,
+    )
 from bzrlib.plugins.git.object_store import (
     BazaarObjectStore,
     LRUTreeCache,
     _check_expected_sha,
     _find_missing_bzr_revids,
+    _tree_to_objects,
     )
 
 
@@ -67,7 +72,7 @@
 
     def _find_missing(self, ancestry, want, have):
         return _find_missing_bzr_revids(
-            DictParentsProvider(ancestry).get_parent_map,
+            Graph(DictParentsProvider(ancestry)),
             set(want), set(have))
 
     def test_simple(self):
@@ -172,3 +177,14 @@
         bb.finish_series()
         self.assertTrue(b.id in self.store)
 
+
+class TreeToObjectsTests(TestCaseWithTransport):
+
+    def setUp(self):
+        super(TreeToObjectsTests, self).setUp()
+        self.idmap = DictGitShaMap()
+
+    def test_no_changes(self):
+        tree = self.make_branch_and_tree('.')
+        entries = list(_tree_to_objects(tree, [tree], self.idmap, {}))
+        self.assertEquals([], entries)

=== modified file 'tests/test_push.py'
--- tests/test_push.py	2010-07-24 09:34:35 +0000
+++ tests/test_push.py	2011-03-23 20:12:35 +0000
@@ -62,5 +62,5 @@
         self.assertEquals([], list(self.interrepo.missing_revisions([])))
 
     def test_missing_revisions_unknown_stop_rev(self):
-        self.assertRaises(errors.NoSuchRevision,
-                self.interrepo.missing_revisions, ["unknown"])
+        self.assertEquals([],
+                list(self.interrepo.missing_revisions([(None, "unknown")])))

=== modified file 'tests/test_refs.py'
--- tests/test_refs.py	2010-08-12 19:36:37 +0000
+++ tests/test_refs.py	2011-03-23 20:12:35 +0000
@@ -52,19 +52,19 @@
                 "HEAD": "ref: foo", "refs/branches/blala": "la"}))
 
     def test_tags(self):
-        self.assertEquals({"mytag": "mysha"},
+        self.assertEquals({"mytag": ("mysha", None)},
             refs.extract_tags({
                 "HEAD": "ref: foo", "refs/tags/mytag": "mysha"}))
 
     def test_ignores_peels(self):
-        self.assertEquals({"mytag": "actualsha"},
+        self.assertEquals({"mytag": ("actualsha", "mysha")},
             refs.extract_tags({
                 "HEAD": "ref: foo",
                 "refs/tags/mytag": "mysha",
                 "refs/tags/mytag^{}": "actualsha"}))
 
     def test_non_ascii_name(self):
-        self.assertEquals({u'myt\xe2g': "actualsha"},
+        self.assertEquals({u'myt\xe2g': ("actualsha", None)},
             refs.extract_tags({
                 "HEAD": "ref: foo",
                 "refs/tags/myt\xc3\xa2g": "actualsha"}))

=== modified file 'tests/test_repository.py'
--- tests/test_repository.py	2010-08-03 20:14:44 +0000
+++ tests/test_repository.py	2011-03-23 20:12:35 +0000
@@ -192,11 +192,12 @@
 
     def test_all_revision_ids(self):
         commit_id = self._do_commit()
-        self.assertEquals(set(["git-v1:%s" % commit_id]),
+        self.assertEquals(
+                set([default_mapping.revision_id_foreign_to_bzr(commit_id)]),
                 self.git_repo.all_revision_ids())
 
     def test_get_ancestry_null(self):
-        self.assertEquals([None, revision.NULL_REVISION], self.git_repo.get_ancestry(revision.NULL_REVISION))
+        self.assertEquals([None], self.git_repo.get_ancestry(revision.NULL_REVISION))
 
     def assertIsNullInventory(self, inv):
         self.assertEqual(inv.root, None)
@@ -274,4 +275,4 @@
 class ForeignTestsRepositoryFactory(object):
 
     def make_repository(self, transport):
-        return dir.LocalGitBzrDirFormat().initialize_on_transport(transport).open_repository()
+        return dir.LocalGitControlDirFormat().initialize_on_transport(transport).open_repository()

=== modified file 'tests/test_roundtrip.py'
--- tests/test_roundtrip.py	2010-05-13 09:40:48 +0000
+++ tests/test_roundtrip.py	2011-03-23 20:12:35 +0000
@@ -67,6 +67,11 @@
         self.assertEquals("property-foo: bar\n",
             generate_roundtripping_metadata(metadata, "utf-8"))
 
+    def test_empty(self):
+        metadata = BzrGitRevisionMetadata()
+        self.assertEquals("",
+            generate_roundtripping_metadata(metadata, "utf-8"))
+
 
 class ExtractMetadataTests(TestCase):
 
@@ -90,6 +95,11 @@
 revision-id: myrevid
 """, msg)
 
+    def test_no_metadata(self):
+        metadata = BzrGitRevisionMetadata()
+        msg = inject_bzr_metadata("Foo", metadata, "utf-8")
+        self.assertEquals("Foo", msg)
+
 
 class FileIdRoundTripTests(TestCase):
 

=== modified file 'tests/test_transportgit.py'
--- tests/test_transportgit.py	2010-06-28 23:48:36 +0000
+++ tests/test_transportgit.py	2011-03-23 20:12:35 +0000
@@ -31,6 +31,10 @@
         TestCaseWithTransport.setUp(self)
         self.store = TransportObjectStore.init(self.get_transport())
 
+    def tearDown(self):
+        PackBasedObjectStoreTests.tearDown(self)
+        TestCaseWithTransport.tearDown(self)
+
 # FIXME: Unfortunately RefsContainerTests requires on a specific set of refs existing.
 
 # class TransportRefContainerTests(RefsContainerTests, TestCaseWithTransport):

=== added file 'tests/test_versionedfiles.py'
--- tests/test_versionedfiles.py	1970-01-01 00:00:00 +0000
+++ tests/test_versionedfiles.py	2011-03-23 20:12:35 +0000
@@ -0,0 +1,50 @@
+# Copyright (C) 2011 Canonical Ltd
+# Authors: 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
+
+"""Tests for git-like versioned files."""
+
+from dulwich.repo import Repo as GitRepo
+
+from bzrlib.repository import Repository
+from bzrlib.tests import TestCaseInTempDir
+
+from bzrlib.plugins.git import tests
+
+class GitRevisionsTests(TestCaseInTempDir):
+
+    def setUp(self):
+        super(GitRevisionsTests, self).setUp()
+        self.gitrepo = GitRepo.init(self.test_dir)
+        self.revisions = Repository.open(self.test_dir).revisions
+
+    def _do_commit(self):
+        builder = tests.GitBranchBuilder()
+        builder.set_file('a', 'text for a\n', False)
+        commit_handle = builder.commit('Joe Foo <[e-mail]>', u'message')
+        mapping = builder.finish()
+        return mapping[commit_handle]
+
+    def test_empty(self):
+        self.assertEquals([], self.revisions.keys())
+
+    def test_check(self):
+        # Just a no-op at the moment
+        self.assertTrue(self.revisions.check())
+
+    def test_revision(self):
+        gitsha = self._do_commit()
+        self.assertEquals([(gitsha,)], self.revisions.keys())

=== modified file 'transportgit.py'
--- transportgit.py	2010-08-12 10:18:56 +0000
+++ transportgit.py	2011-03-23 20:12:35 +0000
@@ -42,6 +42,7 @@
 from dulwich.repo import (
     BaseRepo,
     RefsContainer,
+    BASE_DIRECTORIES,
     INDEX_FILENAME,
     OBJECTDIR,
     REFSDIR,
@@ -312,6 +313,9 @@
         except NoSuchFile:
             return None
 
+    def _put_named_file(self, relpath, contents):
+        self._controltransport.put_bytes(relpath, contents)
+
     def index_path(self):
         """Return the path to the index file."""
         return self._controltransport.local_abspath(INDEX_FILENAME)
@@ -330,7 +334,23 @@
         return not self.bare
 
     def __repr__(self):
-        return "<TransportRepo for %r>" % self.transport
+        return "<%s for %r>" % (self.__class__.__name__, self.transport)
+
+    @classmethod
+    def init(cls, transport, bare=False):
+        if not bare:
+            transport.mkdir(".git")
+            control_transport = transport.clone(".git")
+        else:
+            control_transport = transport
+        for d in BASE_DIRECTORIES:
+            control_transport.mkdir("/".join(d))
+        control_transport.mkdir(OBJECTDIR)
+        TransportObjectStore.init(control_transport.clone(OBJECTDIR))
+        ret = cls(transport)
+        ret.refs.set_symbolic_ref("HEAD", "refs/heads/master")
+        ret._init_files(bare)
+        return ret
 
 
 class TransportObjectStore(PackBasedObjectStore):
@@ -344,7 +364,10 @@
         super(TransportObjectStore, self).__init__()
         self.transport = transport
         self.pack_transport = self.transport.clone(PACKDIR)
-    
+
+    def __repr__(self):
+        return "%s(%r)" % (self.__class__.__name__, self.transport)
+
     def _pack_cache_stale(self):
         return False # FIXME
 

=== modified file 'versionedfiles.py'
--- versionedfiles.py	2010-07-30 20:43:28 +0000
+++ versionedfiles.py	2011-03-23 20:12:35 +0000
@@ -48,7 +48,7 @@
 
     def iterkeys(self):
         for sha in self.object_store:
-            if type(sha) == Commit:
+            if isinstance(self.object_store[sha], Commit):
                 yield (sha,)
 
     def keys(self):

=== modified file 'workingtree.py'
--- workingtree.py	2010-07-31 19:26:31 +0000
+++ workingtree.py	2011-03-23 20:12:35 +0000
@@ -22,6 +22,9 @@
     StringIO,
     )
 import errno
+from dulwich.index import (
+    Index,
+    )
 from dulwich.objects import (
     Blob,
     )
@@ -46,6 +49,9 @@
     )
 
 
+from bzrlib.plugins.git.dir import (
+    LocalGitDir,
+    )
 from bzrlib.plugins.git.inventory import (
     GitIndexInventory,
     )
@@ -108,9 +114,6 @@
         finally:
             self.branch.unlock()
 
-    def is_control_filename(self, path):
-        return os.path.basename(path) == ".git"
-
     def _rewrite_index(self):
         self.index.clear()
         for path, entry in self._inventory.iter_entries():
@@ -136,7 +139,7 @@
                     # old index
                     from posix import stat_result
                     stat_val = stat_result((stat.S_IFLNK, 0, 0, 0, 0, 0, 0, 0, 0, 0))
-                blob.set_raw_string(entry.symlink_target)
+                blob.set_raw_string(self.get_symlink_target(entry.file_id).encode("utf-8"))
             else:
                 raise AssertionError("unknown kind '%s'" % entry.kind)
             # Add object to the repository if it didn't exist yet
@@ -215,12 +218,22 @@
 
     @property
     def _matchingbzrdir(self):
-        from bzrlib.plugins.git import LocalGitBzrDirFormat
-        return LocalGitBzrDirFormat()
+        from bzrlib.plugins.git.dir import LocalGitControlDirFormat
+        return LocalGitControlDirFormat()
 
     def get_format_description(self):
         return "Git Working Tree"
 
+    def initialize(self, a_bzrdir, revision_id=None, from_branch=None,
+                   accelerator_tree=None, hardlink=False):
+        """See WorkingTreeFormat.initialize()."""
+        if not isinstance(a_bzrdir, LocalGitDir):
+            raise errors.IncompatibleFormat(self, a_bzrdir)
+        index = Index(a_bzrdir.root_transport.local_abspath(".git/index"))
+        index.write()
+        return GitWorkingTree(a_bzrdir, a_bzrdir.open_repository(),
+            a_bzrdir.open_branch(), index)
+
 
 class InterIndexGitTree(tree.InterTree):
     """InterTree that works between a Git revision tree and an index."""
@@ -245,17 +258,16 @@
             self.source._repository._git.object_store.__getitem__,
             self.source.tree)
         if self.target.mapping.BZR_FILE_IDS_FILE is not None:
-            try:
-                file_id = self.target.path2id(
-                    self.target.mapping.BZR_FILE_IDS_FILE)
-            except errors.NoSuchId:
+            file_id = self.target.path2id(
+                self.target.mapping.BZR_FILE_IDS_FILE)
+            if file_id is None:
                 target_fileid_map = {}
             else:
-                target_fileid_map = self.import_fileid_map(Blob.from_string(self.target.file_text(file_id)))
+                target_fileid_map = self.target.mapping.import_fileid_map(Blob.from_string(self.target.get_file_text(file_id)))
         else:
             target_fileid_map = {}
         target_fileid_map = GitFileIdMap(target_fileid_map, self.target.mapping)
-        ret = tree_delta_from_git_changes(changes, self.target.mapping, 
+        ret = tree_delta_from_git_changes(changes, self.target.mapping,
             (source_fileid_map, target_fileid_map),
             specific_file=specific_files, require_versioned=require_versioned)
         if want_unversioned: