Merge lp:~jelmer/bzr/weave-plugin into lp:bzr

[Jelmer Vernooij]

Move the weave-era formats into a plugin. This should make avoid some unnecessary overhead loading these formats unless they're actually used and make it easier for users to disable the weave formats completely.

[Jelmer Vernooij (jelmer)]

This branch looks scary but it's mainly moving code around to bzrlib.plugins.weave_fmt...

[Jelmer Vernooij (jelmer)]

Unfortunately I can only set one prerequisite branch, another prerequisite is lp:~jelmer/bzr/repository-format-deprecation

=== modified file 'bzrlib/branch.py'
--- bzrlib/branch.py	2011-03-08 00:04:05 +0000
+++ bzrlib/branch.py	2011-03-09 01:37:04 +0000
@@ -2349,10 +2349,6 @@
 format_registry.register(__format7)
 format_registry.register(__format8)
 format_registry.set_default(__format7)
-format_registry.register_extra_lazy("bzrlib.branch_weave",
-    "BzrBranchFormat4")
-network_format_registry.register_lazy("Bazaar-NG branch, format 6\n",
-    "bzrlib.branch_weave", "BzrBranchFormat4")
 
 
 class BranchWriteLockResult(LogicalLockResult):

=== modified file 'bzrlib/bzrdir.py'
--- bzrlib/bzrdir.py	2011-03-08 17:40:26 +0000
+++ bzrlib/bzrdir.py	2011-03-09 01:37:04 +0000
@@ -27,9 +27,7 @@
 
 # TODO: Move old formats into a plugin to make this file smaller.
 
-import os
 import sys
-import warnings
 
 from bzrlib.lazy_import import lazy_import
 lazy_import(globals(), """
@@ -55,13 +53,9 @@
     win32utils,
     workingtree,
     workingtree_4,
-    xml4,
-    xml5,
     )
 from bzrlib.repofmt import pack_repo
 from bzrlib.smart.client import _SmartClient
-from bzrlib.store.versioned import VersionedFileStore
-from bzrlib.transactions import WriteTransaction
 from bzrlib.transport import (
     do_catching_redirections,
     local,
@@ -73,9 +67,7 @@
 """)
 
 from bzrlib.trace import (
-    mutter,
     note,
-    warning,
     )
 
 from bzrlib import (
@@ -1016,268 +1008,6 @@
                 self.bzrdir)
 
 
-class BzrDirPreSplitOut(BzrDir):
-    """A common class for the all-in-one formats."""
-
-    def __init__(self, _transport, _format):
-        """See BzrDir.__init__."""
-        super(BzrDirPreSplitOut, self).__init__(_transport, _format)
-        self._control_files = lockable_files.LockableFiles(
-                                            self.get_branch_transport(None),
-                                            self._format._lock_file_name,
-                                            self._format._lock_class)
-
-    def break_lock(self):
-        """Pre-splitout bzrdirs do not suffer from stale locks."""
-        raise NotImplementedError(self.break_lock)
-
-    def cloning_metadir(self, require_stacking=False):
-        """Produce a metadir suitable for cloning with."""
-        if require_stacking:
-            return controldir.format_registry.make_bzrdir('1.6')
-        return self._format.__class__()
-
-    def clone(self, url, revision_id=None, force_new_repo=False,
-              preserve_stacking=False):
-        """See BzrDir.clone().
-
-        force_new_repo has no effect, since this family of formats always
-        require a new repository.
-        preserve_stacking has no effect, since no source branch using this
-        family of formats can be stacked, so there is no stacking to preserve.
-        """
-        self._make_tail(url)
-        result = self._format._initialize_for_clone(url)
-        self.open_repository().clone(result, revision_id=revision_id)
-        from_branch = self.open_branch()
-        from_branch.clone(result, revision_id=revision_id)
-        try:
-            tree = self.open_workingtree()
-        except errors.NotLocalUrl:
-            # make a new one, this format always has to have one.
-            result._init_workingtree()
-        else:
-            tree.clone(result)
-        return result
-
-    def create_branch(self, name=None, repository=None):
-        """See BzrDir.create_branch."""
-        if repository is not None:
-            raise NotImplementedError(
-                "create_branch(repository=<not None>) on %r" % (self,))
-        return self._format.get_branch_format().initialize(self, name=name)
-
-    def destroy_branch(self, name=None):
-        """See BzrDir.destroy_branch."""
-        raise errors.UnsupportedOperation(self.destroy_branch, self)
-
-    def create_repository(self, shared=False):
-        """See BzrDir.create_repository."""
-        if shared:
-            raise errors.IncompatibleFormat('shared repository', self._format)
-        return self.open_repository()
-
-    def destroy_repository(self):
-        """See BzrDir.destroy_repository."""
-        raise errors.UnsupportedOperation(self.destroy_repository, self)
-
-    def create_workingtree(self, revision_id=None, from_branch=None,
-                           accelerator_tree=None, hardlink=False):
-        """See BzrDir.create_workingtree."""
-        # The workingtree is sometimes created when the bzrdir is created,
-        # but not when cloning.
-
-        # this looks buggy but is not -really-
-        # because this format creates the workingtree when the bzrdir is
-        # created
-        # clone and sprout will have set the revision_id
-        # and that will have set it for us, its only
-        # specific uses of create_workingtree in isolation
-        # that can do wonky stuff here, and that only
-        # happens for creating checkouts, which cannot be
-        # done on this format anyway. So - acceptable wart.
-        if hardlink:
-            warning("can't support hardlinked working trees in %r"
-                % (self,))
-        try:
-            result = self.open_workingtree(recommend_upgrade=False)
-        except errors.NoSuchFile:
-            result = self._init_workingtree()
-        if revision_id is not None:
-            if revision_id == _mod_revision.NULL_REVISION:
-                result.set_parent_ids([])
-            else:
-                result.set_parent_ids([revision_id])
-        return result
-
-    def _init_workingtree(self):
-        from bzrlib.workingtree_2 import WorkingTreeFormat2
-        try:
-            return WorkingTreeFormat2().initialize(self)
-        except errors.NotLocalUrl:
-            # Even though we can't access the working tree, we need to
-            # create its control files.
-            return WorkingTreeFormat2()._stub_initialize_on_transport(
-                self.transport, self._control_files._file_mode)
-
-    def destroy_workingtree(self):
-        """See BzrDir.destroy_workingtree."""
-        raise errors.UnsupportedOperation(self.destroy_workingtree, self)
-
-    def destroy_workingtree_metadata(self):
-        """See BzrDir.destroy_workingtree_metadata."""
-        raise errors.UnsupportedOperation(self.destroy_workingtree_metadata,
-                                          self)
-
-    def get_branch_transport(self, branch_format, name=None):
-        """See BzrDir.get_branch_transport()."""
-        if name is not None:
-            raise errors.NoColocatedBranchSupport(self)
-        if branch_format is None:
-            return self.transport
-        try:
-            branch_format.get_format_string()
-        except NotImplementedError:
-            return self.transport
-        raise errors.IncompatibleFormat(branch_format, self._format)
-
-    def get_repository_transport(self, repository_format):
-        """See BzrDir.get_repository_transport()."""
-        if repository_format is None:
-            return self.transport
-        try:
-            repository_format.get_format_string()
-        except NotImplementedError:
-            return self.transport
-        raise errors.IncompatibleFormat(repository_format, self._format)
-
-    def get_workingtree_transport(self, workingtree_format):
-        """See BzrDir.get_workingtree_transport()."""
-        if workingtree_format is None:
-            return self.transport
-        try:
-            workingtree_format.get_format_string()
-        except NotImplementedError:
-            return self.transport
-        raise errors.IncompatibleFormat(workingtree_format, self._format)
-
-    def needs_format_conversion(self, format):
-        """See BzrDir.needs_format_conversion()."""
-        return not isinstance(self._format, format.__class__)
-
-    def open_branch(self, name=None, unsupported=False,
-                    ignore_fallbacks=False):
-        """See BzrDir.open_branch."""
-        from bzrlib.branch_weave import BzrBranchFormat4
-        format = BzrBranchFormat4()
-        self._check_supported(format, unsupported)
-        return format.open(self, name, _found=True)
-
-    def sprout(self, url, revision_id=None, force_new_repo=False,
-               possible_transports=None, accelerator_tree=None,
-               hardlink=False, stacked=False, create_tree_if_local=True,
-               source_branch=None):
-        """See BzrDir.sprout()."""
-        if source_branch is not None:
-            my_branch = self.open_branch()
-            if source_branch.base != my_branch.base:
-                raise AssertionError(
-                    "source branch %r is not within %r with branch %r" %
-                    (source_branch, self, my_branch))
-        if stacked:
-            raise errors.UnstackableBranchFormat(
-                self._format, self.root_transport.base)
-        if not create_tree_if_local:
-            raise errors.MustHaveWorkingTree(
-                self._format, self.root_transport.base)
-        from bzrlib.workingtree_2 import WorkingTreeFormat2
-        self._make_tail(url)
-        result = self._format._initialize_for_clone(url)
-        try:
-            self.open_repository().clone(result, revision_id=revision_id)
-        except errors.NoRepositoryPresent:
-            pass
-        try:
-            self.open_branch().sprout(result, revision_id=revision_id)
-        except errors.NotBranchError:
-            pass
-
-        # we always want a working tree
-        WorkingTreeFormat2().initialize(result,
-                                        accelerator_tree=accelerator_tree,
-                                        hardlink=hardlink)
-        return result
-
-
-class BzrDir4(BzrDirPreSplitOut):
-    """A .bzr version 4 control object.
-
-    This is a deprecated format and may be removed after sept 2006.
-    """
-
-    def create_repository(self, shared=False):
-        """See BzrDir.create_repository."""
-        return self._format.repository_format.initialize(self, shared)
-
-    def needs_format_conversion(self, format):
-        """Format 4 dirs are always in need of conversion."""
-        return True
-
-    def open_repository(self):
-        """See BzrDir.open_repository."""
-        from bzrlib.repofmt.weaverepo import RepositoryFormat4
-        return RepositoryFormat4().open(self, _found=True)
-
-
-class BzrDir5(BzrDirPreSplitOut):
-    """A .bzr version 5 control object.
-
-    This is a deprecated format and may be removed after sept 2006.
-    """
-
-    def has_workingtree(self):
-        """See BzrDir.has_workingtree."""
-        return True
-    
-    def open_repository(self):
-        """See BzrDir.open_repository."""
-        from bzrlib.repofmt.weaverepo import RepositoryFormat5
-        return RepositoryFormat5().open(self, _found=True)
-
-    def open_workingtree(self, _unsupported=False,
-            recommend_upgrade=True):
-        """See BzrDir.create_workingtree."""
-        from bzrlib.workingtree_2 import WorkingTreeFormat2
-        wt_format = WorkingTreeFormat2()
-        # we don't warn here about upgrades; that ought to be handled for the
-        # bzrdir as a whole
-        return wt_format.open(self, _found=True)
-
-
-class BzrDir6(BzrDirPreSplitOut):
-    """A .bzr version 6 control object.
-
-    This is a deprecated format and may be removed after sept 2006.
-    """
-
-    def has_workingtree(self):
-        """See BzrDir.has_workingtree."""
-        return True
-    
-    def open_repository(self):
-        """See BzrDir.open_repository."""
-        from bzrlib.repofmt.weaverepo import RepositoryFormat6
-        return RepositoryFormat6().open(self, _found=True)
-
-    def open_workingtree(self, _unsupported=False,
-        recommend_upgrade=True):
-        """See BzrDir.create_workingtree."""
-        # we don't warn here about upgrades; that ought to be handled for the
-        # bzrdir as a whole
-        from bzrlib.workingtree_2 import WorkingTreeFormat2
-        return WorkingTreeFormat2().open(self, _found=True)
-
-
 class BzrDirMeta1(BzrDir):
     """A .bzr meta version 1 control object.
 
@@ -1752,213 +1482,6 @@
         controldir.network_format_registry.remove(format.get_format_string())
 
 
-class BzrDirFormat4(BzrDirFormat):
-    """Bzr dir format 4.
-
-    This format is a combined format for working tree, branch and repository.
-    It has:
-     - Format 1 working trees [always]
-     - Format 4 branches [always]
-     - Format 4 repositories [always]
-
-    This format is deprecated: it indexes texts using a text it which is
-    removed in format 5; write support for this format has been removed.
-    """
-
-    _lock_class = lockable_files.TransportLock
-
-    fixed_components = True
-
-    def get_format_string(self):
-        """See BzrDirFormat.get_format_string()."""
-        return "Bazaar-NG branch, format 0.0.4\n"
-
-    def get_format_description(self):
-        """See BzrDirFormat.get_format_description()."""
-        return "All-in-one format 4"
-
-    def get_converter(self, format=None):
-        """See BzrDirFormat.get_converter()."""
-        # there is one and only one upgrade path here.
-        return ConvertBzrDir4To5()
-
-    def initialize_on_transport(self, transport):
-        """Format 4 branches cannot be created."""
-        raise errors.UninitializableFormat(self)
-
-    def is_supported(self):
-        """Format 4 is not supported.
-
-        It is not supported because the model changed from 4 to 5 and the
-        conversion logic is expensive - so doing it on the fly was not
-        feasible.
-        """
-        return False
-
-    def network_name(self):
-        return self.get_format_string()
-
-    def _open(self, transport):
-        """See BzrDirFormat._open."""
-        return BzrDir4(transport, self)
-
-    def __return_repository_format(self):
-        """Circular import protection."""
-        from bzrlib.repofmt.weaverepo import RepositoryFormat4
-        return RepositoryFormat4()
-    repository_format = property(__return_repository_format)
-
-
-class BzrDirFormatAllInOne(BzrDirFormat):
-    """Common class for formats before meta-dirs."""
-
-    fixed_components = True
-
-    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):
-        """See BzrDirFormat.initialize_on_transport_ex."""
-        require_stacking = (stacked_on is not None)
-        # Format 5 cannot stack, but we've been asked to - actually init
-        # a Meta1Dir
-        if require_stacking:
-            format = BzrDirMetaFormat1()
-            return format.initialize_on_transport_ex(transport,
-                use_existing_dir=use_existing_dir, create_prefix=create_prefix,
-                force_new_repo=force_new_repo, stacked_on=stacked_on,
-                stack_on_pwd=stack_on_pwd, repo_format_name=repo_format_name,
-                make_working_trees=make_working_trees, shared_repo=shared_repo)
-        return BzrDirFormat.initialize_on_transport_ex(self, transport,
-            use_existing_dir=use_existing_dir, create_prefix=create_prefix,
-            force_new_repo=force_new_repo, stacked_on=stacked_on,
-            stack_on_pwd=stack_on_pwd, repo_format_name=repo_format_name,
-            make_working_trees=make_working_trees, shared_repo=shared_repo)
-
-
-class BzrDirFormat5(BzrDirFormatAllInOne):
-    """Bzr control format 5.
-
-    This format is a combined format for working tree, branch and repository.
-    It has:
-     - Format 2 working trees [always]
-     - Format 4 branches [always]
-     - Format 5 repositories [always]
-       Unhashed stores in the repository.
-    """
-
-    _lock_class = lockable_files.TransportLock
-
-    def get_format_string(self):
-        """See BzrDirFormat.get_format_string()."""
-        return "Bazaar-NG branch, format 5\n"
-
-    def get_branch_format(self):
-        from bzrlib import branch_weave
-        return branch_weave.BzrBranchFormat4()
-
-    def get_format_description(self):
-        """See BzrDirFormat.get_format_description()."""
-        return "All-in-one format 5"
-
-    def get_converter(self, format=None):
-        """See BzrDirFormat.get_converter()."""
-        # there is one and only one upgrade path here.
-        return ConvertBzrDir5To6()
-
-    def _initialize_for_clone(self, url):
-        return self.initialize_on_transport(
-            _mod_transport.get_transport(url), _cloning=True)
-
-    def initialize_on_transport(self, transport, _cloning=False):
-        """Format 5 dirs always have working tree, branch and repository.
-
-        Except when they are being cloned.
-        """
-        from bzrlib.branch_weave import BzrBranchFormat4
-        from bzrlib.repofmt.weaverepo import RepositoryFormat5
-        result = (super(BzrDirFormat5, self).initialize_on_transport(transport))
-        RepositoryFormat5().initialize(result, _internal=True)
-        if not _cloning:
-            branch = BzrBranchFormat4().initialize(result)
-            result._init_workingtree()
-        return result
-
-    def network_name(self):
-        return self.get_format_string()
-
-    def _open(self, transport):
-        """See BzrDirFormat._open."""
-        return BzrDir5(transport, self)
-
-    def __return_repository_format(self):
-        """Circular import protection."""
-        from bzrlib.repofmt.weaverepo import RepositoryFormat5
-        return RepositoryFormat5()
-    repository_format = property(__return_repository_format)
-
-
-class BzrDirFormat6(BzrDirFormatAllInOne):
-    """Bzr control format 6.
-
-    This format is a combined format for working tree, branch and repository.
-    It has:
-     - Format 2 working trees [always]
-     - Format 4 branches [always]
-     - Format 6 repositories [always]
-    """
-
-    _lock_class = lockable_files.TransportLock
-
-    def get_format_string(self):
-        """See BzrDirFormat.get_format_string()."""
-        return "Bazaar-NG branch, format 6\n"
-
-    def get_format_description(self):
-        """See BzrDirFormat.get_format_description()."""
-        return "All-in-one format 6"
-
-    def get_branch_format(self):
-        from bzrlib import branch_weave
-        return branch_weave.BzrBranchFormat4()
-
-    def get_converter(self, format=None):
-        """See BzrDirFormat.get_converter()."""
-        # there is one and only one upgrade path here.
-        return ConvertBzrDir6ToMeta()
-
-    def _initialize_for_clone(self, url):
-        return self.initialize_on_transport(
-            _mod_transport.get_transport(url), _cloning=True)
-
-    def initialize_on_transport(self, transport, _cloning=False):
-        """Format 6 dirs always have working tree, branch and repository.
-
-        Except when they are being cloned.
-        """
-        from bzrlib.branch_weave import BzrBranchFormat4
-        from bzrlib.repofmt.weaverepo import RepositoryFormat6
-        result = super(BzrDirFormat6, self).initialize_on_transport(transport)
-        RepositoryFormat6().initialize(result, _internal=True)
-        if not _cloning:
-            branch = BzrBranchFormat4().initialize(result)
-            result._init_workingtree()
-        return result
-
-    def network_name(self):
-        return self.get_format_string()
-
-    def _open(self, transport):
-        """See BzrDirFormat._open."""
-        return BzrDir6(transport, self)
-
-    def __return_repository_format(self):
-        """Circular import protection."""
-        from bzrlib.repofmt.weaverepo import RepositoryFormat6
-        return RepositoryFormat6()
-    repository_format = property(__return_repository_format)
-
-
 class BzrDirMetaFormat1(BzrDirFormat):
     """Bzr meta control format 1
 
@@ -2170,452 +1693,11 @@
 
 
 # Register bzr formats
-BzrDirFormat.register_format(BzrDirFormat4())
-BzrDirFormat.register_format(BzrDirFormat5())
-BzrDirFormat.register_format(BzrDirFormat6())
 __default_format = BzrDirMetaFormat1()
 BzrDirFormat.register_format(__default_format)
 controldir.ControlDirFormat._default_format = __default_format
 
 
-class ConvertBzrDir4To5(controldir.Converter):
-    """Converts format 4 bzr dirs to format 5."""
-
-    def __init__(self):
-        super(ConvertBzrDir4To5, self).__init__()
-        self.converted_revs = set()
-        self.absent_revisions = set()
-        self.text_count = 0
-        self.revisions = {}
-
-    def convert(self, to_convert, pb):
-        """See Converter.convert()."""
-        self.bzrdir = to_convert
-        if pb is not None:
-            warnings.warn("pb parameter to convert() is deprecated")
-        self.pb = ui.ui_factory.nested_progress_bar()
-        try:
-            ui.ui_factory.note('starting upgrade from format 4 to 5')
-            if isinstance(self.bzrdir.transport, local.LocalTransport):
-                self.bzrdir.get_workingtree_transport(None).delete('stat-cache')
-            self._convert_to_weaves()
-            return BzrDir.open(self.bzrdir.user_url)
-        finally:
-            self.pb.finished()
-
-    def _convert_to_weaves(self):
-        ui.ui_factory.note('note: upgrade may be faster if all store files are ungzipped first')
-        try:
-            # TODO permissions
-            stat = self.bzrdir.transport.stat('weaves')
-            if not S_ISDIR(stat.st_mode):
-                self.bzrdir.transport.delete('weaves')
-                self.bzrdir.transport.mkdir('weaves')
-        except errors.NoSuchFile:
-            self.bzrdir.transport.mkdir('weaves')
-        # deliberately not a WeaveFile as we want to build it up slowly.
-        self.inv_weave = Weave('inventory')
-        # holds in-memory weaves for all files
-        self.text_weaves = {}
-        self.bzrdir.transport.delete('branch-format')
-        self.branch = self.bzrdir.open_branch()
-        self._convert_working_inv()
-        rev_history = self.branch.revision_history()
-        # to_read is a stack holding the revisions we still need to process;
-        # appending to it adds new highest-priority revisions
-        self.known_revisions = set(rev_history)
-        self.to_read = rev_history[-1:]
-        while self.to_read:
-            rev_id = self.to_read.pop()
-            if (rev_id not in self.revisions
-                and rev_id not in self.absent_revisions):
-                self._load_one_rev(rev_id)
-        self.pb.clear()
-        to_import = self._make_order()
-        for i, rev_id in enumerate(to_import):
-            self.pb.update('converting revision', i, len(to_import))
-            self._convert_one_rev(rev_id)
-        self.pb.clear()
-        self._write_all_weaves()
-        self._write_all_revs()
-        ui.ui_factory.note('upgraded to weaves:')
-        ui.ui_factory.note('  %6d revisions and inventories' % len(self.revisions))
-        ui.ui_factory.note('  %6d revisions not present' % len(self.absent_revisions))
-        ui.ui_factory.note('  %6d texts' % self.text_count)
-        self._cleanup_spare_files_after_format4()
-        self.branch._transport.put_bytes(
-            'branch-format',
-            BzrDirFormat5().get_format_string(),
-            mode=self.bzrdir._get_file_mode())
-
-    def _cleanup_spare_files_after_format4(self):
-        # FIXME working tree upgrade foo.
-        for n in 'merged-patches', 'pending-merged-patches':
-            try:
-                ## assert os.path.getsize(p) == 0
-                self.bzrdir.transport.delete(n)
-            except errors.NoSuchFile:
-                pass
-        self.bzrdir.transport.delete_tree('inventory-store')
-        self.bzrdir.transport.delete_tree('text-store')
-
-    def _convert_working_inv(self):
-        inv = xml4.serializer_v4.read_inventory(
-                self.branch._transport.get('inventory'))
-        new_inv_xml = xml5.serializer_v5.write_inventory_to_string(inv, working=True)
-        self.branch._transport.put_bytes('inventory', new_inv_xml,
-            mode=self.bzrdir._get_file_mode())
-
-    def _write_all_weaves(self):
-        controlweaves = VersionedFileStore(self.bzrdir.transport, prefixed=False,
-                                           versionedfile_class=WeaveFile)
-        weave_transport = self.bzrdir.transport.clone('weaves')
-        weaves = VersionedFileStore(weave_transport, prefixed=False,
-                            versionedfile_class=WeaveFile)
-        transaction = WriteTransaction()
-
-        try:
-            i = 0
-            for file_id, file_weave in self.text_weaves.items():
-                self.pb.update('writing weave', i, len(self.text_weaves))
-                weaves._put_weave(file_id, file_weave, transaction)
-                i += 1
-            self.pb.update('inventory', 0, 1)
-            controlweaves._put_weave('inventory', self.inv_weave, transaction)
-            self.pb.update('inventory', 1, 1)
-        finally:
-            self.pb.clear()
-
-    def _write_all_revs(self):
-        """Write all revisions out in new form."""
-        self.bzrdir.transport.delete_tree('revision-store')
-        self.bzrdir.transport.mkdir('revision-store')
-        revision_transport = self.bzrdir.transport.clone('revision-store')
-        # TODO permissions
-        from bzrlib.xml5 import serializer_v5
-        from bzrlib.repofmt.weaverepo import RevisionTextStore
-        revision_store = RevisionTextStore(revision_transport,
-            serializer_v5, False, versionedfile.PrefixMapper(),
-            lambda:True, lambda:True)
-        try:
-            for i, rev_id in enumerate(self.converted_revs):
-                self.pb.update('write revision', i, len(self.converted_revs))
-                text = serializer_v5.write_revision_to_string(
-                    self.revisions[rev_id])
-                key = (rev_id,)
-                revision_store.add_lines(key, None, osutils.split_lines(text))
-        finally:
-            self.pb.clear()
-
-    def _load_one_rev(self, rev_id):
-        """Load a revision object into memory.
-
-        Any parents not either loaded or abandoned get queued to be
-        loaded."""
-        self.pb.update('loading revision',
-                       len(self.revisions),
-                       len(self.known_revisions))
-        if not self.branch.repository.has_revision(rev_id):
-            self.pb.clear()
-            ui.ui_factory.note('revision {%s} not present in branch; '
-                         'will be converted as a ghost' %
-                         rev_id)
-            self.absent_revisions.add(rev_id)
-        else:
-            rev = self.branch.repository.get_revision(rev_id)
-            for parent_id in rev.parent_ids:
-                self.known_revisions.add(parent_id)
-                self.to_read.append(parent_id)
-            self.revisions[rev_id] = rev
-
-    def _load_old_inventory(self, rev_id):
-        f = self.branch.repository.inventory_store.get(rev_id)
-        try:
-            old_inv_xml = f.read()
-        finally:
-            f.close()
-        inv = xml4.serializer_v4.read_inventory_from_string(old_inv_xml)
-        inv.revision_id = rev_id
-        rev = self.revisions[rev_id]
-        return inv
-
-    def _load_updated_inventory(self, rev_id):
-        inv_xml = self.inv_weave.get_text(rev_id)
-        inv = xml5.serializer_v5.read_inventory_from_string(inv_xml, rev_id)
-        return inv
-
-    def _convert_one_rev(self, rev_id):
-        """Convert revision and all referenced objects to new format."""
-        rev = self.revisions[rev_id]
-        inv = self._load_old_inventory(rev_id)
-        present_parents = [p for p in rev.parent_ids
-                           if p not in self.absent_revisions]
-        self._convert_revision_contents(rev, inv, present_parents)
-        self._store_new_inv(rev, inv, present_parents)
-        self.converted_revs.add(rev_id)
-
-    def _store_new_inv(self, rev, inv, present_parents):
-        new_inv_xml = xml5.serializer_v5.write_inventory_to_string(inv)
-        new_inv_sha1 = osutils.sha_string(new_inv_xml)
-        self.inv_weave.add_lines(rev.revision_id,
-                                 present_parents,
-                                 new_inv_xml.splitlines(True))
-        rev.inventory_sha1 = new_inv_sha1
-
-    def _convert_revision_contents(self, rev, inv, present_parents):
-        """Convert all the files within a revision.
-
-        Also upgrade the inventory to refer to the text revision ids."""
-        rev_id = rev.revision_id
-        mutter('converting texts of revision {%s}',
-               rev_id)
-        parent_invs = map(self._load_updated_inventory, present_parents)
-        entries = inv.iter_entries()
-        entries.next()
-        for path, ie in entries:
-            self._convert_file_version(rev, ie, parent_invs)
-
-    def _convert_file_version(self, rev, ie, parent_invs):
-        """Convert one version of one file.
-
-        The file needs to be added into the weave if it is a merge
-        of >=2 parents or if it's changed from its parent.
-        """
-        file_id = ie.file_id
-        rev_id = rev.revision_id
-        w = self.text_weaves.get(file_id)
-        if w is None:
-            w = Weave(file_id)
-            self.text_weaves[file_id] = w
-        text_changed = False
-        parent_candiate_entries = ie.parent_candidates(parent_invs)
-        heads = graph.Graph(self).heads(parent_candiate_entries.keys())
-        # XXX: Note that this is unordered - and this is tolerable because
-        # the previous code was also unordered.
-        previous_entries = dict((head, parent_candiate_entries[head]) for head
-            in heads)
-        self.snapshot_ie(previous_entries, ie, w, rev_id)
-
-    def get_parent_map(self, revision_ids):
-        """See graph.StackedParentsProvider.get_parent_map"""
-        return dict((revision_id, self.revisions[revision_id])
-                    for revision_id in revision_ids
-                     if revision_id in self.revisions)
-
-    def snapshot_ie(self, previous_revisions, ie, w, rev_id):
-        # TODO: convert this logic, which is ~= snapshot to
-        # a call to:. This needs the path figured out. rather than a work_tree
-        # a v4 revision_tree can be given, or something that looks enough like
-        # one to give the file content to the entry if it needs it.
-        # and we need something that looks like a weave store for snapshot to
-        # save against.
-        #ie.snapshot(rev, PATH, previous_revisions, REVISION_TREE, InMemoryWeaveStore(self.text_weaves))
-        if len(previous_revisions) == 1:
-            previous_ie = previous_revisions.values()[0]
-            if ie._unchanged(previous_ie):
-                ie.revision = previous_ie.revision
-                return
-        if ie.has_text():
-            f = self.branch.repository._text_store.get(ie.text_id)
-            try:
-                file_lines = f.readlines()
-            finally:
-                f.close()
-            w.add_lines(rev_id, previous_revisions, file_lines)
-            self.text_count += 1
-        else:
-            w.add_lines(rev_id, previous_revisions, [])
-        ie.revision = rev_id
-
-    def _make_order(self):
-        """Return a suitable order for importing revisions.
-
-        The order must be such that an revision is imported after all
-        its (present) parents.
-        """
-        todo = set(self.revisions.keys())
-        done = self.absent_revisions.copy()
-        order = []
-        while todo:
-            # scan through looking for a revision whose parents
-            # are all done
-            for rev_id in sorted(list(todo)):
-                rev = self.revisions[rev_id]
-                parent_ids = set(rev.parent_ids)
-                if parent_ids.issubset(done):
-                    # can take this one now
-                    order.append(rev_id)
-                    todo.remove(rev_id)
-                    done.add(rev_id)
-        return order
-
-
-class ConvertBzrDir5To6(controldir.Converter):
-    """Converts format 5 bzr dirs to format 6."""
-
-    def convert(self, to_convert, pb):
-        """See Converter.convert()."""
-        self.bzrdir = to_convert
-        pb = ui.ui_factory.nested_progress_bar()
-        try:
-            ui.ui_factory.note('starting upgrade from format 5 to 6')
-            self._convert_to_prefixed()
-            return BzrDir.open(self.bzrdir.user_url)
-        finally:
-            pb.finished()
-
-    def _convert_to_prefixed(self):
-        from bzrlib.store import TransportStore
-        self.bzrdir.transport.delete('branch-format')
-        for store_name in ["weaves", "revision-store"]:
-            ui.ui_factory.note("adding prefixes to %s" % store_name)
-            store_transport = self.bzrdir.transport.clone(store_name)
-            store = TransportStore(store_transport, prefixed=True)
-            for urlfilename in store_transport.list_dir('.'):
-                filename = urlutils.unescape(urlfilename)
-                if (filename.endswith(".weave") or
-                    filename.endswith(".gz") or
-                    filename.endswith(".sig")):
-                    file_id, suffix = os.path.splitext(filename)
-                else:
-                    file_id = filename
-                    suffix = ''
-                new_name = store._mapper.map((file_id,)) + suffix
-                # FIXME keep track of the dirs made RBC 20060121
-                try:
-                    store_transport.move(filename, new_name)
-                except errors.NoSuchFile: # catches missing dirs strangely enough
-                    store_transport.mkdir(osutils.dirname(new_name))
-                    store_transport.move(filename, new_name)
-        self.bzrdir.transport.put_bytes(
-            'branch-format',
-            BzrDirFormat6().get_format_string(),
-            mode=self.bzrdir._get_file_mode())
-
-
-class ConvertBzrDir6ToMeta(controldir.Converter):
-    """Converts format 6 bzr dirs to metadirs."""
-
-    def convert(self, to_convert, pb):
-        """See Converter.convert()."""
-        from bzrlib.repofmt.weaverepo import RepositoryFormat7
-        from bzrlib.branch import BzrBranchFormat5
-        self.bzrdir = to_convert
-        self.pb = ui.ui_factory.nested_progress_bar()
-        self.count = 0
-        self.total = 20 # the steps we know about
-        self.garbage_inventories = []
-        self.dir_mode = self.bzrdir._get_dir_mode()
-        self.file_mode = self.bzrdir._get_file_mode()
-
-        ui.ui_factory.note('starting upgrade from format 6 to metadir')
-        self.bzrdir.transport.put_bytes(
-                'branch-format',
-                "Converting to format 6",
-                mode=self.file_mode)
-        # its faster to move specific files around than to open and use the apis...
-        # first off, nuke ancestry.weave, it was never used.
-        try:
-            self.step('Removing ancestry.weave')
-            self.bzrdir.transport.delete('ancestry.weave')
-        except errors.NoSuchFile:
-            pass
-        # find out whats there
-        self.step('Finding branch files')
-        last_revision = self.bzrdir.open_branch().last_revision()
-        bzrcontents = self.bzrdir.transport.list_dir('.')
-        for name in bzrcontents:
-            if name.startswith('basis-inventory.'):
-                self.garbage_inventories.append(name)
-        # create new directories for repository, working tree and branch
-        repository_names = [('inventory.weave', True),
-                            ('revision-store', True),
-                            ('weaves', True)]
-        self.step('Upgrading repository  ')
-        self.bzrdir.transport.mkdir('repository', mode=self.dir_mode)
-        self.make_lock('repository')
-        # we hard code the formats here because we are converting into
-        # the meta format. The meta format upgrader can take this to a
-        # future format within each component.
-        self.put_format('repository', RepositoryFormat7())
-        for entry in repository_names:
-            self.move_entry('repository', entry)
-
-        self.step('Upgrading branch      ')
-        self.bzrdir.transport.mkdir('branch', mode=self.dir_mode)
-        self.make_lock('branch')
-        self.put_format('branch', BzrBranchFormat5())
-        branch_files = [('revision-history', True),
-                        ('branch-name', True),
-                        ('parent', False)]
-        for entry in branch_files:
-            self.move_entry('branch', entry)
-
-        checkout_files = [('pending-merges', True),
-                          ('inventory', True),
-                          ('stat-cache', False)]
-        # If a mandatory checkout file is not present, the branch does not have
-        # a functional checkout. Do not create a checkout in the converted
-        # branch.
-        for name, mandatory in checkout_files:
-            if mandatory and name not in bzrcontents:
-                has_checkout = False
-                break
-        else:
-            has_checkout = True
-        if not has_checkout:
-            ui.ui_factory.note('No working tree.')
-            # If some checkout files are there, we may as well get rid of them.
-            for name, mandatory in checkout_files:
-                if name in bzrcontents:
-                    self.bzrdir.transport.delete(name)
-        else:
-            from bzrlib.workingtree import WorkingTreeFormat3
-            self.step('Upgrading working tree')
-            self.bzrdir.transport.mkdir('checkout', mode=self.dir_mode)
-            self.make_lock('checkout')
-            self.put_format(
-                'checkout', WorkingTreeFormat3())
-            self.bzrdir.transport.delete_multi(
-                self.garbage_inventories, self.pb)
-            for entry in checkout_files:
-                self.move_entry('checkout', entry)
-            if last_revision is not None:
-                self.bzrdir.transport.put_bytes(
-                    'checkout/last-revision', last_revision)
-        self.bzrdir.transport.put_bytes(
-            'branch-format',
-            BzrDirMetaFormat1().get_format_string(),
-            mode=self.file_mode)
-        self.pb.finished()
-        return BzrDir.open(self.bzrdir.user_url)
-
-    def make_lock(self, name):
-        """Make a lock for the new control dir name."""
-        self.step('Make %s lock' % name)
-        ld = lockdir.LockDir(self.bzrdir.transport,
-                             '%s/lock' % name,
-                             file_modebits=self.file_mode,
-                             dir_modebits=self.dir_mode)
-        ld.create()
-
-    def move_entry(self, new_dir, entry):
-        """Move then entry name into new_dir."""
-        name = entry[0]
-        mandatory = entry[1]
-        self.step('Moving %s' % name)
-        try:
-            self.bzrdir.transport.move(name, '%s/%s' % (new_dir, name))
-        except errors.NoSuchFile:
-            if mandatory:
-                raise
-
-    def put_format(self, dirname, format):
-        self.bzrdir.transport.put_bytes('%s/format' % dirname,
-            format.get_format_string(),
-            self.file_mode)
-
-
 class ConvertMetaToMeta(controldir.Converter):
     """Converts the components of metadirs."""
 
@@ -3139,21 +2221,6 @@
     registry.register(key, helper, help, native, deprecated, hidden,
         experimental, alias)
 
-# The pre-0.8 formats have their repository format network name registered in
-# repository.py. MetaDir formats have their repository format network name
-# inferred from their disk format string.
-controldir.format_registry.register('weave', BzrDirFormat6,
-    'Pre-0.8 format.  Slower than knit and does not'
-    ' support checkouts or shared repositories.',
-    hidden=True,
-    deprecated=True)
-register_metadir(controldir.format_registry, 'metaweave',
-    'bzrlib.repofmt.weaverepo.RepositoryFormat7',
-    'Transitional format in 0.8.  Slower than knit.',
-    branch_format='bzrlib.branch.BzrBranchFormat5',
-    tree_format='bzrlib.workingtree.WorkingTreeFormat3',
-    hidden=True,
-    deprecated=True)
 register_metadir(controldir.format_registry, 'knit',
     'bzrlib.repofmt.knitrepo.RepositoryFormatKnit1',
     'Format using knits.  Recommended for interoperation with bzr <= 0.14.',

=== added directory 'bzrlib/plugins/weave_fmt'
=== added file 'bzrlib/plugins/weave_fmt/__init__.py'
--- bzrlib/plugins/weave_fmt/__init__.py	1970-01-01 00:00:00 +0000
+++ bzrlib/plugins/weave_fmt/__init__.py	2011-03-09 01:37:04 +0000
@@ -0,0 +1,114 @@
+# Copyright (C) 2010 Canonical Ltd
+#
+# 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+
+"""Weave formats.
+
+These were formats present in pre-1.0 version of Bazaar.
+"""
+
+from bzrlib import (
+    branch,
+    bzrdir,
+    controldir,
+    repository,
+    serializer,
+    workingtree,
+    )
+
+# Pre-0.8 formats that don't have a disk format string (because they are
+# versioned by the matching control directory). We use the control directories
+# disk format string as a key for the network_name because they meet the
+# constraints (simple string, unique, immutable).
+repository.network_format_registry.register_lazy(
+    "Bazaar-NG branch, format 5\n",
+    'bzrlib.plugins.weave_fmt.repository',
+    'RepositoryFormat5',
+)
+repository.network_format_registry.register_lazy(
+    "Bazaar-NG branch, format 6\n",
+    'bzrlib.plugins.weave_fmt.repository',
+    'RepositoryFormat6',
+)
+
+# weave formats which has no format string and are not discoverable or independently
+# creatable on disk, so are not registered in format_registry.  They're
+# all in bzrlib.plugins.weave_fmt.repository now.  When an instance of one of these is
+# needed, it's constructed directly by the BzrDir.  Non-native formats where
+# the repository is not separately opened are similar.
+
+repository.format_registry.register_lazy(
+    'Bazaar-NG Repository format 7',
+    'bzrlib.plugins.weave_fmt.repository',
+    'RepositoryFormat7'
+    )
+
+repository.format_registry.register_extra_lazy(
+    'bzrlib.plugins.weave_fmt.repository',
+    'RepositoryFormat4')
+repository.format_registry.register_extra_lazy(
+    'bzrlib.plugins.weave_fmt.repository',
+    'RepositoryFormat5')
+repository.format_registry.register_extra_lazy(
+    'bzrlib.plugins.weave_fmt.repository',
+    'RepositoryFormat6')
+
+
+# The pre-0.8 formats have their repository format network name registered in
+# repository.py. MetaDir formats have their repository format network name
+# inferred from their disk format string.
+controldir.format_registry.register_lazy('weave',
+    "bzrlib.plugins.weave_fmt.bzrdir", "BzrDirFormat6",
+    'Pre-0.8 format.  Slower than knit and does not'
+    ' support checkouts or shared repositories.',
+    hidden=True,
+    deprecated=True)
+bzrdir.register_metadir(controldir.format_registry, 'metaweave',
+    'bzrlib.plugins.weave_fmt.repository.RepositoryFormat7',
+    'Transitional format in 0.8.  Slower than knit.',
+    branch_format='bzrlib.branch.BzrBranchFormat5',
+    tree_format='bzrlib.workingtree.WorkingTreeFormat3',
+    hidden=True,
+    deprecated=True)
+
+
+from bzrlib.plugins.weave_fmt.bzrdir import BzrDirFormat4, BzrDirFormat5, BzrDirFormat6
+bzrdir.BzrDirFormat.register_format(BzrDirFormat4())
+bzrdir.BzrDirFormat.register_format(BzrDirFormat5())
+bzrdir.BzrDirFormat.register_format(BzrDirFormat6())
+
+branch.format_registry.register_extra_lazy(
+    'bzrlib.plugins.weave_fmt.branch', 'BzrBranchFormat4')
+branch.network_format_registry.register_lazy(
+    "Bazaar-NG branch, format 6\n",
+    'bzrlib.plugins.weave_fmt.branch', "BzrBranchFormat4")
+
+
+workingtree.format_registry.register_extra_lazy(
+    'bzrlib.plugins.weave_fmt.workingtree',
+    'WorkingTreeFormat2')
+
+serializer.format_registry.register_lazy('4', 'bzrlib.plugins.weave_fmt.xml4',
+    'serializer_v4')
+
+def load_tests(basic_tests, module, loader):
+    testmod_names = [
+        'test_bzrdir',
+        'test_repository',
+        'test_workingtree',
+        ]
+    basic_tests.addTest(loader.loadTestsFromModuleNames(
+            ["%s.%s" % (__name__, tmn) for tmn in testmod_names]))
+    return basic_tests

=== renamed file 'bzrlib/branch_weave.py' => 'bzrlib/plugins/weave_fmt/branch.py'
--- bzrlib/branch_weave.py	2011-03-08 20:07:41 +0000
+++ bzrlib/plugins/weave_fmt/branch.py	2011-03-09 01:37:04 +0000
@@ -34,7 +34,7 @@
     def _get_checkout_format(self):
         """Return the most suitable metadir for a checkout of this branch.
         """
-        from bzrlib.repofmt.weaverepo import RepositoryFormat7
+        from bzrlib.plugins.weave_fmt.repository import RepositoryFormat7
         from bzrlib.bzrdir import BzrDirMetaFormat1
         format = BzrDirMetaFormat1()
         format.repository_format = RepositoryFormat7()
@@ -91,7 +91,9 @@
 
     def __init__(self):
         super(BzrBranchFormat4, self).__init__()
-        from bzrlib.bzrdir import BzrDirFormat4, BzrDirFormat5, BzrDirFormat6
+        from bzrlib.plugins.weave_fmt.bzrdir import (
+            BzrDirFormat4, BzrDirFormat5, BzrDirFormat6,
+            )
         self._matchingbzrdir = BzrDirFormat6()
         self._compatible_bzrdirs = [BzrDirFormat4, BzrDirFormat5,
             BzrDirFormat6]

=== added file 'bzrlib/plugins/weave_fmt/bzrdir.py'
--- bzrlib/plugins/weave_fmt/bzrdir.py	1970-01-01 00:00:00 +0000
+++ bzrlib/plugins/weave_fmt/bzrdir.py	2011-03-09 01:37:04 +0000
@@ -0,0 +1,969 @@
+# Copyright (C) 2006-2010 Canonical Ltd
+#
+# 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+
+"""Weave-era BzrDir formats."""
+
+from bzrlib.bzrdir import (
+    BzrDir,
+    BzrDirFormat,
+    BzrDirMetaFormat1,
+    )
+from bzrlib.controldir import (
+    Converter,
+    format_registry,
+    )
+from bzrlib.lazy_import import lazy_import
+lazy_import(globals(), """
+import os
+import warnings
+
+from bzrlib import (
+    errors,
+    graph,
+    lockable_files,
+    lockdir,
+    osutils,
+    revision as _mod_revision,
+    trace,
+    ui,
+    urlutils,
+    versionedfile,
+    weave,
+    xml5,
+    )
+from bzrlib.store.versioned import VersionedFileStore
+from bzrlib.transactions import WriteTransaction
+from bzrlib.transport import (
+    get_transport,
+    local,
+    )
+from bzrlib.plugins.weave_fmt import xml4
+""")
+
+
+class BzrDirFormatAllInOne(BzrDirFormat):
+    """Common class for formats before meta-dirs."""
+
+    fixed_components = True
+
+    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):
+        """See BzrDirFormat.initialize_on_transport_ex."""
+        require_stacking = (stacked_on is not None)
+        # Format 5 cannot stack, but we've been asked to - actually init
+        # a Meta1Dir
+        if require_stacking:
+            format = BzrDirMetaFormat1()
+            return format.initialize_on_transport_ex(transport,
+                use_existing_dir=use_existing_dir, create_prefix=create_prefix,
+                force_new_repo=force_new_repo, stacked_on=stacked_on,
+                stack_on_pwd=stack_on_pwd, repo_format_name=repo_format_name,
+                make_working_trees=make_working_trees, shared_repo=shared_repo)
+        return BzrDirFormat.initialize_on_transport_ex(self, transport,
+            use_existing_dir=use_existing_dir, create_prefix=create_prefix,
+            force_new_repo=force_new_repo, stacked_on=stacked_on,
+            stack_on_pwd=stack_on_pwd, repo_format_name=repo_format_name,
+            make_working_trees=make_working_trees, shared_repo=shared_repo)
+
+
+class BzrDirFormat5(BzrDirFormatAllInOne):
+    """Bzr control format 5.
+
+    This format is a combined format for working tree, branch and repository.
+    It has:
+     - Format 2 working trees [always]
+     - Format 4 branches [always]
+     - Format 5 repositories [always]
+       Unhashed stores in the repository.
+    """
+
+    _lock_class = lockable_files.TransportLock
+
+    def get_format_string(self):
+        """See BzrDirFormat.get_format_string()."""
+        return "Bazaar-NG branch, format 5\n"
+
+    def get_branch_format(self):
+        from bzrlib.plugins.weave_fmt.branch import BzrBranchFormat4
+        return BzrBranchFormat4()
+
+    def get_format_description(self):
+        """See BzrDirFormat.get_format_description()."""
+        return "All-in-one format 5"
+
+    def get_converter(self, format=None):
+        """See BzrDirFormat.get_converter()."""
+        # there is one and only one upgrade path here.
+        return ConvertBzrDir5To6()
+
+    def _initialize_for_clone(self, url):
+        return self.initialize_on_transport(get_transport(url), _cloning=True)
+
+    def initialize_on_transport(self, transport, _cloning=False):
+        """Format 5 dirs always have working tree, branch and repository.
+
+        Except when they are being cloned.
+        """
+        from bzrlib.plugins.weave_fmt.branch import BzrBranchFormat4
+        from bzrlib.plugins.weave_fmt.repository import RepositoryFormat5
+        result = (super(BzrDirFormat5, self).initialize_on_transport(transport))
+        RepositoryFormat5().initialize(result, _internal=True)
+        if not _cloning:
+            branch = BzrBranchFormat4().initialize(result)
+            result._init_workingtree()
+        return result
+
+    def network_name(self):
+        return self.get_format_string()
+
+    def _open(self, transport):
+        """See BzrDirFormat._open."""
+        return BzrDir5(transport, self)
+
+    def __return_repository_format(self):
+        """Circular import protection."""
+        from bzrlib.plugins.weave_fmt.repository import RepositoryFormat5
+        return RepositoryFormat5()
+    repository_format = property(__return_repository_format)
+
+
+class BzrDirFormat6(BzrDirFormatAllInOne):
+    """Bzr control format 6.
+
+    This format is a combined format for working tree, branch and repository.
+    It has:
+     - Format 2 working trees [always]
+     - Format 4 branches [always]
+     - Format 6 repositories [always]
+    """
+
+    _lock_class = lockable_files.TransportLock
+
+    def get_format_string(self):
+        """See BzrDirFormat.get_format_string()."""
+        return "Bazaar-NG branch, format 6\n"
+
+    def get_format_description(self):
+        """See BzrDirFormat.get_format_description()."""
+        return "All-in-one format 6"
+
+    def get_branch_format(self):
+        from bzrlib.plugins.weave_fmt.branch import BzrBranchFormat4
+        return BzrBranchFormat4()
+
+    def get_converter(self, format=None):
+        """See BzrDirFormat.get_converter()."""
+        # there is one and only one upgrade path here.
+        return ConvertBzrDir6ToMeta()
+
+    def _initialize_for_clone(self, url):
+        return self.initialize_on_transport(get_transport(url), _cloning=True)
+
+    def initialize_on_transport(self, transport, _cloning=False):
+        """Format 6 dirs always have working tree, branch and repository.
+
+        Except when they are being cloned.
+        """
+        from bzrlib.plugins.weave_fmt.branch import BzrBranchFormat4
+        from bzrlib.plugins.weave_fmt.repository import RepositoryFormat6
+        result = super(BzrDirFormat6, self).initialize_on_transport(transport)
+        RepositoryFormat6().initialize(result, _internal=True)
+        if not _cloning:
+            branch = BzrBranchFormat4().initialize(result)
+            result._init_workingtree()
+        return result
+
+    def network_name(self):
+        return self.get_format_string()
+
+    def _open(self, transport):
+        """See BzrDirFormat._open."""
+        return BzrDir6(transport, self)
+
+    def __return_repository_format(self):
+        """Circular import protection."""
+        from bzrlib.plugins.weave_fmt.repository import RepositoryFormat6
+        return RepositoryFormat6()
+    repository_format = property(__return_repository_format)
+
+
+class ConvertBzrDir4To5(Converter):
+    """Converts format 4 bzr dirs to format 5."""
+
+    def __init__(self):
+        super(ConvertBzrDir4To5, self).__init__()
+        self.converted_revs = set()
+        self.absent_revisions = set()
+        self.text_count = 0
+        self.revisions = {}
+
+    def convert(self, to_convert, pb):
+        """See Converter.convert()."""
+        self.bzrdir = to_convert
+        if pb is not None:
+            warnings.warn("pb parameter to convert() is deprecated")
+        self.pb = ui.ui_factory.nested_progress_bar()
+        try:
+            ui.ui_factory.note('starting upgrade from format 4 to 5')
+            if isinstance(self.bzrdir.transport, local.LocalTransport):
+                self.bzrdir.get_workingtree_transport(None).delete('stat-cache')
+            self._convert_to_weaves()
+            return BzrDir.open(self.bzrdir.user_url)
+        finally:
+            self.pb.finished()
+
+    def _convert_to_weaves(self):
+        ui.ui_factory.note('note: upgrade may be faster if all store files are ungzipped first')
+        try:
+            # TODO permissions
+            stat = self.bzrdir.transport.stat('weaves')
+            if not S_ISDIR(stat.st_mode):
+                self.bzrdir.transport.delete('weaves')
+                self.bzrdir.transport.mkdir('weaves')
+        except errors.NoSuchFile:
+            self.bzrdir.transport.mkdir('weaves')
+        # deliberately not a WeaveFile as we want to build it up slowly.
+        self.inv_weave = weave.Weave('inventory')
+        # holds in-memory weaves for all files
+        self.text_weaves = {}
+        self.bzrdir.transport.delete('branch-format')
+        self.branch = self.bzrdir.open_branch()
+        self._convert_working_inv()
+        rev_history = self.branch.revision_history()
+        # to_read is a stack holding the revisions we still need to process;
+        # appending to it adds new highest-priority revisions
+        self.known_revisions = set(rev_history)
+        self.to_read = rev_history[-1:]
+        while self.to_read:
+            rev_id = self.to_read.pop()
+            if (rev_id not in self.revisions
+                and rev_id not in self.absent_revisions):
+                self._load_one_rev(rev_id)
+        self.pb.clear()
+        to_import = self._make_order()
+        for i, rev_id in enumerate(to_import):
+            self.pb.update('converting revision', i, len(to_import))
+            self._convert_one_rev(rev_id)
+        self.pb.clear()
+        self._write_all_weaves()
+        self._write_all_revs()
+        ui.ui_factory.note('upgraded to weaves:')
+        ui.ui_factory.note('  %6d revisions and inventories' % len(self.revisions))
+        ui.ui_factory.note('  %6d revisions not present' % len(self.absent_revisions))
+        ui.ui_factory.note('  %6d texts' % self.text_count)
+        self._cleanup_spare_files_after_format4()
+        self.branch._transport.put_bytes(
+            'branch-format',
+            BzrDirFormat5().get_format_string(),
+            mode=self.bzrdir._get_file_mode())
+
+    def _cleanup_spare_files_after_format4(self):
+        # FIXME working tree upgrade foo.
+        for n in 'merged-patches', 'pending-merged-patches':
+            try:
+                ## assert os.path.getsize(p) == 0
+                self.bzrdir.transport.delete(n)
+            except errors.NoSuchFile:
+                pass
+        self.bzrdir.transport.delete_tree('inventory-store')
+        self.bzrdir.transport.delete_tree('text-store')
+
+    def _convert_working_inv(self):
+        inv = xml4.serializer_v4.read_inventory(
+                self.branch._transport.get('inventory'))
+        new_inv_xml = xml5.serializer_v5.write_inventory_to_string(inv, working=True)
+        self.branch._transport.put_bytes('inventory', new_inv_xml,
+            mode=self.bzrdir._get_file_mode())
+
+    def _write_all_weaves(self):
+        controlweaves = VersionedFileStore(self.bzrdir.transport, prefixed=False,
+            versionedfile_class=weave.WeaveFile)
+        weave_transport = self.bzrdir.transport.clone('weaves')
+        weaves = VersionedFileStore(weave_transport, prefixed=False,
+                versionedfile_class=weave.WeaveFile)
+        transaction = WriteTransaction()
+
+        try:
+            i = 0
+            for file_id, file_weave in self.text_weaves.items():
+                self.pb.update('writing weave', i, len(self.text_weaves))
+                weaves._put_weave(file_id, file_weave, transaction)
+                i += 1
+            self.pb.update('inventory', 0, 1)
+            controlweaves._put_weave('inventory', self.inv_weave, transaction)
+            self.pb.update('inventory', 1, 1)
+        finally:
+            self.pb.clear()
+
+    def _write_all_revs(self):
+        """Write all revisions out in new form."""
+        self.bzrdir.transport.delete_tree('revision-store')
+        self.bzrdir.transport.mkdir('revision-store')
+        revision_transport = self.bzrdir.transport.clone('revision-store')
+        # TODO permissions
+        from bzrlib.xml5 import serializer_v5
+        from bzrlib.plugins.weave_fmt.repository import RevisionTextStore
+        revision_store = RevisionTextStore(revision_transport,
+            serializer_v5, False, versionedfile.PrefixMapper(),
+            lambda:True, lambda:True)
+        try:
+            for i, rev_id in enumerate(self.converted_revs):
+                self.pb.update('write revision', i, len(self.converted_revs))
+                text = serializer_v5.write_revision_to_string(
+                    self.revisions[rev_id])
+                key = (rev_id,)
+                revision_store.add_lines(key, None, osutils.split_lines(text))
+        finally:
+            self.pb.clear()
+
+    def _load_one_rev(self, rev_id):
+        """Load a revision object into memory.
+
+        Any parents not either loaded or abandoned get queued to be
+        loaded."""
+        self.pb.update('loading revision',
+                       len(self.revisions),
+                       len(self.known_revisions))
+        if not self.branch.repository.has_revision(rev_id):
+            self.pb.clear()
+            ui.ui_factory.note('revision {%s} not present in branch; '
+                         'will be converted as a ghost' %
+                         rev_id)
+            self.absent_revisions.add(rev_id)
+        else:
+            rev = self.branch.repository.get_revision(rev_id)
+            for parent_id in rev.parent_ids:
+                self.known_revisions.add(parent_id)
+                self.to_read.append(parent_id)
+            self.revisions[rev_id] = rev
+
+    def _load_old_inventory(self, rev_id):
+        f = self.branch.repository.inventory_store.get(rev_id)
+        try:
+            old_inv_xml = f.read()
+        finally:
+            f.close()
+        inv = xml4.serializer_v4.read_inventory_from_string(old_inv_xml)
+        inv.revision_id = rev_id
+        rev = self.revisions[rev_id]
+        return inv
+
+    def _load_updated_inventory(self, rev_id):
+        inv_xml = self.inv_weave.get_text(rev_id)
+        inv = xml5.serializer_v5.read_inventory_from_string(inv_xml, rev_id)
+        return inv
+
+    def _convert_one_rev(self, rev_id):
+        """Convert revision and all referenced objects to new format."""
+        rev = self.revisions[rev_id]
+        inv = self._load_old_inventory(rev_id)
+        present_parents = [p for p in rev.parent_ids
+                           if p not in self.absent_revisions]
+        self._convert_revision_contents(rev, inv, present_parents)
+        self._store_new_inv(rev, inv, present_parents)
+        self.converted_revs.add(rev_id)
+
+    def _store_new_inv(self, rev, inv, present_parents):
+        new_inv_xml = xml5.serializer_v5.write_inventory_to_string(inv)
+        new_inv_sha1 = osutils.sha_string(new_inv_xml)
+        self.inv_weave.add_lines(rev.revision_id,
+                                 present_parents,
+                                 new_inv_xml.splitlines(True))
+        rev.inventory_sha1 = new_inv_sha1
+
+    def _convert_revision_contents(self, rev, inv, present_parents):
+        """Convert all the files within a revision.
+
+        Also upgrade the inventory to refer to the text revision ids."""
+        rev_id = rev.revision_id
+        trace.mutter('converting texts of revision {%s}', rev_id)
+        parent_invs = map(self._load_updated_inventory, present_parents)
+        entries = inv.iter_entries()
+        entries.next()
+        for path, ie in entries:
+            self._convert_file_version(rev, ie, parent_invs)
+
+    def _convert_file_version(self, rev, ie, parent_invs):
+        """Convert one version of one file.
+
+        The file needs to be added into the weave if it is a merge
+        of >=2 parents or if it's changed from its parent.
+        """
+        file_id = ie.file_id
+        rev_id = rev.revision_id
+        w = self.text_weaves.get(file_id)
+        if w is None:
+            w = weave.Weave(file_id)
+            self.text_weaves[file_id] = w
+        text_changed = False
+        parent_candiate_entries = ie.parent_candidates(parent_invs)
+        heads = graph.Graph(self).heads(parent_candiate_entries.keys())
+        # XXX: Note that this is unordered - and this is tolerable because
+        # the previous code was also unordered.
+        previous_entries = dict((head, parent_candiate_entries[head]) for head
+            in heads)
+        self.snapshot_ie(previous_entries, ie, w, rev_id)
+
+    def get_parent_map(self, revision_ids):
+        """See graph.StackedParentsProvider.get_parent_map"""
+        return dict((revision_id, self.revisions[revision_id])
+                    for revision_id in revision_ids
+                     if revision_id in self.revisions)
+
+    def snapshot_ie(self, previous_revisions, ie, w, rev_id):
+        # TODO: convert this logic, which is ~= snapshot to
+        # a call to:. This needs the path figured out. rather than a work_tree
+        # a v4 revision_tree can be given, or something that looks enough like
+        # one to give the file content to the entry if it needs it.
+        # and we need something that looks like a weave store for snapshot to
+        # save against.
+        #ie.snapshot(rev, PATH, previous_revisions, REVISION_TREE, InMemoryWeaveStore(self.text_weaves))
+        if len(previous_revisions) == 1:
+            previous_ie = previous_revisions.values()[0]
+            if ie._unchanged(previous_ie):
+                ie.revision = previous_ie.revision
+                return
+        if ie.has_text():
+            f = self.branch.repository._text_store.get(ie.text_id)
+            try:
+                file_lines = f.readlines()
+            finally:
+                f.close()
+            w.add_lines(rev_id, previous_revisions, file_lines)
+            self.text_count += 1
+        else:
+            w.add_lines(rev_id, previous_revisions, [])
+        ie.revision = rev_id
+
+    def _make_order(self):
+        """Return a suitable order for importing revisions.
+
+        The order must be such that an revision is imported after all
+        its (present) parents.
+        """
+        todo = set(self.revisions.keys())
+        done = self.absent_revisions.copy()
+        order = []
+        while todo:
+            # scan through looking for a revision whose parents
+            # are all done
+            for rev_id in sorted(list(todo)):
+                rev = self.revisions[rev_id]
+                parent_ids = set(rev.parent_ids)
+                if parent_ids.issubset(done):
+                    # can take this one now
+                    order.append(rev_id)
+                    todo.remove(rev_id)
+                    done.add(rev_id)
+        return order
+
+
+
+
+class ConvertBzrDir5To6(Converter):
+    """Converts format 5 bzr dirs to format 6."""
+
+    def convert(self, to_convert, pb):
+        """See Converter.convert()."""
+        self.bzrdir = to_convert
+        pb = ui.ui_factory.nested_progress_bar()
+        try:
+            ui.ui_factory.note('starting upgrade from format 5 to 6')
+            self._convert_to_prefixed()
+            return BzrDir.open(self.bzrdir.user_url)
+        finally:
+            pb.finished()
+
+    def _convert_to_prefixed(self):
+        from bzrlib.store import TransportStore
+        self.bzrdir.transport.delete('branch-format')
+        for store_name in ["weaves", "revision-store"]:
+            ui.ui_factory.note("adding prefixes to %s" % store_name)
+            store_transport = self.bzrdir.transport.clone(store_name)
+            store = TransportStore(store_transport, prefixed=True)
+            for urlfilename in store_transport.list_dir('.'):
+                filename = urlutils.unescape(urlfilename)
+                if (filename.endswith(".weave") or
+                    filename.endswith(".gz") or
+                    filename.endswith(".sig")):
+                    file_id, suffix = os.path.splitext(filename)
+                else:
+                    file_id = filename
+                    suffix = ''
+                new_name = store._mapper.map((file_id,)) + suffix
+                # FIXME keep track of the dirs made RBC 20060121
+                try:
+                    store_transport.move(filename, new_name)
+                except errors.NoSuchFile: # catches missing dirs strangely enough
+                    store_transport.mkdir(osutils.dirname(new_name))
+                    store_transport.move(filename, new_name)
+        self.bzrdir.transport.put_bytes(
+            'branch-format',
+            BzrDirFormat6().get_format_string(),
+            mode=self.bzrdir._get_file_mode())
+
+
+class ConvertBzrDir6ToMeta(Converter):
+    """Converts format 6 bzr dirs to metadirs."""
+
+    def convert(self, to_convert, pb):
+        """See Converter.convert()."""
+        from bzrlib.plugins.weave_fmt.repository import RepositoryFormat7
+        from bzrlib.branch import BzrBranchFormat5
+        self.bzrdir = to_convert
+        self.pb = ui.ui_factory.nested_progress_bar()
+        self.count = 0
+        self.total = 20 # the steps we know about
+        self.garbage_inventories = []
+        self.dir_mode = self.bzrdir._get_dir_mode()
+        self.file_mode = self.bzrdir._get_file_mode()
+
+        ui.ui_factory.note('starting upgrade from format 6 to metadir')
+        self.bzrdir.transport.put_bytes(
+                'branch-format',
+                "Converting to format 6",
+                mode=self.file_mode)
+        # its faster to move specific files around than to open and use the apis...
+        # first off, nuke ancestry.weave, it was never used.
+        try:
+            self.step('Removing ancestry.weave')
+            self.bzrdir.transport.delete('ancestry.weave')
+        except errors.NoSuchFile:
+            pass
+        # find out whats there
+        self.step('Finding branch files')
+        last_revision = self.bzrdir.open_branch().last_revision()
+        bzrcontents = self.bzrdir.transport.list_dir('.')
+        for name in bzrcontents:
+            if name.startswith('basis-inventory.'):
+                self.garbage_inventories.append(name)
+        # create new directories for repository, working tree and branch
+        repository_names = [('inventory.weave', True),
+                            ('revision-store', True),
+                            ('weaves', True)]
+        self.step('Upgrading repository  ')
+        self.bzrdir.transport.mkdir('repository', mode=self.dir_mode)
+        self.make_lock('repository')
+        # we hard code the formats here because we are converting into
+        # the meta format. The meta format upgrader can take this to a
+        # future format within each component.
+        self.put_format('repository', RepositoryFormat7())
+        for entry in repository_names:
+            self.move_entry('repository', entry)
+
+        self.step('Upgrading branch      ')
+        self.bzrdir.transport.mkdir('branch', mode=self.dir_mode)
+        self.make_lock('branch')
+        self.put_format('branch', BzrBranchFormat5())
+        branch_files = [('revision-history', True),
+                        ('branch-name', True),
+                        ('parent', False)]
+        for entry in branch_files:
+            self.move_entry('branch', entry)
+
+        checkout_files = [('pending-merges', True),
+                          ('inventory', True),
+                          ('stat-cache', False)]
+        # If a mandatory checkout file is not present, the branch does not have
+        # a functional checkout. Do not create a checkout in the converted
+        # branch.
+        for name, mandatory in checkout_files:
+            if mandatory and name not in bzrcontents:
+                has_checkout = False
+                break
+        else:
+            has_checkout = True
+        if not has_checkout:
+            ui.ui_factory.note('No working tree.')
+            # If some checkout files are there, we may as well get rid of them.
+            for name, mandatory in checkout_files:
+                if name in bzrcontents:
+                    self.bzrdir.transport.delete(name)
+        else:
+            from bzrlib.workingtree import WorkingTreeFormat3
+            self.step('Upgrading working tree')
+            self.bzrdir.transport.mkdir('checkout', mode=self.dir_mode)
+            self.make_lock('checkout')
+            self.put_format(
+                'checkout', WorkingTreeFormat3())
+            self.bzrdir.transport.delete_multi(
+                self.garbage_inventories, self.pb)
+            for entry in checkout_files:
+                self.move_entry('checkout', entry)
+            if last_revision is not None:
+                self.bzrdir.transport.put_bytes(
+                    'checkout/last-revision', last_revision)
+        self.bzrdir.transport.put_bytes(
+            'branch-format',
+            BzrDirMetaFormat1().get_format_string(),
+            mode=self.file_mode)
+        self.pb.finished()
+        return BzrDir.open(self.bzrdir.user_url)
+
+    def make_lock(self, name):
+        """Make a lock for the new control dir name."""
+        self.step('Make %s lock' % name)
+        ld = lockdir.LockDir(self.bzrdir.transport,
+                             '%s/lock' % name,
+                             file_modebits=self.file_mode,
+                             dir_modebits=self.dir_mode)
+        ld.create()
+
+    def move_entry(self, new_dir, entry):
+        """Move then entry name into new_dir."""
+        name = entry[0]
+        mandatory = entry[1]
+        self.step('Moving %s' % name)
+        try:
+            self.bzrdir.transport.move(name, '%s/%s' % (new_dir, name))
+        except errors.NoSuchFile:
+            if mandatory:
+                raise
+
+    def put_format(self, dirname, format):
+        self.bzrdir.transport.put_bytes('%s/format' % dirname,
+            format.get_format_string(),
+            self.file_mode)
+
+
+class BzrDirFormat4(BzrDirFormat):
+    """Bzr dir format 4.
+
+    This format is a combined format for working tree, branch and repository.
+    It has:
+     - Format 1 working trees [always]
+     - Format 4 branches [always]
+     - Format 4 repositories [always]
+
+    This format is deprecated: it indexes texts using a text it which is
+    removed in format 5; write support for this format has been removed.
+    """
+
+    _lock_class = lockable_files.TransportLock
+
+    def get_format_string(self):
+        """See BzrDirFormat.get_format_string()."""
+        return "Bazaar-NG branch, format 0.0.4\n"
+
+    def get_format_description(self):
+        """See BzrDirFormat.get_format_description()."""
+        return "All-in-one format 4"
+
+    def get_converter(self, format=None):
+        """See BzrDirFormat.get_converter()."""
+        # there is one and only one upgrade path here.
+        return ConvertBzrDir4To5()
+
+    def initialize_on_transport(self, transport):
+        """Format 4 branches cannot be created."""
+        raise errors.UninitializableFormat(self)
+
+    def is_supported(self):
+        """Format 4 is not supported.
+
+        It is not supported because the model changed from 4 to 5 and the
+        conversion logic is expensive - so doing it on the fly was not
+        feasible.
+        """
+        return False
+
+    def network_name(self):
+        return self.get_format_string()
+
+    def _open(self, transport):
+        """See BzrDirFormat._open."""
+        return BzrDir4(transport, self)
+
+    def __return_repository_format(self):
+        """Circular import protection."""
+        from bzrlib.plugins.weave_fmt.repository import RepositoryFormat4
+        return RepositoryFormat4()
+    repository_format = property(__return_repository_format)
+
+
+class BzrDirPreSplitOut(BzrDir):
+    """A common class for the all-in-one formats."""
+
+    def __init__(self, _transport, _format):
+        """See BzrDir.__init__."""
+        super(BzrDirPreSplitOut, self).__init__(_transport, _format)
+        self._control_files = lockable_files.LockableFiles(
+                                            self.get_branch_transport(None),
+                                            self._format._lock_file_name,
+                                            self._format._lock_class)
+
+    def break_lock(self):
+        """Pre-splitout bzrdirs do not suffer from stale locks."""
+        raise NotImplementedError(self.break_lock)
+
+    def cloning_metadir(self, require_stacking=False):
+        """Produce a metadir suitable for cloning with."""
+        if require_stacking:
+            return format_registry.make_bzrdir('1.6')
+        return self._format.__class__()
+
+    def clone(self, url, revision_id=None, force_new_repo=False,
+              preserve_stacking=False):
+        """See BzrDir.clone().
+
+        force_new_repo has no effect, since this family of formats always
+        require a new repository.
+        preserve_stacking has no effect, since no source branch using this
+        family of formats can be stacked, so there is no stacking to preserve.
+        """
+        self._make_tail(url)
+        result = self._format._initialize_for_clone(url)
+        self.open_repository().clone(result, revision_id=revision_id)
+        from_branch = self.open_branch()
+        from_branch.clone(result, revision_id=revision_id)
+        try:
+            tree = self.open_workingtree()
+        except errors.NotLocalUrl:
+            # make a new one, this format always has to have one.
+            result._init_workingtree()
+        else:
+            tree.clone(result)
+        return result
+
+    def create_branch(self, name=None, repository=None):
+        """See BzrDir.create_branch."""
+        if repository is not None:
+            raise NotImplementedError(
+                "create_branch(repository=<not None>) on %r" % (self,))
+        return self._format.get_branch_format().initialize(self, name=name)
+
+    def destroy_branch(self, name=None):
+        """See BzrDir.destroy_branch."""
+        raise errors.UnsupportedOperation(self.destroy_branch, self)
+
+    def create_repository(self, shared=False):
+        """See BzrDir.create_repository."""
+        if shared:
+            raise errors.IncompatibleFormat('shared repository', self._format)
+        return self.open_repository()
+
+    def destroy_repository(self):
+        """See BzrDir.destroy_repository."""
+        raise errors.UnsupportedOperation(self.destroy_repository, self)
+
+    def create_workingtree(self, revision_id=None, from_branch=None,
+                           accelerator_tree=None, hardlink=False):
+        """See BzrDir.create_workingtree."""
+        # The workingtree is sometimes created when the bzrdir is created,
+        # but not when cloning.
+
+        # this looks buggy but is not -really-
+        # because this format creates the workingtree when the bzrdir is
+        # created
+        # clone and sprout will have set the revision_id
+        # and that will have set it for us, its only
+        # specific uses of create_workingtree in isolation
+        # that can do wonky stuff here, and that only
+        # happens for creating checkouts, which cannot be
+        # done on this format anyway. So - acceptable wart.
+        if hardlink:
+            warning("can't support hardlinked working trees in %r"
+                % (self,))
+        try:
+            result = self.open_workingtree(recommend_upgrade=False)
+        except errors.NoSuchFile:
+            result = self._init_workingtree()
+        if revision_id is not None:
+            if revision_id == _mod_revision.NULL_REVISION:
+                result.set_parent_ids([])
+            else:
+                result.set_parent_ids([revision_id])
+        return result
+
+    def _init_workingtree(self):
+        from bzrlib.plugins.weave_fmt.workingtree import WorkingTreeFormat2
+        try:
+            return WorkingTreeFormat2().initialize(self)
+        except errors.NotLocalUrl:
+            # Even though we can't access the working tree, we need to
+            # create its control files.
+            return WorkingTreeFormat2()._stub_initialize_on_transport(
+                self.transport, self._control_files._file_mode)
+
+    def destroy_workingtree(self):
+        """See BzrDir.destroy_workingtree."""
+        raise errors.UnsupportedOperation(self.destroy_workingtree, self)
+
+    def destroy_workingtree_metadata(self):
+        """See BzrDir.destroy_workingtree_metadata."""
+        raise errors.UnsupportedOperation(self.destroy_workingtree_metadata,
+                                          self)
+
+    def get_branch_transport(self, branch_format, name=None):
+        """See BzrDir.get_branch_transport()."""
+        if name is not None:
+            raise errors.NoColocatedBranchSupport(self)
+        if branch_format is None:
+            return self.transport
+        try:
+            branch_format.get_format_string()
+        except NotImplementedError:
+            return self.transport
+        raise errors.IncompatibleFormat(branch_format, self._format)
+
+    def get_repository_transport(self, repository_format):
+        """See BzrDir.get_repository_transport()."""
+        if repository_format is None:
+            return self.transport
+        try:
+            repository_format.get_format_string()
+        except NotImplementedError:
+            return self.transport
+        raise errors.IncompatibleFormat(repository_format, self._format)
+
+    def get_workingtree_transport(self, workingtree_format):
+        """See BzrDir.get_workingtree_transport()."""
+        if workingtree_format is None:
+            return self.transport
+        try:
+            workingtree_format.get_format_string()
+        except NotImplementedError:
+            return self.transport
+        raise errors.IncompatibleFormat(workingtree_format, self._format)
+
+    def needs_format_conversion(self, format=None):
+        """See BzrDir.needs_format_conversion()."""
+        # if the format is not the same as the system default,
+        # an upgrade is needed.
+        if format is None:
+            symbol_versioning.warn(symbol_versioning.deprecated_in((1, 13, 0))
+                % 'needs_format_conversion(format=None)')
+            format = BzrDirFormat.get_default_format()
+        return not isinstance(self._format, format.__class__)
+
+    def open_branch(self, name=None, unsupported=False,
+                    ignore_fallbacks=False):
+        """See BzrDir.open_branch."""
+        from bzrlib.plugins.weave_fmt.branch import BzrBranchFormat4
+        format = BzrBranchFormat4()
+        self._check_supported(format, unsupported)
+        return format.open(self, name, _found=True)
+
+    def sprout(self, url, revision_id=None, force_new_repo=False,
+               possible_transports=None, accelerator_tree=None,
+               hardlink=False, stacked=False, create_tree_if_local=True,
+               source_branch=None):
+        """See BzrDir.sprout()."""
+        if source_branch is not None:
+            my_branch = self.open_branch()
+            if source_branch.base != my_branch.base:
+                raise AssertionError(
+                    "source branch %r is not within %r with branch %r" %
+                    (source_branch, self, my_branch))
+        if stacked:
+            raise errors.UnstackableBranchFormat(
+                self._format, self.root_transport.base)
+        if not create_tree_if_local:
+            raise errors.MustHaveWorkingTree(
+                self._format, self.root_transport.base)
+        from bzrlib.plugins.weave_fmt.workingtree import WorkingTreeFormat2
+        self._make_tail(url)
+        result = self._format._initialize_for_clone(url)
+        try:
+            self.open_repository().clone(result, revision_id=revision_id)
+        except errors.NoRepositoryPresent:
+            pass
+        try:
+            self.open_branch().sprout(result, revision_id=revision_id)
+        except errors.NotBranchError:
+            pass
+
+        # we always want a working tree
+        WorkingTreeFormat2().initialize(result,
+                                        accelerator_tree=accelerator_tree,
+                                        hardlink=hardlink)
+        return result
+
+
+class BzrDir4(BzrDirPreSplitOut):
+    """A .bzr version 4 control object.
+
+    This is a deprecated format and may be removed after sept 2006.
+    """
+
+    def create_repository(self, shared=False):
+        """See BzrDir.create_repository."""
+        return self._format.repository_format.initialize(self, shared)
+
+    def needs_format_conversion(self, format=None):
+        """Format 4 dirs are always in need of conversion."""
+        if format is None:
+            symbol_versioning.warn(symbol_versioning.deprecated_in((1, 13, 0))
+                % 'needs_format_conversion(format=None)')
+        return True
+
+    def open_repository(self):
+        """See BzrDir.open_repository."""
+        from bzrlib.plugins.weave_fmt.repository import RepositoryFormat4
+        return RepositoryFormat4().open(self, _found=True)
+
+
+
+
+class BzrDir5(BzrDirPreSplitOut):
+    """A .bzr version 5 control object.
+
+    This is a deprecated format and may be removed after sept 2006.
+    """
+
+    def has_workingtree(self):
+        """See BzrDir.has_workingtree."""
+        return True
+    
+    def open_repository(self):
+        """See BzrDir.open_repository."""
+        from bzrlib.plugins.weave_fmt.repository import RepositoryFormat5
+        return RepositoryFormat5().open(self, _found=True)
+
+    def open_workingtree(self, _unsupported=False,
+            recommend_upgrade=True):
+        """See BzrDir.create_workingtree."""
+        from bzrlib.plugins.weave_fmt.workingtree import WorkingTreeFormat2
+        wt_format = WorkingTreeFormat2()
+        # we don't warn here about upgrades; that ought to be handled for the
+        # bzrdir as a whole
+        return wt_format.open(self, _found=True)
+
+
+class BzrDir6(BzrDirPreSplitOut):
+    """A .bzr version 6 control object.
+
+    This is a deprecated format and may be removed after sept 2006.
+    """
+
+    def has_workingtree(self):
+        """See BzrDir.has_workingtree."""
+        return True
+
+    def open_repository(self):
+        """See BzrDir.open_repository."""
+        from bzrlib.plugins.weave_fmt.repository import RepositoryFormat6
+        return RepositoryFormat6().open(self, _found=True)
+
+    def open_workingtree(self, _unsupported=False,
+        recommend_upgrade=True):
+        """See BzrDir.create_workingtree."""
+        # we don't warn here about upgrades; that ought to be handled for the
+        # bzrdir as a whole
+        from bzrlib.plugins.weave_fmt.workingtree import WorkingTreeFormat2
+        return WorkingTreeFormat2().open(self, _found=True)

=== renamed file 'bzrlib/repofmt/weaverepo.py' => 'bzrlib/plugins/weave_fmt/repository.py'
--- bzrlib/repofmt/weaverepo.py	2011-03-05 04:10:42 +0000
+++ bzrlib/plugins/weave_fmt/repository.py	2011-03-09 01:37:04 +0000
@@ -34,7 +34,6 @@
     )
 """)
 from bzrlib import (
-    bzrdir,
     debug,
     errors,
     lockable_files,
@@ -65,6 +64,8 @@
     VersionedFiles,
     )
 
+from bzrlib.plugins.weave_fmt import bzrdir as weave_bzrdir
+
 
 class AllInOneRepository(Repository):
     """Legacy support - the repository behaviour for all-in-one branches."""
@@ -348,7 +349,7 @@
 
     supports_funky_characters = False
 
-    _matchingbzrdir = bzrdir.BzrDirFormat4()
+    _matchingbzrdir = weave_bzrdir.BzrDirFormat4()
 
     def get_format_description(self):
         """See RepositoryFormat.get_format_description()."""
@@ -372,7 +373,7 @@
         return None
 
     def _get_revisions(self, repo_transport, repo):
-        from bzrlib.xml4 import serializer_v4
+        from bzrlib.plugins.weave_fmt.xml4 import serializer_v4
         return RevisionTextStore(repo_transport.clone('revision-store'),
             serializer_v4, True, versionedfile.PrefixMapper(),
             repo.is_locked, repo.is_write_locked)
@@ -396,7 +397,7 @@
     """
 
     _versionedfile_class = weave.WeaveFile
-    _matchingbzrdir = bzrdir.BzrDirFormat5()
+    _matchingbzrdir = weave_bzrdir.BzrDirFormat5()
     supports_funky_characters = False
 
     @property
@@ -432,6 +433,11 @@
         return versionedfile.ThunkedVersionedFiles(base_transport,
             weave.WeaveFile, mapper, repo.is_locked)
 
+    def _get_extra_interrepo_test_combinations(self):
+        from bzrlib.repofmt import knitrepo
+        return [(InterRepository, RepositoryFormat5(),
+            knitrepo.RepositoryFormatKnit3())]
+
 
 class RepositoryFormat6(PreSplitOutRepositoryFormat):
     """Bzr control format 6.
@@ -443,7 +449,7 @@
     """
 
     _versionedfile_class = weave.WeaveFile
-    _matchingbzrdir = bzrdir.BzrDirFormat6()
+    _matchingbzrdir = weave_bzrdir.BzrDirFormat6()
     supports_funky_characters = False
     @property
     def _serializer(self):

=== added file 'bzrlib/plugins/weave_fmt/test_bzrdir.py'
--- bzrlib/plugins/weave_fmt/test_bzrdir.py	1970-01-01 00:00:00 +0000
+++ bzrlib/plugins/weave_fmt/test_bzrdir.py	2011-03-09 01:37:04 +0000
@@ -0,0 +1,512 @@
+# Copyright (C) 2006-2010 Canonical Ltd
+#
+# 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+
+"""Tests for the weave-era BzrDir formats.
+
+For interface contract tests, see tests/per_bzr_dir.
+"""
+
+import sys
+
+from bzrlib import (
+    branch,
+    bzrdir,
+    repository,
+    upgrade,
+    workingtree,
+    )
+from bzrlib.osutils import (
+    lexists,
+    )
+from bzrlib.tests.test_sftp_transport import TestCaseWithSFTPServer
+from bzrlib.tests import (
+    TestCaseWithTransport,
+    )
+
+from bzrlib.plugins.weave_fmt.bzrdir import (
+    BzrDirFormat5,
+    BzrDirFormat6,
+    )
+
+
+class TestFormat5(TestCaseWithTransport):
+    """Tests specific to the version 5 bzrdir format."""
+
+    def test_same_lockfiles_between_tree_repo_branch(self):
+        # this checks that only a single lockfiles instance is created
+        # for format 5 objects
+        dir = BzrDirFormat5().initialize(self.get_url())
+        def check_dir_components_use_same_lock(dir):
+            ctrl_1 = dir.open_repository().control_files
+            ctrl_2 = dir.open_branch().control_files
+            ctrl_3 = dir.open_workingtree()._control_files
+            self.assertTrue(ctrl_1 is ctrl_2)
+            self.assertTrue(ctrl_2 is ctrl_3)
+        check_dir_components_use_same_lock(dir)
+        # and if we open it normally.
+        dir = bzrdir.BzrDir.open(self.get_url())
+        check_dir_components_use_same_lock(dir)
+
+    def test_can_convert(self):
+        # format 5 dirs are convertable
+        dir = BzrDirFormat5().initialize(self.get_url())
+        self.assertTrue(dir.can_convert_format())
+
+    def test_needs_conversion(self):
+        # format 5 dirs need a conversion if they are not the default,
+        # and they aren't
+        dir = BzrDirFormat5().initialize(self.get_url())
+        # don't need to convert it to itself
+        self.assertFalse(dir.needs_format_conversion(BzrDirFormat5()))
+        # do need to convert it to the current default
+        self.assertTrue(dir.needs_format_conversion(
+            bzrdir.BzrDirFormat.get_default_format()))
+
+
+class TestFormat6(TestCaseWithTransport):
+    """Tests specific to the version 6 bzrdir format."""
+
+    def test_same_lockfiles_between_tree_repo_branch(self):
+        # this checks that only a single lockfiles instance is created
+        # for format 6 objects
+        dir = BzrDirFormat6().initialize(self.get_url())
+        def check_dir_components_use_same_lock(dir):
+            ctrl_1 = dir.open_repository().control_files
+            ctrl_2 = dir.open_branch().control_files
+            ctrl_3 = dir.open_workingtree()._control_files
+            self.assertTrue(ctrl_1 is ctrl_2)
+            self.assertTrue(ctrl_2 is ctrl_3)
+        check_dir_components_use_same_lock(dir)
+        # and if we open it normally.
+        dir = bzrdir.BzrDir.open(self.get_url())
+        check_dir_components_use_same_lock(dir)
+
+    def test_can_convert(self):
+        # format 6 dirs are convertable
+        dir = BzrDirFormat6().initialize(self.get_url())
+        self.assertTrue(dir.can_convert_format())
+
+    def test_needs_conversion(self):
+        # format 6 dirs need an conversion if they are not the default.
+        dir = BzrDirFormat6().initialize(self.get_url())
+        self.assertTrue(dir.needs_format_conversion(
+            bzrdir.BzrDirFormat.get_default_format()))
+
+
+class TestBreakLockOldBranch(TestCaseWithTransport):
+
+    def test_break_lock_format_5_bzrdir(self):
+        # break lock on a format 5 bzrdir should just return
+        self.make_branch_and_tree('foo', format=BzrDirFormat5())
+        out, err = self.run_bzr('break-lock foo')
+        self.assertEqual('', out)
+        self.assertEqual('', err)
+
+
+_upgrade1_template = \
+     [
+     ('foo', 'new contents\n'),
+     ('.bzr/',),
+     ('.bzr/README',
+      'This is a Bazaar control directory.\n'
+      'Do not change any files in this directory.\n'
+      'See http://bazaar.canonical.com/ for more information about Bazaar.\n'),
+     ('.bzr/branch-format', 'Bazaar-NG branch, format 0.0.4\n'),
+     ('.bzr/revision-history',
+      '[e-mail]-20051004035611-176b16534b086b3c\n'
+      '[e-mail]-20051004035756-235f2b7dcdddd8dd\n'),
+     ('.bzr/merged-patches', ''),
+     ('.bzr/pending-merged-patches', ''),
+     ('.bzr/branch-name', ''),
+     ('.bzr/branch-lock', ''),
+     ('.bzr/pending-merges', ''),
+     ('.bzr/inventory',
+      '<inventory>\n'
+      '<entry file_id="foo-20051004035605-91e788d1875603ae" kind="file" name="foo" />\n'
+      '</inventory>\n'),
+     ('.bzr/stat-cache',
+      '### bzr hashcache v5\n'
+      'foo// be9f309239729f69a6309e970ef24941d31e042c 13 1128398176 1128398176 303464 770\n'),
+     ('.bzr/text-store/',),
+     ('.bzr/text-store/foo-20051004035611-1591048e9dc7c2d4.gz',
+      '\x1f\x8b\x08\x00[\xfdAC\x02\xff\xcb\xcc\xcb,\xc9L\xccQH\xce\xcf+I\xcd+)\xe6\x02\x00\xdd\xcc\xf90\x11\x00\x00\x00'),
+     ('.bzr/text-store/foo-20051004035756-4081373d897c3453.gz',
+      '\x1f\x8b\x08\x00\xc4\xfdAC\x02\xff\xcbK-WH\xce\xcf+I\xcd+)\xe6\x02\x00g\xc3\xdf\xc9\r\x00\x00\x00'),
+     ('.bzr/inventory-store/',),
+     ('.bzr/inventory-store/[e-mail]',
+      '\x1f\x8b\x08\x00[\xfdAC\x02\xffm\x8f\xcd\n\xc20\x10\x84\xef>E\xc8\xbdt7?M\x02\xad\xaf"\xa1\x99`P[\xa8E\xacOo\x14\x05\x0f\xdef\xe1\xfbv\x98\xbeL7L\xeb\xbcl\xfb]_\xc3\xb2\x89\\\xce8\x944\xc8<\xcf\x8d"\xb2LdH\xdb\x8el\x13\x18\xce\xfb\xc4\xde\xd5SGHq*\xd3\x0b\xad\x8e\x14S\xbc\xe0\xadI\xb1\xe2\xbe\xfe}\xc2\xdc\xb0\rL\xc6#\xa4\xd1\x8d*\x99\x0f}=F\x1e$8G\x9d\xa0\x02\xa1rP9\x01c`FV\xda1qg\x98"\x02}\xa5\xf2\xa8\x95\xec\xa4h\xeb\x80\xf6g\xcd\x13\xb3\x01\xcc\x98\xda\x00\x00\x00'),
+     ('.bzr/inventory-store/[e-mail]',
+      '\x1f\x8b\x08\x00\xc4\xfdAC\x02\xffm\x8f\xc1\n\xc20\x10D\xef~E\xc8\xbd\xb8\x9bM\x9a,\xb4\xfe\x8a\xc4f\x83Am\xa1\x16\xb1~\xbdQ\x14<x\x9b\x81y3LW\xc6\x9b\x8c\xcb4\xaf\xbbMW\xc5\xbc\xaa\\\xce\xb2/\xa9\xd7y\x9a\x1a\x03\xe0\x10\xc0\x02\xb9\x16\\\xc3(>\x84\x84\xc1WKQ\xb4:\x95\xf1\x15\xad\x8cVc\xbc\xc8\x1b\xd3j\x91\xfb\xf2\xaf\xa4r\x8d\x85\x80\xe4)\x05\xf6\x03YG\x9f\xf4\xf5\x18\xb1\xd7\x07\xe1L\xc0\x86\xd8\x1b\xce-\xc7\xb6:a\x0f\x92\x8de\x8b\x89P\xc0\x9a\xe1\x0b\x95G\x9d\xc4\xda\xb1\xad\x07\xb6?o\x9e\xb5\xff\xf0\xf9\xda\x00\x00\x00'),
+     ('.bzr/revision-store/',),
+     ('.bzr/revision-store/[e-mail]',
+      '\x1f\x8b\x08\x00[\xfdAC\x02\xff\x9d\x8eKj\xc30\x14E\xe7^\x85\xd0 \xb3$\xefI\xd1\x8f\xd8\xa6\x1b(t\x07E?\xbb\x82H\n\xb2\x1ahW\xdfB1\x14:\xeb\xf4r\xee\xbdgl\xf1\x91\xb6T\x0b\xf15\xe7\xd4{l\x13}\xb6\xad\xa7B^j\xbd\x91\xc3\xad_\xb3\xbb?m\xf5\xbd\xf9\xb8\xb4\xba\x9eJ\xec\x87\xb5_)I\xe5\x11K\xaf\xed\xe35\x85\x89\xfe\xa5\x8e\x0c@ \xc0\x05\xb8\x90\x88GT\xd2\xa1\x14\xfc\xe2@K\xc7\xfd\xef\x85\xed\xcd\xe2D\x95\x8d\x1a\xa47<\x02c2\xb0 \xbc\xd0\x8ay\xa3\xbcp\x8a\x83\x12A3\xb7XJv\xef\x7f_\xf7\x94\xe3\xd6m\xbeO\x14\x91in4*<\x812\x88\xc60\xfc\x01>k\x89\x13\xe5\x12\x00\xe8<\x8c\xdf\x8d\xcd\xaeq\xb6!\x90\xa5\xd6\xf1\xbc\x07\xc3x\xde\x85\xe6\xe1\x0b\xc8\x8a\x98\x03T\x01\x00\x00'),
+     ('.bzr/revision-store/[e-mail]',
+      '\x1f\x8b\x08\x00\xc4\xfdAC\x02\xff\x9d\x90Kj\x031\x0c\x86\xf79\xc5\xe0Ev\xe9\xc8o\x9b\xcc\x84^\xa0\xd0\x1b\x14\xbf&5d\xec`\xbb\x81\xf6\xf45\x84\xa4\x81\xaeZ\xa1\x85\x84^\xdf\xaf\xa9\x84K\xac1\xa7\xc1\xe5u\x8d\xad\x852\xa3\x17SZL\xc3k\xce\xa7a{j\xfb\xd5\x9e\x9fk\xfe(.,%\x1f\x9fRh\xdbc\xdb\xa3!\xa6KH-\x97\xcf\xb7\xe8g\xf4\xbbkG\x008\x06`@\xb9\xe4bG(_\x88\x95\xde\xf9n\xca\xfb\xc7\r\xf5\xdd\xe0\x19\xa9\x85)\x81\xf5"\xbd\x04j\xb8\x02b\xa8W\\\x0b\xc9\x14\xf4\xbc\xbb\xd7\xd6H4\xdc\xb8\xff}\xba\xc55\xd4f\xd6\xf3\x8c0&\x8ajE\xa4x\xe2@\xa5\xa6\x9a\xf3k\xc3WNaFT\x00\x00:l\xa6>Q\xcd1\x1cjp9\xf9;\xc34\xde\n\x9b\xe9lJWT{t\',a\xf9\x0b\xae\xc0x\x87\xa5\xb0Xp\xca,(a\xa9{\xd0{}\xd4\x12\x04(\xc5\xbb$\xc5$V\xceaI\x19\x01\xa2\x1dh\xed\x82d\x8c.\xccr@\xc3\xd8Q\xc6\x1f\xaa\xf1\xb6\xe8\xb0\xf9\x06QR\r\xf9\xfc\x01\x00\x00')]
+
+
+_ghost_template = [
+    ( './foo',
+        'hello\n'
+    ),
+    ( './.bzr/', ),
+    ( './.bzr/README',
+      'This is a Bazaar control directory.\n'
+      'Do not change any files in this directory.\n'
+      'See http://bazaar.canonical.com/ for more information about Bazaar.\n'
+    ),
+    ( './.bzr/branch-format',
+        'Bazaar-NG branch, format 0.0.4\n'
+    ),
+    ( './.bzr/branch-lock',
+        ''
+    ),
+    ( './.bzr/branch-name',
+        ''
+    ),
+    ( './.bzr/inventory',
+        '<inventory>\n'
+        '<entry file_id="foo-20051004104918-0379cb7c76354cde" kind="file" name="foo" />\n'
+        '</inventory>\n'
+    ),
+    ( './.bzr/merged-patches',
+        ''
+    ),
+    ( './.bzr/pending-merged-patches',
+        ''
+    ),
+    ( './.bzr/pending-merges',
+        ''
+    ),
+    ( './.bzr/revision-history',
+        '[e-mail]-20051004104921-a98be2278dd30b7b\n'
+        '[e-mail]-20051004104937-c9b7a7bfcc0bb22d\n'
+    ),
+    ( './.bzr/stat-cache',
+        '### bzr hashcache v5\n'
+        'foo// f572d396fae9206628714fb2ce00f72e94f2258f 6 1128422956 1128422956 306900 770\n'
+    ),
+    ( './.bzr/text-store/', ),
+    ( './.bzr/text-store/foo-20051004104921-8de8118a71be45ba.gz',
+        '\x1f\x8b\x08\x081^BC\x00\x03foo-20051004104921-8de8118a71be45ba\x00\xcbH\xcd\xc9\xc9\xe7\x02\x00 0:6\x06\x00\x00\x00'
+    ),
+    ( './.bzr/inventory-store/', ),
+    ( './.bzr/inventory-store/[e-mail]',
+        '\x1f\x8b\x08\x081^BC\x00\[e-mail]-20051004104921-a98be2278dd30b7b\x00m\x8f\xcb\n'
+        '\xc20\x10E\xf7~E\xc8\xbe83\xcd\x13\xaa\xbf"yL0\xa8-\xd4"\xd6\xaf7\x8a\x82\x0bw\xb38\xe7\xde;C\x1do<.\xd3\xbc\xee7C;\xe6U\x94z\xe6C\xcd;Y\xa6\xa9#\x00\x8d\x00\n'
+        'Ayt\x1d\xf4\xd6\xa7h\x935\xbdV)\xb3\x14\xa7:\xbe\xd0\xe6H1\x86\x0b\xbf5)\x16\xbe/\x7fC\x08;\x97\xd9!\xba`1\xb2\xd21|\xe8\xeb1`\xe3\xb5\xa5\xdc{S\x02{\x02c\xc8YT%Rb\x80b\x89\xbd*D\xda\x95\xafT\x1f\xad\xd2H\xb1m\xfb\xb7?\xcf<\x01W}\xb5\x8b\xd9\x00\x00\x00'
+    ),
+    ( './.bzr/inventory-store/[e-mail]',
+        '\x1f\x8b\x08\x08A^BC\x00\[e-mail]-20051004104937-c9b7a7bfcc0bb22d\x00m\x8f\xcb\n'
+        '\xc20\x10E\xf7~E\xc8\xbe83\xcd\x13\xaa\xbf"yL0\xa8-\xd4"\xd6\xaf7\x8a\x82\x0bw\xb38\xe7\xde;C\x1do<.\xd3\xbc\xee7C;\xe6U\x94z\xe6C\xcd;Y\xa6\xa9#\x00\x8d\x00\n'
+        'Ayt\x1d\xf4\xd6\xa7h\x935\xbdV)\xb3\x14\xa7:\xbe\xd0\xe6H1\x86\x0b\xbf5)\x16\xbe/\x7fC\x08;\x97\xd9!\xba`1\xb2\xd21|\xe8\xeb1`\xe3\xb5\xa5\xdc{S\x02{\x02c\xc8YT%Rb\x80b\x89\xbd*D\xda\x95\xafT\x1f\xad\xd2H\xb1m\xfb\xb7?\xcf<\x01W}\xb5\x8b\xd9\x00\x00\x00'
+    ),
+    ( './.bzr/revision-store/', ),
+    ( './.bzr/revision-store/[e-mail]',
+        '\x1f\x8b\x08\x081^BC\x00\[e-mail]-20051004104921-a98be2278dd30b7b\x00\x9d\x8eMj\xc30\x14\x84\xf7>\x85\xd0"\xbb$\xef\xc9\xb6,\x11\xdb\xf4\x02\x85\xde\xa0\xe8\xe7\xd9\x11\xc4R\x90\xd4@{\xfa\x06\x8a\xa1\xd0]\x97\x03\xdf\xcc|c\xa6G(!E\xe6\xd2\xb6\x85Z)O\xfc\xd5\xe4\x1a"{K\xe9\xc6\x0e\xb7z\xd9\xec\xfd\xa5\xa4\x8f\xech\xc9i=E\xaa\x87\xb5^8\x0b\xf1A\xb1\xa6\xfc\xf9\x1e\xfc\xc4\xffRG\x01\xd0#@\x87\xd0i\x81G\xa3\x95%!\x06\xe5}\x0bv\xb0\xbf\x17\xca\xd5\xe0\xc4-\xa0\xb1\x8b\xb6`\xc0I\xa4\xc5\xf4\x9el\xef\x95v [\x94\xcf\x8e\xd5\xcay\xe4l\xf7\xfe\xf7u\r'
+        '\x1b\x95j\xb6\xfb\xc4\x11\x85\xea\x84\xd0\x12O\x03t\x83D\xad\xc4\x0f\xf0\x95"M\xbc\x95\x00\xc0\xe7f|6\x8aYi^B.u<\xef\xb1\x19\xcf\xbb\xce\xdc|\x038=\xc7\xe6R\x01\x00\x00'
+    ),
+    ( './.bzr/revision-store/[e-mail]',
+        '\x1f\x8b\x08\x08A^BC\x00\[e-mail]-20051004104937-c9b7a7bfcc0bb22d\x00\x9d\x90\xc1j\xc30\x0c\x86\xef}\n'
+        "\xe3Coie'\xb1c\x9a\x94\xbe\xc0`o0,[N\x03M\\\x1c\xafe{\xfae\x94n\x85\xc1`;Y\x88O\xd2\xff\xb9Mt\x19\xe6!N\xcc\xc5q\x1cr\xa6\xd4\xf1'\x9b\xf20\xb1\xe7\x18Ol}\xca\xbb\x11\xcf\x879\xbe&G!\xc5~3Q^\xf7y\xc7\xd90]h\xca1\xbd\xbd\x0c\xbe\xe3?\xa9B\x02\xd4\x02\xa0\x12P\x99R\x17\xce\xa0\xb6\x1a\x83s\x80(\xa5\x7f\xdc0\x1f\xad\xe88\x82\xb0\x18\x0c\x82\x05\xa7\x04\x05[{\xc2\xda7\xc6\x81*\x85B\x8dh\x1a\xe7\x05g\xf7\xdc\xff>\x9d\x87\x91\xe6l\xc7s\xc7\x85\x90M%\xa5\xd1z#\x85\xa8\x9b\x1a\xaa\xfa\x06\xbc\xc7\x89:^*\x00\xe0\xfbU\xbbL\xcc\xb6\xa7\xfdH\xa9'\x16\x03\xeb\x8fq\xce\xed\xf6\xde_\xb5g\x9b\x16\xa1y\xa9\xbe\x02&\n"
+        '\x7fJ+EaM\x83$\xa5n\xbc/a\x91~\xd0\xbd\xfd\x135\n'
+        '\xd0\x9a`\x0c*W\x1aR\xc1\x94du\x08(\t\xb0\x91\xdeZ\xa3\x9cU\x9cm\x7f\x8dr\x1d\x10Ot\xb8\xc6\xcf\xa7\x907|\xfb-\xb1\xbd\xd3\xfb\xd5\x07\xeeD\xee\x08*\x02\x00\x00'
+    ),
+]
+
+_upgrade_dir_template = [
+    ( './.bzr/', ),
+    ( './.bzr/README',
+      'This is a Bazaar control directory.\n'
+      'Do not change any files in this directory.\n'
+      'See http://bazaar.canonical.com/ for more information about Bazaar.\n'
+    ),
+    ( './.bzr/branch-format',
+        'Bazaar-NG branch, format 0.0.4\n'
+    ),
+    ( './.bzr/branch-lock',
+        ''
+    ),
+    ( './.bzr/branch-name',
+        ''
+    ),
+    ( './.bzr/inventory',
+        '<inventory>\n'
+        '<entry file_id="dir-20051005095101-da1441ea3fa6917a" kind="directory" name="dir" />\n'
+        '</inventory>\n'
+    ),
+    ( './.bzr/merged-patches',
+        ''
+    ),
+    ( './.bzr/pending-merged-patches',
+        ''
+    ),
+    ( './.bzr/pending-merges',
+        ''
+    ),
+    ( './.bzr/revision-history',
+        '[e-mail]-20051005095108-6065fbd8e7d8617e\n'
+    ),
+    ( './.bzr/stat-cache',
+        '### bzr hashcache v5\n'
+    ),
+    ( './.bzr/text-store/', ),
+    ( './.bzr/inventory-store/', ),
+    ( './.bzr/inventory-store/[e-mail]',
+        '\x1f\x8b\x08\x00\x0c\xa2CC\x02\xff\xb3\xc9\xcc+K\xcd+\xc9/\xaa\xb4\xe3\xb2\x012\x8a*\x15\xd22sR\xe33Sl\x95R2\x8bt\x8d\x0c\x0cL\r'
+        "\x81\xd8\xc0\x12H\x19\xea\xa6$\x1a\x9a\x98\x18\xa6&\x1a\xa7%\x9aY\x1a\x9a'*)dg\xe6A\x94\xa6&\x83LQR\xc8K\xccM\x05\x0b()\xe8\x03\xcd\xd4G\xb2\x00\x00\xc2<\x94\xb1m\x00\x00\x00"
+    ),
+    ( './.bzr/revision-store/', ),
+    ( './.bzr/revision-store/[e-mail]',
+        '\x1f\x8b\x08\x00\x0c\xa2CC\x02\xff\xa5OKj\xc30\x14\xdc\xfb\x14B\x8b\xec\x92<I\xd6\xc7\xc42\x85\xde\xa0\x17(\xb6\xf4\x9c\n'
+        'l\xa9H"\x90\x9c\xbe\xa6\xa9\xa1\x9b\xae\xbax\x0c\xcc\xe71\xd3g\xbc\x85\x12R$.\xadk\xa8\x15\xb3\xa5oi\xc2\\\xc9kZ\x96\x10\x0b9,\xf5\x92\xbf)\xf7\xf2\x83O\xe5\x14\xb1\x1e\xae\xf5BI\x887\x8c5\xe5\xfb{\xf0\x96\xfei>r\x00\xc9\xb6\x83n\x03sT\xa0\xe4<y\x83\xda\x1b\xc54\xfe~T>Ff\xe9\xcc:\xdd\x8e\xa6E\xc7@\xa2\x82I\xaaNL\xbas\\313)\x00\xb9\xe6\xe0(\xd9\x87\xfc\xb7A\r'
+        "+\x96:\xae\x9f\x962\xc6\x8d\x04i\x949\x01\x97R\xb7\x1d\x17O\xc3#E\xb4T(\x00\xa0C\xd3o\x892^q\x18\xbd'>\xe4\xfe\xbc\x13M\x7f\xde{\r"
+        '\xcd\x17\x85\xea\xba\x03l\x01\x00\x00'
+    ),
+    ( './dir/', ),
+]
+
+
+class TestUpgrade(TestCaseWithTransport):
+
+    def test_upgrade_v6_to_meta_no_workingtree(self):
+        # Some format6 branches do not have checkout files. Upgrading
+        # such a branch to metadir must not setup a working tree.
+        self.build_tree_contents(_upgrade1_template)
+        upgrade.upgrade('.', BzrDirFormat6())
+        t = self.get_transport('.')
+        t.delete_multi(['.bzr/pending-merges', '.bzr/inventory'])
+        self.assertFalse(t.has('.bzr/stat-cache'))
+        # XXX: upgrade fails if a backup.bzr is already present
+        # -- David Allouche 2006-08-11
+        t.delete_tree('backup.bzr.~1~')
+        # At this point, we have a format6 branch without checkout files.
+        upgrade.upgrade('.', bzrdir.BzrDirMetaFormat1())
+        # The upgrade should not have set up a working tree.
+        control = bzrdir.BzrDir.open('.')
+        self.assertFalse(control.has_workingtree())
+        # We have covered the scope of this test, we may as well check that
+        # upgrade has not eaten our data, even if it's a bit redundant with
+        # other tests.
+        self.failUnless(isinstance(control._format, bzrdir.BzrDirMetaFormat1))
+        b = control.open_branch()
+        self.assertEquals(b.revision_history(),
+           ['[e-mail]-20051004035611-176b16534b086b3c',
+            '[e-mail]-20051004035756-235f2b7dcdddd8dd'])
+
+    def test_upgrade_simple(self):
+        """Upgrade simple v0.0.4 format to latest format"""
+        eq = self.assertEquals
+        self.build_tree_contents(_upgrade1_template)
+        upgrade.upgrade(u'.')
+        control = bzrdir.BzrDir.open('.')
+        b = control.open_branch()
+        # tsk, peeking under the covers.
+        self.failUnless(
+            isinstance(
+                control._format,
+                bzrdir.BzrDirFormat.get_default_format().__class__))
+        rh = b.revision_history()
+        eq(rh,
+           ['[e-mail]-20051004035611-176b16534b086b3c',
+            '[e-mail]-20051004035756-235f2b7dcdddd8dd'])
+        rt = b.repository.revision_tree(rh[0])
+        foo_id = 'foo-20051004035605-91e788d1875603ae'
+        rt.lock_read()
+        try:
+            eq(rt.get_file_text(foo_id), 'initial contents\n')
+        finally:
+            rt.unlock()
+        rt = b.repository.revision_tree(rh[1])
+        rt.lock_read()
+        try:
+            eq(rt.get_file_text(foo_id), 'new contents\n')
+        finally:
+            rt.unlock()
+        # check a backup was made:
+        backup_dir = 'backup.bzr.~1~'
+        t = self.get_transport('.')
+        t.stat(backup_dir)
+        t.stat(backup_dir + '/README')
+        t.stat(backup_dir + '/branch-format')
+        t.stat(backup_dir + '/revision-history')
+        t.stat(backup_dir + '/merged-patches')
+        t.stat(backup_dir + '/pending-merged-patches')
+        t.stat(backup_dir + '/pending-merges')
+        t.stat(backup_dir + '/branch-name')
+        t.stat(backup_dir + '/branch-lock')
+        t.stat(backup_dir + '/inventory')
+        t.stat(backup_dir + '/stat-cache')
+        t.stat(backup_dir + '/text-store')
+        t.stat(backup_dir + '/text-store/foo-20051004035611-1591048e9dc7c2d4.gz')
+        t.stat(backup_dir + '/text-store/foo-20051004035756-4081373d897c3453.gz')
+        t.stat(backup_dir + '/inventory-store/')
+        t.stat(backup_dir + '/inventory-store/[e-mail]')
+        t.stat(backup_dir + '/inventory-store/[e-mail]')
+        t.stat(backup_dir + '/revision-store/')
+        t.stat(backup_dir + '/revision-store/[e-mail]')
+        t.stat(backup_dir + '/revision-store/[e-mail]')
+
+    def test_upgrade_with_ghosts(self):
+        """Upgrade v0.0.4 tree containing ghost references.
+
+        That is, some of the parents of revisions mentioned in the branch
+        aren't present in the branch's storage.
+
+        This shouldn't normally happen in branches created entirely in
+        bzr, but can happen in branches imported from baz and arch, or from
+        other systems, where the importer knows about a revision but not
+        its contents."""
+        eq = self.assertEquals
+        self.build_tree_contents(_ghost_template)
+        upgrade.upgrade(u'.')
+        b = branch.Branch.open(u'.')
+        revision_id = b.revision_history()[1]
+        rev = b.repository.get_revision(revision_id)
+        eq(len(rev.parent_ids), 2)
+        eq(rev.parent_ids[1], 'wibble@wobble-2')
+
+    def test_upgrade_makes_dir_weaves(self):
+        self.build_tree_contents(_upgrade_dir_template)
+        old_repodir = bzrdir.BzrDir.open_unsupported('.')
+        old_repo_format = old_repodir.open_repository()._format
+        upgrade.upgrade('.')
+        # this is the path to the literal file. As format changes
+        # occur it needs to be updated. FIXME: ask the store for the
+        # path.
+        repo = repository.Repository.open('.')
+        # it should have changed the format
+        self.assertNotEqual(old_repo_format.__class__, repo._format.__class__)
+        # and we should be able to read the names for the file id
+        # 'dir-20051005095101-da1441ea3fa6917a'
+        repo.lock_read()
+        self.addCleanup(repo.unlock)
+        text_keys = repo.texts.keys()
+        dir_keys = [key for key in text_keys if key[0] ==
+                'dir-20051005095101-da1441ea3fa6917a']
+        self.assertNotEqual([], dir_keys)
+
+    def test_upgrade_to_meta_sets_workingtree_last_revision(self):
+        self.build_tree_contents(_upgrade_dir_template)
+        upgrade.upgrade('.', bzrdir.BzrDirMetaFormat1())
+        tree = workingtree.WorkingTree.open('.')
+        self.assertEqual([tree.branch.revision_history()[-1]],
+            tree.get_parent_ids())
+
+
+class SFTPBranchTest(TestCaseWithSFTPServer):
+    """Test some stuff when accessing a bzr Branch over sftp"""
+
+    def test_lock_file(self):
+        # old format branches use a special lock file on sftp.
+        b = self.make_branch('', format=BzrDirFormat6())
+        b = branch.Branch.open(self.get_url())
+        self.failUnlessExists('.bzr/')
+        self.failUnlessExists('.bzr/branch-format')
+        self.failUnlessExists('.bzr/branch-lock')
+
+        self.failIf(lexists('.bzr/branch-lock.write-lock'))
+        b.lock_write()
+        self.failUnlessExists('.bzr/branch-lock.write-lock')
+        b.unlock()
+        self.failIf(lexists('.bzr/branch-lock.write-lock'))
+
+
+class TestInfo(TestCaseWithTransport):
+
+    def test_info_locking_oslocks(self):
+        if sys.platform == "win32":
+            self.skip("don't use oslocks on win32 in unix manner")
+        # This test tests old (all-in-one, OS lock using) behaviour which
+        # simply cannot work on windows (and is indeed why we changed our
+        # design. As such, don't try to remove the thisFailsStrictLockCheck
+        # call here.
+        self.thisFailsStrictLockCheck()
+
+        tree = self.make_branch_and_tree('branch',
+                                         format=BzrDirFormat6())
+
+        # Test all permutations of locking the working tree, branch and repository
+        # XXX: Well not yet, as we can't query oslocks yet. Currently, it's
+        # implemented by raising NotImplementedError and get_physical_lock_status()
+        # always returns false. This makes bzr info hide the lock status.  (Olaf)
+        # W B R
+
+        # U U U
+        out, err = self.run_bzr('info -v branch')
+        self.assertEqualDiff(
+"""Standalone tree (format: weave)
+Location:
+  branch root: %s
+
+Format:
+       control: All-in-one format 6
+  working tree: Working tree format 2
+        branch: Branch format 4
+    repository: %s
+
+In the working tree:
+         0 unchanged
+         0 modified
+         0 added
+         0 removed
+         0 renamed
+         0 unknown
+         0 ignored
+         0 versioned subdirectories
+
+Branch history:
+         0 revisions
+
+Repository:
+         0 revisions
+""" % ('branch', tree.branch.repository._format.get_format_description(),
+       ), out)
+        self.assertEqual('', err)
+        # L L L
+        tree.lock_write()
+        out, err = self.run_bzr('info -v branch')
+        self.assertEqualDiff(
+"""Standalone tree (format: weave)
+Location:
+  branch root: %s
+
+Format:
+       control: All-in-one format 6
+  working tree: Working tree format 2
+        branch: Branch format 4
+    repository: %s
+
+In the working tree:
+         0 unchanged
+         0 modified
+         0 added
+         0 removed
+         0 renamed
+         0 unknown
+         0 ignored
+         0 versioned subdirectories
+
+Branch history:
+         0 revisions
+
+Repository:
+         0 revisions
+""" % ('branch', tree.branch.repository._format.get_format_description(),
+       ), out)
+        self.assertEqual('', err)
+        tree.unlock()
+
+

=== added file 'bzrlib/plugins/weave_fmt/test_repository.py'
--- bzrlib/plugins/weave_fmt/test_repository.py	1970-01-01 00:00:00 +0000
+++ bzrlib/plugins/weave_fmt/test_repository.py	2011-03-09 01:37:04 +0000
@@ -0,0 +1,329 @@
+# Copyright (C) 2006-2010 Canonical Ltd
+#
+# 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+
+"""Tests for weave repositories.
+
+For interface tests see tests/per_repository/*.py.
+
+"""
+
+from cStringIO import StringIO
+from stat import S_ISDIR
+import sys
+
+from bzrlib.bzrdir import (
+    BzrDirMetaFormat1,
+    )
+from bzrlib.errors import (
+    IllegalPath,
+    NoSuchFile,
+    )
+from bzrlib.repository import (
+    InterRepository,
+    Repository,
+    )
+from bzrlib.serializer import (
+    format_registry as serializer_format_registry,
+    )
+from bzrlib.tests import (
+    TestCase,
+    TestCaseWithTransport,
+    )
+
+from bzrlib.plugins.weave_fmt import xml4
+from bzrlib.plugins.weave_fmt.bzrdir import (
+    BzrDirFormat6,
+    )
+from bzrlib.plugins.weave_fmt.repository import (
+    InterWeaveRepo,
+    RepositoryFormat4,
+    RepositoryFormat5,
+    RepositoryFormat6,
+    RepositoryFormat7,
+    )
+
+
+class TestFormat6(TestCaseWithTransport):
+
+    def test_attribute__fetch_order(self):
+        """Weaves need topological data insertion."""
+        control = BzrDirFormat6().initialize(self.get_url())
+        repo = RepositoryFormat6().initialize(control)
+        self.assertEqual('topological', repo._format._fetch_order)
+
+    def test_attribute__fetch_uses_deltas(self):
+        """Weaves do not reuse deltas."""
+        control = BzrDirFormat6().initialize(self.get_url())
+        repo = RepositoryFormat6().initialize(control)
+        self.assertEqual(False, repo._format._fetch_uses_deltas)
+
+    def test_attribute__fetch_reconcile(self):
+        """Weave repositories need a reconcile after fetch."""
+        control = BzrDirFormat6().initialize(self.get_url())
+        repo = RepositoryFormat6().initialize(control)
+        self.assertEqual(True, repo._format._fetch_reconcile)
+
+    def test_no_ancestry_weave(self):
+        control = BzrDirFormat6().initialize(self.get_url())
+        repo = RepositoryFormat6().initialize(control)
+        # We no longer need to create the ancestry.weave file
+        # since it is *never* used.
+        self.assertRaises(NoSuchFile,
+                          control.transport.get,
+                          'ancestry.weave')
+
+    def test_supports_external_lookups(self):
+        control = BzrDirFormat6().initialize(self.get_url())
+        repo = RepositoryFormat6().initialize(control)
+        self.assertFalse(repo._format.supports_external_lookups)
+
+
+
+
+class TestFormat7(TestCaseWithTransport):
+
+    def test_attribute__fetch_order(self):
+        """Weaves need topological data insertion."""
+        control = BzrDirMetaFormat1().initialize(self.get_url())
+        repo = RepositoryFormat7().initialize(control)
+        self.assertEqual('topological', repo._format._fetch_order)
+
+    def test_attribute__fetch_uses_deltas(self):
+        """Weaves do not reuse deltas."""
+        control = BzrDirMetaFormat1().initialize(self.get_url())
+        repo = RepositoryFormat7().initialize(control)
+        self.assertEqual(False, repo._format._fetch_uses_deltas)
+
+    def test_attribute__fetch_reconcile(self):
+        """Weave repositories need a reconcile after fetch."""
+        control = BzrDirMetaFormat1().initialize(self.get_url())
+        repo = RepositoryFormat7().initialize(control)
+        self.assertEqual(True, repo._format._fetch_reconcile)
+
+    def test_disk_layout(self):
+        control = BzrDirMetaFormat1().initialize(self.get_url())
+        repo = RepositoryFormat7().initialize(control)
+        # in case of side effects of locking.
+        repo.lock_write()
+        repo.unlock()
+        # we want:
+        # format 'Bazaar-NG Repository format 7'
+        # lock ''
+        # inventory.weave == empty_weave
+        # empty revision-store directory
+        # empty weaves directory
+        t = control.get_repository_transport(None)
+        self.assertEqualDiff('Bazaar-NG Repository format 7',
+                             t.get('format').read())
+        self.assertTrue(S_ISDIR(t.stat('revision-store').st_mode))
+        self.assertTrue(S_ISDIR(t.stat('weaves').st_mode))
+        self.assertEqualDiff('# bzr weave file v5\n'
+                             'w\n'
+                             'W\n',
+                             t.get('inventory.weave').read())
+        # Creating a file with id Foo:Bar results in a non-escaped file name on
+        # disk.
+        control.create_branch()
+        tree = control.create_workingtree()
+        tree.add(['foo'], ['Foo:Bar'], ['file'])
+        tree.put_file_bytes_non_atomic('Foo:Bar', 'content\n')
+        try:
+            tree.commit('first post', rev_id='first')
+        except IllegalPath:
+            if sys.platform != 'win32':
+                raise
+            self.knownFailure('Foo:Bar cannot be used as a file-id on windows'
+                              ' in repo format 7')
+            return
+        self.assertEqualDiff(
+            '# bzr weave file v5\n'
+            'i\n'
+            '1 7fe70820e08a1aac0ef224d9c66ab66831cc4ab1\n'
+            'n first\n'
+            '\n'
+            'w\n'
+            '{ 0\n'
+            '. content\n'
+            '}\n'
+            'W\n',
+            t.get('weaves/74/Foo%3ABar.weave').read())
+
+    def test_shared_disk_layout(self):
+        control = BzrDirMetaFormat1().initialize(self.get_url())
+        repo = RepositoryFormat7().initialize(control, shared=True)
+        # we want:
+        # format 'Bazaar-NG Repository format 7'
+        # inventory.weave == empty_weave
+        # empty revision-store directory
+        # empty weaves directory
+        # a 'shared-storage' marker file.
+        # lock is not present when unlocked
+        t = control.get_repository_transport(None)
+        self.assertEqualDiff('Bazaar-NG Repository format 7',
+                             t.get('format').read())
+        self.assertEqualDiff('', t.get('shared-storage').read())
+        self.assertTrue(S_ISDIR(t.stat('revision-store').st_mode))
+        self.assertTrue(S_ISDIR(t.stat('weaves').st_mode))
+        self.assertEqualDiff('# bzr weave file v5\n'
+                             'w\n'
+                             'W\n',
+                             t.get('inventory.weave').read())
+        self.assertFalse(t.has('branch-lock'))
+
+    def test_creates_lockdir(self):
+        """Make sure it appears to be controlled by a LockDir existence"""
+        control = BzrDirMetaFormat1().initialize(self.get_url())
+        repo = RepositoryFormat7().initialize(control, shared=True)
+        t = control.get_repository_transport(None)
+        # TODO: Should check there is a 'lock' toplevel directory,
+        # regardless of contents
+        self.assertFalse(t.has('lock/held/info'))
+        repo.lock_write()
+        try:
+            self.assertTrue(t.has('lock/held/info'))
+        finally:
+            # unlock so we don't get a warning about failing to do so
+            repo.unlock()
+
+    def test_uses_lockdir(self):
+        """repo format 7 actually locks on lockdir"""
+        base_url = self.get_url()
+        control = BzrDirMetaFormat1().initialize(base_url)
+        repo = RepositoryFormat7().initialize(control, shared=True)
+        t = control.get_repository_transport(None)
+        repo.lock_write()
+        repo.unlock()
+        del repo
+        # make sure the same lock is created by opening it
+        repo = Repository.open(base_url)
+        repo.lock_write()
+        self.assertTrue(t.has('lock/held/info'))
+        repo.unlock()
+        self.assertFalse(t.has('lock/held/info'))
+
+    def test_shared_no_tree_disk_layout(self):
+        control = BzrDirMetaFormat1().initialize(self.get_url())
+        repo = RepositoryFormat7().initialize(control, shared=True)
+        repo.set_make_working_trees(False)
+        # we want:
+        # format 'Bazaar-NG Repository format 7'
+        # lock ''
+        # inventory.weave == empty_weave
+        # empty revision-store directory
+        # empty weaves directory
+        # a 'shared-storage' marker file.
+        t = control.get_repository_transport(None)
+        self.assertEqualDiff('Bazaar-NG Repository format 7',
+                             t.get('format').read())
+        ## self.assertEqualDiff('', t.get('lock').read())
+        self.assertEqualDiff('', t.get('shared-storage').read())
+        self.assertEqualDiff('', t.get('no-working-trees').read())
+        repo.set_make_working_trees(True)
+        self.assertFalse(t.has('no-working-trees'))
+        self.assertTrue(S_ISDIR(t.stat('revision-store').st_mode))
+        self.assertTrue(S_ISDIR(t.stat('weaves').st_mode))
+        self.assertEqualDiff('# bzr weave file v5\n'
+                             'w\n'
+                             'W\n',
+                             t.get('inventory.weave').read())
+
+    def test_supports_external_lookups(self):
+        control = BzrDirMetaFormat1().initialize(self.get_url())
+        repo = RepositoryFormat7().initialize(control)
+        self.assertFalse(repo._format.supports_external_lookups)
+
+
+class TestInterWeaveRepo(TestCaseWithTransport):
+
+    def test_is_compatible_and_registered(self):
+        # InterWeaveRepo is compatible when either side
+        # is a format 5/6/7 branch
+        from bzrlib.repofmt import knitrepo
+        formats = [RepositoryFormat5(),
+                   RepositoryFormat6(),
+                   RepositoryFormat7()]
+        incompatible_formats = [RepositoryFormat4(),
+                                knitrepo.RepositoryFormatKnit1(),
+                                ]
+        repo_a = self.make_repository('a')
+        repo_b = self.make_repository('b')
+        is_compatible = InterWeaveRepo.is_compatible
+        for source in incompatible_formats:
+            # force incompatible left then right
+            repo_a._format = source
+            repo_b._format = formats[0]
+            self.assertFalse(is_compatible(repo_a, repo_b))
+            self.assertFalse(is_compatible(repo_b, repo_a))
+        for source in formats:
+            repo_a._format = source
+            for target in formats:
+                repo_b._format = target
+                self.assertTrue(is_compatible(repo_a, repo_b))
+        self.assertEqual(InterWeaveRepo,
+                         InterRepository.get(repo_a, repo_b).__class__)
+
+
+_working_inventory_v4 = """<inventory file_id="TREE_ROOT">
+<entry file_id="bar-20050901064931-73b4b1138abc9cd2" kind="file" name="bar" parent_id="TREE_ROOT" />
+<entry file_id="foo-20050801201819-4139aa4a272f4250" kind="directory" name="foo" parent_id="TREE_ROOT" />
+<entry file_id="bar-20050824000535-6bc48cfad47ed134" kind="file" name="bar" parent_id="foo-20050801201819-4139aa4a272f4250" />
+</inventory>"""
+
+
+_revision_v4 = """<revision committer="Martin Pool &lt;[e-mail]&gt;"
+    inventory_id="[e-mail]-20050905080035-e0439293f8b6b9f9"
+    inventory_sha1="e79c31c1deb64c163cf660fdedd476dd579ffd41"
+    revision_id="[e-mail]-20050905080035-e0439293f8b6b9f9"
+    timestamp="1125907235.212"
+    timezone="36000">
+<message>- start splitting code for xml (de)serialization away from objects
+  preparatory to supporting multiple formats by a single library
+</message>
+<parents>
+<revision_ref revision_id="[e-mail]-20050905063503-43948f59fa127d92" revision_sha1="7bdf4cc8c5bdac739f8cf9b10b78cf4b68f915ff" />
+</parents>
+</revision>
+"""
+
+
+class TestSerializer(TestCase):
+    """Test serializer"""
+
+    def test_registry(self):
+        self.assertIs(xml4.serializer_v4,
+                      serializer_format_registry.get('4'))
+
+    def test_canned_inventory(self):
+        """Test unpacked a canned inventory v4 file."""
+        inp = StringIO(_working_inventory_v4)
+        inv = xml4.serializer_v4.read_inventory(inp)
+        self.assertEqual(len(inv), 4)
+        self.assert_('bar-20050901064931-73b4b1138abc9cd2' in inv)
+
+    def test_unpack_revision(self):
+        """Test unpacking a canned revision v4"""
+        inp = StringIO(_revision_v4)
+        rev = xml4.serializer_v4.read_revision(inp)
+        eq = self.assertEqual
+        eq(rev.committer,
+           "Martin Pool <[e-mail]>")
+        eq(rev.inventory_id,
+           "[e-mail]-20050905080035-e0439293f8b6b9f9")
+        eq(len(rev.parent_ids), 1)
+        eq(rev.parent_ids[0],
+           "[e-mail]-20050905063503-43948f59fa127d92")
+
+

=== renamed file 'bzrlib/tests/test_workingtree_2.py' => 'bzrlib/plugins/weave_fmt/test_workingtree.py'
--- bzrlib/tests/test_workingtree_2.py	2011-03-03 11:32:03 +0000
+++ bzrlib/plugins/weave_fmt/test_workingtree.py	2011-03-09 01:37:04 +0000
@@ -28,7 +28,7 @@
     TestCaseWithTransport,
     )
 
-from bzrlib.bzrdir import BzrDirFormat6
+from bzrlib.plugins.weave_fmt.bzrdir import BzrDirFormat6
 
 
 class TestFormat2WorkingTree(TestCaseWithTransport):

=== added directory 'bzrlib/plugins/weave_fmt/tests'
=== renamed file 'bzrlib/workingtree_2.py' => 'bzrlib/plugins/weave_fmt/workingtree.py'
--- bzrlib/workingtree_2.py	2011-03-03 11:32:03 +0000
+++ bzrlib/plugins/weave_fmt/workingtree.py	2011-03-09 01:37:04 +0000
@@ -111,7 +111,7 @@
 
     def __init__(self):
         super(WorkingTreeFormat2, self).__init__()
-        from bzrlib.bzrdir import BzrDirFormat6
+        from bzrlib.plugins.weave_fmt.bzrdir import BzrDirFormat6
         self._matchingbzrdir = BzrDirFormat6()
 
     def open(self, a_bzrdir, _found=False):

=== renamed file 'bzrlib/xml4.py' => 'bzrlib/plugins/weave_fmt/xml4.py'
=== modified file 'bzrlib/repository.py'
--- bzrlib/repository.py	2011-03-05 04:10:42 +0000
+++ bzrlib/repository.py	2011-03-09 01:37:04 +0000
@@ -3218,44 +3218,13 @@
         return self.get_format_string()
 
 
-# Pre-0.8 formats that don't have a disk format string (because they are
-# versioned by the matching control directory). We use the control directories
-# disk format string as a key for the network_name because they meet the
-# constraints (simple string, unique, immutable).
-network_format_registry.register_lazy(
-    "Bazaar-NG branch, format 5\n",
-    'bzrlib.repofmt.weaverepo',
-    'RepositoryFormat5',
-)
-network_format_registry.register_lazy(
-    "Bazaar-NG branch, format 6\n",
-    'bzrlib.repofmt.weaverepo',
-    'RepositoryFormat6',
-)
-
-format_registry.register_extra_lazy(
-    'bzrlib.repofmt.weaverepo',
-    'RepositoryFormat4')
-format_registry.register_extra_lazy(
-    'bzrlib.repofmt.weaverepo',
-    'RepositoryFormat5')
-format_registry.register_extra_lazy(
-    'bzrlib.repofmt.weaverepo',
-    'RepositoryFormat6')
-
 # formats which have no format string are not discoverable or independently
 # creatable on disk, so are not registered in format_registry.  They're
-# all in bzrlib.repofmt.weaverepo now.  When an instance of one of these is
+# all in bzrlib.repofmt.knitreponow.  When an instance of one of these is
 # needed, it's constructed directly by the BzrDir.  Non-native formats where
 # the repository is not separately opened are similar.
 
 format_registry.register_lazy(
-    'Bazaar-NG Repository format 7',
-    'bzrlib.repofmt.weaverepo',
-    'RepositoryFormat7'
-    )
-
-format_registry.register_lazy(
     'Bazaar-NG Knit Repository Format 1',
     'bzrlib.repofmt.knitrepo',
     'RepositoryFormatKnit1',

=== modified file 'bzrlib/serializer.py'
--- bzrlib/serializer.py	2010-02-17 17:11:16 +0000
+++ bzrlib/serializer.py	2011-03-09 01:37:04 +0000
@@ -93,7 +93,6 @@
 
 
 format_registry = SerializerRegistry()
-format_registry.register_lazy('4', 'bzrlib.xml4', 'serializer_v4')
 format_registry.register_lazy('5', 'bzrlib.xml5', 'serializer_v5')
 format_registry.register_lazy('6', 'bzrlib.xml6', 'serializer_v6')
 format_registry.register_lazy('7', 'bzrlib.xml7', 'serializer_v7')

=== modified file 'bzrlib/tests/__init__.py'
--- bzrlib/tests/__init__.py	2011-03-08 17:37:58 +0000
+++ bzrlib/tests/__init__.py	2011-03-09 01:37:04 +0000
@@ -3888,7 +3888,6 @@
         'bzrlib.tests.test_whitebox',
         'bzrlib.tests.test_win32utils',
         'bzrlib.tests.test_workingtree',
-        'bzrlib.tests.test_workingtree_2',
         'bzrlib.tests.test_workingtree_4',
         'bzrlib.tests.test_wsgi',
         'bzrlib.tests.test_xml',

=== modified file 'bzrlib/tests/blackbox/test_break_lock.py'
--- bzrlib/tests/blackbox/test_break_lock.py	2011-01-13 05:28:55 +0000
+++ bzrlib/tests/blackbox/test_break_lock.py	2011-03-09 01:37:04 +0000
@@ -104,15 +104,6 @@
         self.assertRaises(errors.LockBroken, self.master_branch.unlock)
 
 
-class TestBreakLockOldBranch(tests.TestCaseWithTransport):
-
-    def test_break_lock_format_5_bzrdir(self):
-        # break lock on a format 5 bzrdir should just return
-        self.make_branch_and_tree('foo', format=bzrdir.BzrDirFormat5())
-        out, err = self.run_bzr('break-lock foo')
-        self.assertEqual('', out)
-        self.assertEqual('', err)
-
 class TestConfigBreakLock(tests.TestCaseWithTransport):
 
     def setUp(self):

=== modified file 'bzrlib/tests/blackbox/test_info.py'
--- bzrlib/tests/blackbox/test_info.py	2010-04-14 09:57:01 +0000
+++ bzrlib/tests/blackbox/test_info.py	2011-03-09 01:37:04 +0000
@@ -1323,89 +1323,6 @@
             self.knownFailure('Win32 cannot run "bzr info"'
                               ' when the tree is locked.')
 
-    def test_info_locking_oslocks(self):
-        if sys.platform == "win32":
-            self.skip("don't use oslocks on win32 in unix manner")
-        # This test tests old (all-in-one, OS lock using) behaviour which
-        # simply cannot work on windows (and is indeed why we changed our
-        # design. As such, don't try to remove the thisFailsStrictLockCheck
-        # call here.
-        self.thisFailsStrictLockCheck()
-
-        tree = self.make_branch_and_tree('branch',
-                                         format=bzrdir.BzrDirFormat6())
-
-        # Test all permutations of locking the working tree, branch and repository
-        # XXX: Well not yet, as we can't query oslocks yet. Currently, it's
-        # implemented by raising NotImplementedError and get_physical_lock_status()
-        # always returns false. This makes bzr info hide the lock status.  (Olaf)
-        # W B R
-
-        # U U U
-        out, err = self.run_bzr('info -v branch')
-        self.assertEqualDiff(
-"""Standalone tree (format: weave)
-Location:
-  branch root: %s
-
-Format:
-       control: All-in-one format 6
-  working tree: Working tree format 2
-        branch: Branch format 4
-    repository: %s
-
-In the working tree:
-         0 unchanged
-         0 modified
-         0 added
-         0 removed
-         0 renamed
-         0 unknown
-         0 ignored
-         0 versioned subdirectories
-
-Branch history:
-         0 revisions
-
-Repository:
-         0 revisions
-""" % ('branch', tree.branch.repository._format.get_format_description(),
-       ), out)
-        self.assertEqual('', err)
-        # L L L
-        tree.lock_write()
-        out, err = self.run_bzr('info -v branch')
-        self.assertEqualDiff(
-"""Standalone tree (format: weave)
-Location:
-  branch root: %s
-
-Format:
-       control: All-in-one format 6
-  working tree: Working tree format 2
-        branch: Branch format 4
-    repository: %s
-
-In the working tree:
-         0 unchanged
-         0 modified
-         0 added
-         0 removed
-         0 renamed
-         0 unknown
-         0 ignored
-         0 versioned subdirectories
-
-Branch history:
-         0 revisions
-
-Repository:
-         0 revisions
-""" % ('branch', tree.branch.repository._format.get_format_description(),
-       ), out)
-        self.assertEqual('', err)
-        tree.unlock()
-
     def test_info_stacked(self):
         # We have a mainline
         trunk_tree = self.make_branch_and_tree('mainline',

=== modified file 'bzrlib/tests/per_repository/test_repository.py'
--- bzrlib/tests/per_repository/test_repository.py	2011-03-08 17:02:52 +0000
+++ bzrlib/tests/per_repository/test_repository.py	2011-03-09 01:37:04 +0000
@@ -38,7 +38,6 @@
     )
 from bzrlib.repofmt import (
     pack_repo,
-    weaverepo,
     )
 from bzrlib.tests import (
     per_repository,
@@ -560,23 +559,6 @@
         self.addCleanup(rev_tree.unlock)
         self.assertEqual('rev_id', rev_tree.inventory.root.revision)
 
-    def test_upgrade_from_format4(self):
-        from bzrlib.tests.test_upgrade import _upgrade_dir_template
-        if isinstance(self.repository_format, remote.RemoteRepositoryFormat):
-            return # local conversion to/from RemoteObjects is irrelevant.
-        if self.repository_format.get_format_description() \
-            == "Repository format 4":
-            raise tests.TestSkipped('Cannot convert format-4 to itself')
-        self.build_tree_contents(_upgrade_dir_template)
-        old_repodir = bzrdir.BzrDir.open_unsupported('.')
-        old_repo_format = old_repodir.open_repository()._format
-        format = self.repository_format._matchingbzrdir
-        try:
-            format.repository_format = self.repository_format
-        except AttributeError:
-            pass
-        upgrade.upgrade('.', format)
-
     def test_pointless_commit(self):
         tree = self.make_branch_and_tree('.')
         self.assertRaises(errors.PointlessCommit, tree.commit, 'pointless',

=== modified file 'bzrlib/tests/test_bzrdir.py'
--- bzrlib/tests/test_bzrdir.py	2011-02-24 12:08:37 +0000
+++ bzrlib/tests/test_bzrdir.py	2011-03-09 01:37:04 +0000
@@ -1007,70 +1007,6 @@
         self.assertEqual(2, rpc_count)
 
 
-class TestFormat5(TestCaseWithTransport):
-    """Tests specific to the version 5 bzrdir format."""
-
-    def test_same_lockfiles_between_tree_repo_branch(self):
-        # this checks that only a single lockfiles instance is created
-        # for format 5 objects
-        dir = bzrdir.BzrDirFormat5().initialize(self.get_url())
-        def check_dir_components_use_same_lock(dir):
-            ctrl_1 = dir.open_repository().control_files
-            ctrl_2 = dir.open_branch().control_files
-            ctrl_3 = dir.open_workingtree()._control_files
-            self.assertTrue(ctrl_1 is ctrl_2)
-            self.assertTrue(ctrl_2 is ctrl_3)
-        check_dir_components_use_same_lock(dir)
-        # and if we open it normally.
-        dir = bzrdir.BzrDir.open(self.get_url())
-        check_dir_components_use_same_lock(dir)
-
-    def test_can_convert(self):
-        # format 5 dirs are convertable
-        dir = bzrdir.BzrDirFormat5().initialize(self.get_url())
-        self.assertTrue(dir.can_convert_format())
-
-    def test_needs_conversion(self):
-        # format 5 dirs need a conversion if they are not the default,
-        # and they aren't
-        dir = bzrdir.BzrDirFormat5().initialize(self.get_url())
-        # don't need to convert it to itself
-        self.assertFalse(dir.needs_format_conversion(bzrdir.BzrDirFormat5()))
-        # do need to convert it to the current default
-        self.assertTrue(dir.needs_format_conversion(
-            bzrdir.BzrDirFormat.get_default_format()))
-
-
-class TestFormat6(TestCaseWithTransport):
-    """Tests specific to the version 6 bzrdir format."""
-
-    def test_same_lockfiles_between_tree_repo_branch(self):
-        # this checks that only a single lockfiles instance is created
-        # for format 6 objects
-        dir = bzrdir.BzrDirFormat6().initialize(self.get_url())
-        def check_dir_components_use_same_lock(dir):
-            ctrl_1 = dir.open_repository().control_files
-            ctrl_2 = dir.open_branch().control_files
-            ctrl_3 = dir.open_workingtree()._control_files
-            self.assertTrue(ctrl_1 is ctrl_2)
-            self.assertTrue(ctrl_2 is ctrl_3)
-        check_dir_components_use_same_lock(dir)
-        # and if we open it normally.
-        dir = bzrdir.BzrDir.open(self.get_url())
-        check_dir_components_use_same_lock(dir)
-
-    def test_can_convert(self):
-        # format 6 dirs are convertable
-        dir = bzrdir.BzrDirFormat6().initialize(self.get_url())
-        self.assertTrue(dir.can_convert_format())
-
-    def test_needs_conversion(self):
-        # format 6 dirs need an conversion if they are not the default.
-        dir = bzrdir.BzrDirFormat6().initialize(self.get_url())
-        self.assertTrue(dir.needs_format_conversion(
-            bzrdir.BzrDirFormat.get_default_format()))
-
-
 class NotBzrDir(bzrlib.bzrdir.BzrDir):
     """A non .bzr based control directory."""
 

=== modified file 'bzrlib/tests/test_repository.py'
--- bzrlib/tests/test_repository.py	2011-02-24 16:13:39 +0000
+++ bzrlib/tests/test_repository.py	2011-03-09 01:37:04 +0000
@@ -23,11 +23,9 @@
 """
 
 from stat import S_ISDIR
-import sys
 
 import bzrlib
 from bzrlib.errors import (
-    NoSuchFile,
     UnknownFormatError,
     UnsupportedFormatError,
     )
@@ -60,7 +58,6 @@
     groupcompress_repo,
     knitrepo,
     pack_repo,
-    weaverepo,
     )
 
 
@@ -209,194 +206,6 @@
         self.assertIsInstance(formats[0], SampleExtraRepositoryFormat)
 
 
-class TestFormat6(TestCaseWithTransport):
-
-    def test_attribute__fetch_order(self):
-        """Weaves need topological data insertion."""
-        control = bzrdir.BzrDirFormat6().initialize(self.get_url())
-        repo = weaverepo.RepositoryFormat6().initialize(control)
-        self.assertEqual('topological', repo._format._fetch_order)
-
-    def test_attribute__fetch_uses_deltas(self):
-        """Weaves do not reuse deltas."""
-        control = bzrdir.BzrDirFormat6().initialize(self.get_url())
-        repo = weaverepo.RepositoryFormat6().initialize(control)
-        self.assertEqual(False, repo._format._fetch_uses_deltas)
-
-    def test_attribute__fetch_reconcile(self):
-        """Weave repositories need a reconcile after fetch."""
-        control = bzrdir.BzrDirFormat6().initialize(self.get_url())
-        repo = weaverepo.RepositoryFormat6().initialize(control)
-        self.assertEqual(True, repo._format._fetch_reconcile)
-
-    def test_no_ancestry_weave(self):
-        control = bzrdir.BzrDirFormat6().initialize(self.get_url())
-        repo = weaverepo.RepositoryFormat6().initialize(control)
-        # We no longer need to create the ancestry.weave file
-        # since it is *never* used.
-        self.assertRaises(NoSuchFile,
-                          control.transport.get,
-                          'ancestry.weave')
-
-    def test_supports_external_lookups(self):
-        control = bzrdir.BzrDirFormat6().initialize(self.get_url())
-        repo = weaverepo.RepositoryFormat6().initialize(control)
-        self.assertFalse(repo._format.supports_external_lookups)
-
-
-class TestFormat7(TestCaseWithTransport):
-
-    def test_attribute__fetch_order(self):
-        """Weaves need topological data insertion."""
-        control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
-        repo = weaverepo.RepositoryFormat7().initialize(control)
-        self.assertEqual('topological', repo._format._fetch_order)
-
-    def test_attribute__fetch_uses_deltas(self):
-        """Weaves do not reuse deltas."""
-        control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
-        repo = weaverepo.RepositoryFormat7().initialize(control)
-        self.assertEqual(False, repo._format._fetch_uses_deltas)
-
-    def test_attribute__fetch_reconcile(self):
-        """Weave repositories need a reconcile after fetch."""
-        control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
-        repo = weaverepo.RepositoryFormat7().initialize(control)
-        self.assertEqual(True, repo._format._fetch_reconcile)
-
-    def test_disk_layout(self):
-        control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
-        repo = weaverepo.RepositoryFormat7().initialize(control)
-        # in case of side effects of locking.
-        repo.lock_write()
-        repo.unlock()
-        # we want:
-        # format 'Bazaar-NG Repository format 7'
-        # lock ''
-        # inventory.weave == empty_weave
-        # empty revision-store directory
-        # empty weaves directory
-        t = control.get_repository_transport(None)
-        self.assertEqualDiff('Bazaar-NG Repository format 7',
-                             t.get('format').read())
-        self.assertTrue(S_ISDIR(t.stat('revision-store').st_mode))
-        self.assertTrue(S_ISDIR(t.stat('weaves').st_mode))
-        self.assertEqualDiff('# bzr weave file v5\n'
-                             'w\n'
-                             'W\n',
-                             t.get('inventory.weave').read())
-        # Creating a file with id Foo:Bar results in a non-escaped file name on
-        # disk.
-        control.create_branch()
-        tree = control.create_workingtree()
-        tree.add(['foo'], ['Foo:Bar'], ['file'])
-        tree.put_file_bytes_non_atomic('Foo:Bar', 'content\n')
-        try:
-            tree.commit('first post', rev_id='first')
-        except errors.IllegalPath:
-            if sys.platform != 'win32':
-                raise
-            self.knownFailure('Foo:Bar cannot be used as a file-id on windows'
-                              ' in repo format 7')
-            return
-        self.assertEqualDiff(
-            '# bzr weave file v5\n'
-            'i\n'
-            '1 7fe70820e08a1aac0ef224d9c66ab66831cc4ab1\n'
-            'n first\n'
-            '\n'
-            'w\n'
-            '{ 0\n'
-            '. content\n'
-            '}\n'
-            'W\n',
-            t.get('weaves/74/Foo%3ABar.weave').read())
-
-    def test_shared_disk_layout(self):
-        control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
-        repo = weaverepo.RepositoryFormat7().initialize(control, shared=True)
-        # we want:
-        # format 'Bazaar-NG Repository format 7'
-        # inventory.weave == empty_weave
-        # empty revision-store directory
-        # empty weaves directory
-        # a 'shared-storage' marker file.
-        # lock is not present when unlocked
-        t = control.get_repository_transport(None)
-        self.assertEqualDiff('Bazaar-NG Repository format 7',
-                             t.get('format').read())
-        self.assertEqualDiff('', t.get('shared-storage').read())
-        self.assertTrue(S_ISDIR(t.stat('revision-store').st_mode))
-        self.assertTrue(S_ISDIR(t.stat('weaves').st_mode))
-        self.assertEqualDiff('# bzr weave file v5\n'
-                             'w\n'
-                             'W\n',
-                             t.get('inventory.weave').read())
-        self.assertFalse(t.has('branch-lock'))
-
-    def test_creates_lockdir(self):
-        """Make sure it appears to be controlled by a LockDir existence"""
-        control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
-        repo = weaverepo.RepositoryFormat7().initialize(control, shared=True)
-        t = control.get_repository_transport(None)
-        # TODO: Should check there is a 'lock' toplevel directory,
-        # regardless of contents
-        self.assertFalse(t.has('lock/held/info'))
-        repo.lock_write()
-        try:
-            self.assertTrue(t.has('lock/held/info'))
-        finally:
-            # unlock so we don't get a warning about failing to do so
-            repo.unlock()
-
-    def test_uses_lockdir(self):
-        """repo format 7 actually locks on lockdir"""
-        base_url = self.get_url()
-        control = bzrdir.BzrDirMetaFormat1().initialize(base_url)
-        repo = weaverepo.RepositoryFormat7().initialize(control, shared=True)
-        t = control.get_repository_transport(None)
-        repo.lock_write()
-        repo.unlock()
-        del repo
-        # make sure the same lock is created by opening it
-        repo = repository.Repository.open(base_url)
-        repo.lock_write()
-        self.assertTrue(t.has('lock/held/info'))
-        repo.unlock()
-        self.assertFalse(t.has('lock/held/info'))
-
-    def test_shared_no_tree_disk_layout(self):
-        control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
-        repo = weaverepo.RepositoryFormat7().initialize(control, shared=True)
-        repo.set_make_working_trees(False)
-        # we want:
-        # format 'Bazaar-NG Repository format 7'
-        # lock ''
-        # inventory.weave == empty_weave
-        # empty revision-store directory
-        # empty weaves directory
-        # a 'shared-storage' marker file.
-        t = control.get_repository_transport(None)
-        self.assertEqualDiff('Bazaar-NG Repository format 7',
-                             t.get('format').read())
-        ## self.assertEqualDiff('', t.get('lock').read())
-        self.assertEqualDiff('', t.get('shared-storage').read())
-        self.assertEqualDiff('', t.get('no-working-trees').read())
-        repo.set_make_working_trees(True)
-        self.assertFalse(t.has('no-working-trees'))
-        self.assertTrue(S_ISDIR(t.stat('revision-store').st_mode))
-        self.assertTrue(S_ISDIR(t.stat('weaves').st_mode))
-        self.assertEqualDiff('# bzr weave file v5\n'
-                             'w\n'
-                             'W\n',
-                             t.get('inventory.weave').read())
-
-    def test_supports_external_lookups(self):
-        control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
-        repo = weaverepo.RepositoryFormat7().initialize(control)
-        self.assertFalse(repo._format.supports_external_lookups)
-
-
 class TestFormatKnit1(TestCaseWithTransport):
 
     def test_attribute__fetch_order(self):
@@ -619,35 +428,17 @@
         self.assertGetsDefaultInterRepository(dummy_a, dummy_b)
 
 
-class TestInterWeaveRepo(TestCaseWithTransport):
-
-    def test_is_compatible_and_registered(self):
-        # InterWeaveRepo is compatible when either side
-        # is a format 5/6/7 branch
-        from bzrlib.repofmt import knitrepo, weaverepo
-        formats = [weaverepo.RepositoryFormat5(),
-                   weaverepo.RepositoryFormat6(),
-                   weaverepo.RepositoryFormat7()]
-        incompatible_formats = [weaverepo.RepositoryFormat4(),
-                                knitrepo.RepositoryFormatKnit1(),
-                                ]
-        repo_a = self.make_repository('a')
-        repo_b = self.make_repository('b')
-        is_compatible = weaverepo.InterWeaveRepo.is_compatible
-        for source in incompatible_formats:
-            # force incompatible left then right
-            repo_a._format = source
-            repo_b._format = formats[0]
-            self.assertFalse(is_compatible(repo_a, repo_b))
-            self.assertFalse(is_compatible(repo_b, repo_a))
-        for source in formats:
-            repo_a._format = source
-            for target in formats:
-                repo_b._format = target
-                self.assertTrue(is_compatible(repo_a, repo_b))
-        self.assertEqual(weaverepo.InterWeaveRepo,
-                         repository.InterRepository.get(repo_a,
-                                                        repo_b).__class__)
+
+class TestRepositoryFormat1(knitrepo.RepositoryFormatKnit1):
+
+    def get_format_string(self):
+        return "Test Format 1"
+
+
+class TestRepositoryFormat2(knitrepo.RepositoryFormatKnit1):
+
+    def get_format_string(self):
+        return "Test Format 2"
 
 
 class TestRepositoryFormat1(knitrepo.RepositoryFormatKnit1):

=== modified file 'bzrlib/tests/test_serializer.py'
--- bzrlib/tests/test_serializer.py	2009-06-10 03:56:49 +0000
+++ bzrlib/tests/test_serializer.py	2011-03-09 01:37:04 +0000
@@ -21,7 +21,6 @@
 from bzrlib import (
     chk_serializer,
     serializer,
-    xml4,
     xml5,
     xml6,
     xml7,
@@ -34,8 +33,6 @@
     """Test serializer"""
 
     def test_registry(self):
-        self.assertIs(xml4.serializer_v4,
-                      serializer.format_registry.get('4'))
         self.assertIs(xml5.serializer_v5,
                       serializer.format_registry.get('5'))
         self.assertIs(xml6.serializer_v6,

=== modified file 'bzrlib/tests/test_sftp_transport.py'
--- bzrlib/tests/test_sftp_transport.py	2011-01-12 01:01:53 +0000
+++ bzrlib/tests/test_sftp_transport.py	2011-03-09 01:37:04 +0000
@@ -189,20 +189,6 @@
 class SFTPBranchTest(TestCaseWithSFTPServer):
     """Test some stuff when accessing a bzr Branch over sftp"""
 
-    def test_lock_file(self):
-        # old format branches use a special lock file on sftp.
-        b = self.make_branch('', format=bzrdir.BzrDirFormat6())
-        b = bzrlib.branch.Branch.open(self.get_url())
-        self.failUnlessExists('.bzr/')
-        self.failUnlessExists('.bzr/branch-format')
-        self.failUnlessExists('.bzr/branch-lock')
-
-        self.failIf(lexists('.bzr/branch-lock.write-lock'))
-        b.lock_write()
-        self.failUnlessExists('.bzr/branch-lock.write-lock')
-        b.unlock()
-        self.failIf(lexists('.bzr/branch-lock.write-lock'))
-
     def test_push_support(self):
         self.build_tree(['a/', 'a/foo'])
         t = bzrdir.BzrDir.create_standalone_workingtree('a')

=== modified file 'bzrlib/tests/test_upgrade.py'
--- bzrlib/tests/test_upgrade.py	2011-01-10 22:20:12 +0000
+++ bzrlib/tests/test_upgrade.py	2011-03-09 01:37:04 +0000
@@ -35,130 +35,6 @@
 
 class TestUpgrade(tests.TestCaseWithTransport):
 
-    def test_upgrade_simple(self):
-        """Upgrade simple v0.0.4 format to latest format"""
-        eq = self.assertEquals
-        self.build_tree_contents(_upgrade1_template)
-        upgrade.upgrade(u'.')
-        control = bzrdir.BzrDir.open('.')
-        b = control.open_branch()
-        # tsk, peeking under the covers.
-        self.failUnless(
-            isinstance(
-                control._format,
-                bzrdir.BzrDirFormat.get_default_format().__class__))
-        rh = b.revision_history()
-        eq(rh,
-           ['[e-mail]-20051004035611-176b16534b086b3c',
-            '[e-mail]-20051004035756-235f2b7dcdddd8dd'])
-        rt = b.repository.revision_tree(rh[0])
-        foo_id = 'foo-20051004035605-91e788d1875603ae'
-        rt.lock_read()
-        try:
-            eq(rt.get_file_text(foo_id), 'initial contents\n')
-        finally:
-            rt.unlock()
-        rt = b.repository.revision_tree(rh[1])
-        rt.lock_read()
-        try:
-            eq(rt.get_file_text(foo_id), 'new contents\n')
-        finally:
-            rt.unlock()
-        # check a backup was made:
-        backup_dir = 'backup.bzr.~1~'
-        t = self.get_transport('.')
-        t.stat(backup_dir)
-        t.stat(backup_dir + '/README')
-        t.stat(backup_dir + '/branch-format')
-        t.stat(backup_dir + '/revision-history')
-        t.stat(backup_dir + '/merged-patches')
-        t.stat(backup_dir + '/pending-merged-patches')
-        t.stat(backup_dir + '/pending-merges')
-        t.stat(backup_dir + '/branch-name')
-        t.stat(backup_dir + '/branch-lock')
-        t.stat(backup_dir + '/inventory')
-        t.stat(backup_dir + '/stat-cache')
-        t.stat(backup_dir + '/text-store')
-        t.stat(backup_dir + '/text-store/foo-20051004035611-1591048e9dc7c2d4.gz')
-        t.stat(backup_dir + '/text-store/foo-20051004035756-4081373d897c3453.gz')
-        t.stat(backup_dir + '/inventory-store/')
-        t.stat(backup_dir + '/inventory-store/[e-mail]')
-        t.stat(backup_dir + '/inventory-store/[e-mail]')
-        t.stat(backup_dir + '/revision-store/')
-        t.stat(backup_dir + '/revision-store/[e-mail]')
-        t.stat(backup_dir + '/revision-store/[e-mail]')
-
-    def test_upgrade_with_ghosts(self):
-        """Upgrade v0.0.4 tree containing ghost references.
-
-        That is, some of the parents of revisions mentioned in the branch
-        aren't present in the branch's storage.
-
-        This shouldn't normally happen in branches created entirely in
-        bzr, but can happen in branches imported from baz and arch, or from
-        other systems, where the importer knows about a revision but not
-        its contents."""
-        eq = self.assertEquals
-        self.build_tree_contents(_ghost_template)
-        upgrade.upgrade(u'.')
-        b = branch.Branch.open(u'.')
-        revision_id = b.revision_history()[1]
-        rev = b.repository.get_revision(revision_id)
-        eq(len(rev.parent_ids), 2)
-        eq(rev.parent_ids[1], 'wibble@wobble-2')
-
-    def test_upgrade_makes_dir_weaves(self):
-        self.build_tree_contents(_upgrade_dir_template)
-        old_repodir = bzrdir.BzrDir.open_unsupported('.')
-        old_repo_format = old_repodir.open_repository()._format
-        upgrade.upgrade('.')
-        # this is the path to the literal file. As format changes
-        # occur it needs to be updated. FIXME: ask the store for the
-        # path.
-        repo = repository.Repository.open('.')
-        # it should have changed the format
-        self.assertNotEqual(old_repo_format.__class__, repo._format.__class__)
-        # and we should be able to read the names for the file id
-        # 'dir-20051005095101-da1441ea3fa6917a'
-        repo.lock_read()
-        self.addCleanup(repo.unlock)
-        text_keys = repo.texts.keys()
-        dir_keys = [key for key in text_keys if key[0] ==
-                'dir-20051005095101-da1441ea3fa6917a']
-        self.assertNotEqual([], dir_keys)
-
-    def test_upgrade_to_meta_sets_workingtree_last_revision(self):
-        self.build_tree_contents(_upgrade_dir_template)
-        upgrade.upgrade('.', bzrdir.BzrDirMetaFormat1())
-        tree = workingtree.WorkingTree.open('.')
-        self.assertEqual([tree.branch.revision_history()[-1]],
-            tree.get_parent_ids())
-
-    def test_upgrade_v6_to_meta_no_workingtree(self):
-        # Some format6 branches do not have checkout files. Upgrading
-        # such a branch to metadir must not setup a working tree.
-        self.build_tree_contents(_upgrade1_template)
-        upgrade.upgrade('.', bzrdir.BzrDirFormat6())
-        t = self.get_transport('.')
-        t.delete_multi(['.bzr/pending-merges', '.bzr/inventory'])
-        self.assertFalse(t.has('.bzr/stat-cache'))
-        # XXX: upgrade fails if a backup.bzr is already present
-        # -- David Allouche 2006-08-11
-        t.delete_tree('backup.bzr.~1~')
-        # At this point, we have a format6 branch without checkout files.
-        upgrade.upgrade('.', bzrdir.BzrDirMetaFormat1())
-        # The upgrade should not have set up a working tree.
-        control = bzrdir.BzrDir.open('.')
-        self.assertFalse(control.has_workingtree())
-        # We have covered the scope of this test, we may as well check that
-        # upgrade has not eaten our data, even if it's a bit redundant with
-        # other tests.
-        self.failUnless(isinstance(control._format, bzrdir.BzrDirMetaFormat1))
-        b = control.open_branch()
-        self.assertEquals(b.revision_history(),
-           ['[e-mail]-20051004035611-176b16534b086b3c',
-            '[e-mail]-20051004035756-235f2b7dcdddd8dd'])
-
     def test_upgrade_rich_root(self):
         tree = self.make_branch_and_tree('tree', format='rich-root')
         rev_id = tree.commit('first post')
@@ -254,169 +130,6 @@
             self.failIfExists('tree/.bzr/checkout/' + path)
 
 
-_upgrade1_template = \
-     [
-     ('foo', 'new contents\n'),
-     ('.bzr/',),
-     ('.bzr/README',
-      'This is a Bazaar control directory.\n'
-      'Do not change any files in this directory.\n'
-      'See http://bazaar.canonical.com/ for more information about Bazaar.\n'),
-     ('.bzr/branch-format', 'Bazaar-NG branch, format 0.0.4\n'),
-     ('.bzr/revision-history',
-      '[e-mail]-20051004035611-176b16534b086b3c\n'
-      '[e-mail]-20051004035756-235f2b7dcdddd8dd\n'),
-     ('.bzr/merged-patches', ''),
-     ('.bzr/pending-merged-patches', ''),
-     ('.bzr/branch-name', ''),
-     ('.bzr/branch-lock', ''),
-     ('.bzr/pending-merges', ''),
-     ('.bzr/inventory',
-      '<inventory>\n'
-      '<entry file_id="foo-20051004035605-91e788d1875603ae" kind="file" name="foo" />\n'
-      '</inventory>\n'),
-     ('.bzr/stat-cache',
-      '### bzr hashcache v5\n'
-      'foo// be9f309239729f69a6309e970ef24941d31e042c 13 1128398176 1128398176 303464 770\n'),
-     ('.bzr/text-store/',),
-     ('.bzr/text-store/foo-20051004035611-1591048e9dc7c2d4.gz',
-      '\x1f\x8b\x08\x00[\xfdAC\x02\xff\xcb\xcc\xcb,\xc9L\xccQH\xce\xcf+I\xcd+)\xe6\x02\x00\xdd\xcc\xf90\x11\x00\x00\x00'),
-     ('.bzr/text-store/foo-20051004035756-4081373d897c3453.gz',
-      '\x1f\x8b\x08\x00\xc4\xfdAC\x02\xff\xcbK-WH\xce\xcf+I\xcd+)\xe6\x02\x00g\xc3\xdf\xc9\r\x00\x00\x00'),
-     ('.bzr/inventory-store/',),
-     ('.bzr/inventory-store/[e-mail]',
-      '\x1f\x8b\x08\x00[\xfdAC\x02\xffm\x8f\xcd\n\xc20\x10\x84\xef>E\xc8\xbdt7?M\x02\xad\xaf"\xa1\x99`P[\xa8E\xacOo\x14\x05\x0f\xdef\xe1\xfbv\x98\xbeL7L\xeb\xbcl\xfb]_\xc3\xb2\x89\\\xce8\x944\xc8<\xcf\x8d"\xb2LdH\xdb\x8el\x13\x18\xce\xfb\xc4\xde\xd5SGHq*\xd3\x0b\xad\x8e\x14S\xbc\xe0\xadI\xb1\xe2\xbe\xfe}\xc2\xdc\xb0\rL\xc6#\xa4\xd1\x8d*\x99\x0f}=F\x1e$8G\x9d\xa0\x02\xa1rP9\x01c`FV\xda1qg\x98"\x02}\xa5\xf2\xa8\x95\xec\xa4h\xeb\x80\xf6g\xcd\x13\xb3\x01\xcc\x98\xda\x00\x00\x00'),
-     ('.bzr/inventory-store/[e-mail]',
-      '\x1f\x8b\x08\x00\xc4\xfdAC\x02\xffm\x8f\xc1\n\xc20\x10D\xef~E\xc8\xbd\xb8\x9bM\x9a,\xb4\xfe\x8a\xc4f\x83Am\xa1\x16\xb1~\xbdQ\x14<x\x9b\x81y3LW\xc6\x9b\x8c\xcb4\xaf\xbbMW\xc5\xbc\xaa\\\xce\xb2/\xa9\xd7y\x9a\x1a\x03\xe0\x10\xc0\x02\xb9\x16\\\xc3(>\x84\x84\xc1WKQ\xb4:\x95\xf1\x15\xad\x8cVc\xbc\xc8\x1b\xd3j\x91\xfb\xf2\xaf\xa4r\x8d\x85\x80\xe4)\x05\xf6\x03YG\x9f\xf4\xf5\x18\xb1\xd7\x07\xe1L\xc0\x86\xd8\x1b\xce-\xc7\xb6:a\x0f\x92\x8de\x8b\x89P\xc0\x9a\xe1\x0b\x95G\x9d\xc4\xda\xb1\xad\x07\xb6?o\x9e\xb5\xff\xf0\xf9\xda\x00\x00\x00'),
-     ('.bzr/revision-store/',),
-     ('.bzr/revision-store/[e-mail]',
-      '\x1f\x8b\x08\x00[\xfdAC\x02\xff\x9d\x8eKj\xc30\x14E\xe7^\x85\xd0 \xb3$\xefI\xd1\x8f\xd8\xa6\x1b(t\x07E?\xbb\x82H\n\xb2\x1ahW\xdfB1\x14:\xeb\xf4r\xee\xbdgl\xf1\x91\xb6T\x0b\xf15\xe7\xd4{l\x13}\xb6\xad\xa7B^j\xbd\x91\xc3\xad_\xb3\xbb?m\xf5\xbd\xf9\xb8\xb4\xba\x9eJ\xec\x87\xb5_)I\xe5\x11K\xaf\xed\xe35\x85\x89\xfe\xa5\x8e\x0c@ \xc0\x05\xb8\x90\x88GT\xd2\xa1\x14\xfc\xe2@K\xc7\xfd\xef\x85\xed\xcd\xe2D\x95\x8d\x1a\xa47<\x02c2\xb0 \xbc\xd0\x8ay\xa3\xbcp\x8a\x83\x12A3\xb7XJv\xef\x7f_\xf7\x94\xe3\xd6m\xbeO\x14\x91in4*<\x812\x88\xc60\xfc\x01>k\x89\x13\xe5\x12\x00\xe8<\x8c\xdf\x8d\xcd\xaeq\xb6!\x90\xa5\xd6\xf1\xbc\x07\xc3x\xde\x85\xe6\xe1\x0b\xc8\x8a\x98\x03T\x01\x00\x00'),
-     ('.bzr/revision-store/[e-mail]',
-      '\x1f\x8b\x08\x00\xc4\xfdAC\x02\xff\x9d\x90Kj\x031\x0c\x86\xf79\xc5\xe0Ev\xe9\xc8o\x9b\xcc\x84^\xa0\xd0\x1b\x14\xbf&5d\xec`\xbb\x81\xf6\xf45\x84\xa4\x81\xaeZ\xa1\x85\x84^\xdf\xaf\xa9\x84K\xac1\xa7\xc1\xe5u\x8d\xad\x852\xa3\x17SZL\xc3k\xce\xa7a{j\xfb\xd5\x9e\x9fk\xfe(.,%\x1f\x9fRh\xdbc\xdb\xa3!\xa6KH-\x97\xcf\xb7\xe8g\xf4\xbbkG\x008\x06`@\xb9\xe4bG(_\x88\x95\xde\xf9n\xca\xfb\xc7\r\xf5\xdd\xe0\x19\xa9\x85)\x81\xf5"\xbd\x04j\xb8\x02b\xa8W\\\x0b\xc9\x14\xf4\xbc\xbb\xd7\xd6H4\xdc\xb8\xff}\xba\xc55\xd4f\xd6\xf3\x8c0&\x8ajE\xa4x\xe2@\xa5\xa6\x9a\xf3k\xc3WNaFT\x00\x00:l\xa6>Q\xcd1\x1cjp9\xf9;\xc34\xde\n\x9b\xe9lJWT{t\',a\xf9\x0b\xae\xc0x\x87\xa5\xb0Xp\xca,(a\xa9{\xd0{}\xd4\x12\x04(\xc5\xbb$\xc5$V\xceaI\x19\x01\xa2\x1dh\xed\x82d\x8c.\xccr@\xc3\xd8Q\xc6\x1f\xaa\xf1\xb6\xe8\xb0\xf9\x06QR\r\xf9\xfc\x01\x00\x00')]
-
-
-_ghost_template = [
-    ( './foo',
-        'hello\n'
-    ),
-    ( './.bzr/', ),
-    ( './.bzr/README',
-      'This is a Bazaar control directory.\n'
-      'Do not change any files in this directory.\n'
-      'See http://bazaar.canonical.com/ for more information about Bazaar.\n'
-    ),
-    ( './.bzr/branch-format',
-        'Bazaar-NG branch, format 0.0.4\n'
-    ),
-    ( './.bzr/branch-lock',
-        ''
-    ),
-    ( './.bzr/branch-name',
-        ''
-    ),
-    ( './.bzr/inventory',
-        '<inventory>\n'
-        '<entry file_id="foo-20051004104918-0379cb7c76354cde" kind="file" name="foo" />\n'
-        '</inventory>\n'
-    ),
-    ( './.bzr/merged-patches',
-        ''
-    ),
-    ( './.bzr/pending-merged-patches',
-        ''
-    ),
-    ( './.bzr/pending-merges',
-        ''
-    ),
-    ( './.bzr/revision-history',
-        '[e-mail]-20051004104921-a98be2278dd30b7b\n'
-        '[e-mail]-20051004104937-c9b7a7bfcc0bb22d\n'
-    ),
-    ( './.bzr/stat-cache',
-        '### bzr hashcache v5\n'
-        'foo// f572d396fae9206628714fb2ce00f72e94f2258f 6 1128422956 1128422956 306900 770\n'
-    ),
-    ( './.bzr/text-store/', ),
-    ( './.bzr/text-store/foo-20051004104921-8de8118a71be45ba.gz',
-        '\x1f\x8b\x08\x081^BC\x00\x03foo-20051004104921-8de8118a71be45ba\x00\xcbH\xcd\xc9\xc9\xe7\x02\x00 0:6\x06\x00\x00\x00'
-    ),
-    ( './.bzr/inventory-store/', ),
-    ( './.bzr/inventory-store/[e-mail]',
-        '\x1f\x8b\x08\x081^BC\x00\[e-mail]-20051004104921-a98be2278dd30b7b\x00m\x8f\xcb\n'
-        '\xc20\x10E\xf7~E\xc8\xbe83\xcd\x13\xaa\xbf"yL0\xa8-\xd4"\xd6\xaf7\x8a\x82\x0bw\xb38\xe7\xde;C\x1do<.\xd3\xbc\xee7C;\xe6U\x94z\xe6C\xcd;Y\xa6\xa9#\x00\x8d\x00\n'
-        'Ayt\x1d\xf4\xd6\xa7h\x935\xbdV)\xb3\x14\xa7:\xbe\xd0\xe6H1\x86\x0b\xbf5)\x16\xbe/\x7fC\x08;\x97\xd9!\xba`1\xb2\xd21|\xe8\xeb1`\xe3\xb5\xa5\xdc{S\x02{\x02c\xc8YT%Rb\x80b\x89\xbd*D\xda\x95\xafT\x1f\xad\xd2H\xb1m\xfb\xb7?\xcf<\x01W}\xb5\x8b\xd9\x00\x00\x00'
-    ),
-    ( './.bzr/inventory-store/[e-mail]',
-        '\x1f\x8b\x08\x08A^BC\x00\[e-mail]-20051004104937-c9b7a7bfcc0bb22d\x00m\x8f\xcb\n'
-        '\xc20\x10E\xf7~E\xc8\xbe83\xcd\x13\xaa\xbf"yL0\xa8-\xd4"\xd6\xaf7\x8a\x82\x0bw\xb38\xe7\xde;C\x1do<.\xd3\xbc\xee7C;\xe6U\x94z\xe6C\xcd;Y\xa6\xa9#\x00\x8d\x00\n'
-        'Ayt\x1d\xf4\xd6\xa7h\x935\xbdV)\xb3\x14\xa7:\xbe\xd0\xe6H1\x86\x0b\xbf5)\x16\xbe/\x7fC\x08;\x97\xd9!\xba`1\xb2\xd21|\xe8\xeb1`\xe3\xb5\xa5\xdc{S\x02{\x02c\xc8YT%Rb\x80b\x89\xbd*D\xda\x95\xafT\x1f\xad\xd2H\xb1m\xfb\xb7?\xcf<\x01W}\xb5\x8b\xd9\x00\x00\x00'
-    ),
-    ( './.bzr/revision-store/', ),
-    ( './.bzr/revision-store/[e-mail]',
-        '\x1f\x8b\x08\x081^BC\x00\[e-mail]-20051004104921-a98be2278dd30b7b\x00\x9d\x8eMj\xc30\x14\x84\xf7>\x85\xd0"\xbb$\xef\xc9\xb6,\x11\xdb\xf4\x02\x85\xde\xa0\xe8\xe7\xd9\x11\xc4R\x90\xd4@{\xfa\x06\x8a\xa1\xd0]\x97\x03\xdf\xcc|c\xa6G(!E\xe6\xd2\xb6\x85Z)O\xfc\xd5\xe4\x1a"{K\xe9\xc6\x0e\xb7z\xd9\xec\xfd\xa5\xa4\x8f\xech\xc9i=E\xaa\x87\xb5^8\x0b\xf1A\xb1\xa6\xfc\xf9\x1e\xfc\xc4\xffRG\x01\xd0#@\x87\xd0i\x81G\xa3\x95%!\x06\xe5}\x0bv\xb0\xbf\x17\xca\xd5\xe0\xc4-\xa0\xb1\x8b\xb6`\xc0I\xa4\xc5\xf4\x9el\xef\x95v [\x94\xcf\x8e\xd5\xcay\xe4l\xf7\xfe\xf7u\r'
-        '\x1b\x95j\xb6\xfb\xc4\x11\x85\xea\x84\xd0\x12O\x03t\x83D\xad\xc4\x0f\xf0\x95"M\xbc\x95\x00\xc0\xe7f|6\x8aYi^B.u<\xef\xb1\x19\xcf\xbb\xce\xdc|\x038=\xc7\xe6R\x01\x00\x00'
-    ),
-    ( './.bzr/revision-store/[e-mail]',
-        '\x1f\x8b\x08\x08A^BC\x00\[e-mail]-20051004104937-c9b7a7bfcc0bb22d\x00\x9d\x90\xc1j\xc30\x0c\x86\xef}\n'
-        "\xe3Coie'\xb1c\x9a\x94\xbe\xc0`o0,[N\x03M\\\x1c\xafe{\xfae\x94n\x85\xc1`;Y\x88O\xd2\xff\xb9Mt\x19\xe6!N\xcc\xc5q\x1cr\xa6\xd4\xf1'\x9b\xf20\xb1\xe7\x18Ol}\xca\xbb\x11\xcf\x879\xbe&G!\xc5~3Q^\xf7y\xc7\xd90]h\xca1\xbd\xbd\x0c\xbe\xe3?\xa9B\x02\xd4\x02\xa0\x12P\x99R\x17\xce\xa0\xb6\x1a\x83s\x80(\xa5\x7f\xdc0\x1f\xad\xe88\x82\xb0\x18\x0c\x82\x05\xa7\x04\x05[{\xc2\xda7\xc6\x81*\x85B\x8dh\x1a\xe7\x05g\xf7\xdc\xff>\x9d\x87\x91\xe6l\xc7s\xc7\x85\x90M%\xa5\xd1z#\x85\xa8\x9b\x1a\xaa\xfa\x06\xbc\xc7\x89:^*\x00\xe0\xfbU\xbbL\xcc\xb6\xa7\xfdH\xa9'\x16\x03\xeb\x8fq\xce\xed\xf6\xde_\xb5g\x9b\x16\xa1y\xa9\xbe\x02&\n"
-        '\x7fJ+EaM\x83$\xa5n\xbc/a\x91~\xd0\xbd\xfd\x135\n'
-        '\xd0\x9a`\x0c*W\x1aR\xc1\x94du\x08(\t\xb0\x91\xdeZ\xa3\x9cU\x9cm\x7f\x8dr\x1d\x10Ot\xb8\xc6\xcf\xa7\x907|\xfb-\xb1\xbd\xd3\xfb\xd5\x07\xeeD\xee\x08*\x02\x00\x00'
-    ),
-]
-
-_upgrade_dir_template = [
-    ( './.bzr/', ),
-    ( './.bzr/README',
-      'This is a Bazaar control directory.\n'
-      'Do not change any files in this directory.\n'
-      'See http://bazaar.canonical.com/ for more information about Bazaar.\n'
-    ),
-    ( './.bzr/branch-format',
-        'Bazaar-NG branch, format 0.0.4\n'
-    ),
-    ( './.bzr/branch-lock',
-        ''
-    ),
-    ( './.bzr/branch-name',
-        ''
-    ),
-    ( './.bzr/inventory',
-        '<inventory>\n'
-        '<entry file_id="dir-20051005095101-da1441ea3fa6917a" kind="directory" name="dir" />\n'
-        '</inventory>\n'
-    ),
-    ( './.bzr/merged-patches',
-        ''
-    ),
-    ( './.bzr/pending-merged-patches',
-        ''
-    ),
-    ( './.bzr/pending-merges',
-        ''
-    ),
-    ( './.bzr/revision-history',
-        '[e-mail]-20051005095108-6065fbd8e7d8617e\n'
-    ),
-    ( './.bzr/stat-cache',
-        '### bzr hashcache v5\n'
-    ),
-    ( './.bzr/text-store/', ),
-    ( './.bzr/inventory-store/', ),
-    ( './.bzr/inventory-store/[e-mail]',
-        '\x1f\x8b\x08\x00\x0c\xa2CC\x02\xff\xb3\xc9\xcc+K\xcd+\xc9/\xaa\xb4\xe3\xb2\x012\x8a*\x15\xd22sR\xe33Sl\x95R2\x8bt\x8d\x0c\x0cL\r'
-        "\x81\xd8\xc0\x12H\x19\xea\xa6$\x1a\x9a\x98\x18\xa6&\x1a\xa7%\x9aY\x1a\x9a'*)dg\xe6A\x94\xa6&\x83LQR\xc8K\xccM\x05\x0b()\xe8\x03\xcd\xd4G\xb2\x00\x00\xc2<\x94\xb1m\x00\x00\x00"
-    ),
-    ( './.bzr/revision-store/', ),
-    ( './.bzr/revision-store/[e-mail]',
-        '\x1f\x8b\x08\x00\x0c\xa2CC\x02\xff\xa5OKj\xc30\x14\xdc\xfb\x14B\x8b\xec\x92<I\xd6\xc7\xc42\x85\xde\xa0\x17(\xb6\xf4\x9c\n'
-        'l\xa9H"\x90\x9c\xbe\xa6\xa9\xa1\x9b\xae\xbax\x0c\xcc\xe71\xd3g\xbc\x85\x12R$.\xadk\xa8\x15\xb3\xa5oi\xc2\\\xc9kZ\x96\x10\x0b9,\xf5\x92\xbf)\xf7\xf2\x83O\xe5\x14\xb1\x1e\xae\xf5BI\x887\x8c5\xe5\xfb{\xf0\x96\xfei>r\x00\xc9\xb6\x83n\x03sT\xa0\xe4<y\x83\xda\x1b\xc54\xfe~T>Ff\xe9\xcc:\xdd\x8e\xa6E\xc7@\xa2\x82I\xaaNL\xbas\\313)\x00\xb9\xe6\xe0(\xd9\x87\xfc\xb7A\r'
-        "+\x96:\xae\x9f\x962\xc6\x8d\x04i\x949\x01\x97R\xb7\x1d\x17O\xc3#E\xb4T(\x00\xa0C\xd3o\x892^q\x18\xbd'>\xe4\xfe\xbc\x13M\x7f\xde{\r"
-        '\xcd\x17\x85\xea\xba\x03l\x01\x00\x00'
-    ),
-    ( './dir/', ),
-]
-
-
 class TestSmartUpgrade(tests.TestCaseWithTransport):
 
     from_format = bzrdir.format_registry.make_bzrdir("pack-0.92")

=== modified file 'bzrlib/tests/test_xml.py'
--- bzrlib/tests/test_xml.py	2011-02-21 19:58:27 +0000
+++ bzrlib/tests/test_xml.py	2011-03-09 01:37:04 +0000
@@ -26,31 +26,8 @@
     )
 from bzrlib.tests import TestCase
 from bzrlib.inventory import Inventory
-from bzrlib.xml4 import serializer_v4
 import bzrlib.xml5
 
-_working_inventory_v4 = """<inventory file_id="TREE_ROOT">
-<entry file_id="bar-20050901064931-73b4b1138abc9cd2" kind="file" name="bar" parent_id="TREE_ROOT" />
-<entry file_id="foo-20050801201819-4139aa4a272f4250" kind="directory" name="foo" parent_id="TREE_ROOT" />
-<entry file_id="bar-20050824000535-6bc48cfad47ed134" kind="file" name="bar" parent_id="foo-20050801201819-4139aa4a272f4250" />
-</inventory>"""
-
-
-_revision_v4 = """<revision committer="Martin Pool &lt;[e-mail]&gt;"
-    inventory_id="[e-mail]-20050905080035-e0439293f8b6b9f9"
-    inventory_sha1="e79c31c1deb64c163cf660fdedd476dd579ffd41"
-    revision_id="[e-mail]-20050905080035-e0439293f8b6b9f9"
-    timestamp="1125907235.212"
-    timezone="36000">
-<message>- start splitting code for xml (de)serialization away from objects
-  preparatory to supporting multiple formats by a single library
-</message>
-<parents>
-<revision_ref revision_id="[e-mail]-20050905063503-43948f59fa127d92" revision_sha1="7bdf4cc8c5bdac739f8cf9b10b78cf4b68f915ff" />
-</parents>
-</revision>
-"""
-
 _revision_v5 = """<revision committer="Martin Pool &lt;[e-mail]&gt;"
     inventory_sha1="e79c31c1deb64c163cf660fdedd476dd579ffd41"
     revision_id="[e-mail]-20050905080035-e0439293f8b6b9f9"
@@ -217,26 +194,6 @@
 class TestSerializer(TestCase):
     """Test XML serialization"""
 
-    def test_canned_inventory(self):
-        """Test unpacked a canned inventory v4 file."""
-        inp = StringIO(_working_inventory_v4)
-        inv = serializer_v4.read_inventory(inp)
-        self.assertEqual(len(inv), 4)
-        self.assert_('bar-20050901064931-73b4b1138abc9cd2' in inv)
-
-    def test_unpack_revision(self):
-        """Test unpacking a canned revision v4"""
-        inp = StringIO(_revision_v4)
-        rev = serializer_v4.read_revision(inp)
-        eq = self.assertEqual
-        eq(rev.committer,
-           "Martin Pool <[e-mail]>")
-        eq(rev.inventory_id,
-           "[e-mail]-20050905080035-e0439293f8b6b9f9")
-        eq(len(rev.parent_ids), 1)
-        eq(rev.parent_ids[0],
-           "[e-mail]-20050905063503-43948f59fa127d92")
-
     def test_unpack_revision_5(self):
         """Test unpacking a canned revision v5"""
         inp = StringIO(_revision_v5)

=== modified file 'bzrlib/workingtree.py'
--- bzrlib/workingtree.py	2011-03-06 18:10:47 +0000
+++ bzrlib/workingtree.py	2011-03-09 01:37:04 +0000
@@ -3067,8 +3067,3 @@
     "bzrlib.workingtree_4", "WorkingTreeFormat6")
 format_registry.register(WorkingTreeFormat3())
 format_registry.set_default(__default_format)
-# Register extra formats which have no format string are not discoverable
-# and not independently creatable. They are implicitly created as part of
-# e.g. older Bazaar formats or foreign formats.
-format_registry.register_extra_lazy("bzrlib.workingtree_2",
-    "WorkingTreeFormat2")