Merge lp:~jelmer/bzr/workingtree-format-registry into lp:bzr

[Jelmer Vernooij]

Add WorkingTreeFormatRegistry.

Add a WorkingTreeFormatRegistry, similar to RepositoryFormatRegistry and the BranchFormatRegistry I added in lp:~jelmer/bzr/branch-format-registry.

Among other things this makes it possible to lazily register working tree formats that can not be used in bzr meta directories. This is useful so non-metadir bzr formats and foreign formats can be tested.

I next plan to work on factoring out some of the common elements of these three format registries into a single base class.

[Vincent Ladeuil (vila)]

19 # this uses bzrlib.workingtree.WorkingTreeFormat4 because importing
20 # directly from workingtree_4 triggers a circular import.
21 - tree_format='bzrlib.workingtree.WorkingTreeFormat4',
22 + tree_format='bzrlib.workingtree_4.WorkingTreeFormat4',

The comment is now wrong because the import is lazy right ?

Please fix it and land.

review: Needs Fixing

[Jelmer Vernooij (jelmer)]

sent to pqm by email

=== modified file 'bzrlib/bzrdir.py'
--- bzrlib/bzrdir.py	2011-02-19 17:37:45 +0000
+++ bzrlib/bzrdir.py	2011-02-23 13:57:14 +0000
@@ -2119,8 +2119,10 @@
 
     def __get_workingtree_format(self):
         if self._workingtree_format is None:
-            from bzrlib.workingtree import WorkingTreeFormat
-            self._workingtree_format = WorkingTreeFormat.get_default_format()
+            from bzrlib.workingtree import (
+                format_registry as wt_format_registry,
+                )
+            self._workingtree_format = wt_format_registry.get_default()
         return self._workingtree_format
 
     def __set_workingtree_format(self, wt_format):

=== modified file 'bzrlib/tests/per_tree/__init__.py'
--- bzrlib/tests/per_tree/__init__.py	2011-02-04 18:12:44 +0000
+++ bzrlib/tests/per_tree/__init__.py	2011-02-23 13:57:14 +0000
@@ -38,7 +38,7 @@
 from bzrlib.revisiontree import RevisionTree
 from bzrlib.transform import TransformPreview
 from bzrlib.workingtree import (
-    WorkingTreeFormat,
+    format_registry,
     )
 from bzrlib.workingtree_4 import (
     DirStateRevisionTree,
@@ -332,7 +332,7 @@
         # for working tree format tests, preserve the tree
         scenario[1]["_workingtree_to_test_tree"] = return_parameter
     # add RevisionTree scenario
-    workingtree_format = WorkingTreeFormat._default_format
+    workingtree_format = format_registry.get_default()
     scenarios.append((RevisionTree.__name__,
         create_tree_scenario(transport_server, transport_readonly_server,
         workingtree_format, revision_tree_from_workingtree,)))
@@ -397,6 +397,6 @@
         # None here will cause a readonly decorator to be created
         # by the TestCaseWithTransport.get_readonly_transport method.
         None,
-        WorkingTreeFormat.get_formats())
+        format_registry._get_all())
     # add the tests for the sub modules
     return tests.multiply_tests(submod_tests, scenarios, standard_tests)

=== modified file 'bzrlib/tests/per_workingtree/__init__.py'
--- bzrlib/tests/per_workingtree/__init__.py	2011-02-04 18:12:44 +0000
+++ bzrlib/tests/per_workingtree/__init__.py	2011-02-23 13:57:14 +0000
@@ -120,7 +120,7 @@
         # None here will cause a readonly decorator to be created
         # by the TestCaseWithTransport.get_readonly_transport method.
         None,
-        workingtree.WorkingTreeFormat.get_formats()
+        workingtree.format_registry._get_all()
         )
 
     # add the tests for the sub modules

=== modified file 'bzrlib/tests/test_inv.py'
--- bzrlib/tests/test_inv.py	2011-02-04 18:12:44 +0000
+++ bzrlib/tests/test_inv.py	2011-02-23 13:57:14 +0000
@@ -24,6 +24,7 @@
     repository,
     revision,
     tests,
+    workingtree,
     )
 from bzrlib.inventory import (
     CHKInventory,
@@ -39,7 +40,6 @@
     TestCaseWithTransport,
     )
 from bzrlib.tests.scenarios import load_tests_apply_scenarios
-from bzrlib.workingtree import WorkingTreeFormat
 
 
 load_tests = load_tests_apply_scenarios
@@ -59,7 +59,7 @@
         scenarios.append((str(format.__name__), {
             'apply_delta':apply_inventory_Repository_add_inventory_by_delta,
             'format':format}))
-    for format in WorkingTreeFormat.get_formats():
+    for format in workingtree.format_registry._get_all():
         scenarios.append(
             (str(format.__class__.__name__) + ".update_basis_by_delta", {
             'apply_delta':apply_inventory_WT_basis,

=== modified file 'bzrlib/tests/test_selftest.py'
--- bzrlib/tests/test_selftest.py	2011-02-18 21:52:42 +0000
+++ bzrlib/tests/test_selftest.py	2011-02-23 13:57:14 +0000
@@ -379,7 +379,7 @@
                    workingtree.WorkingTreeFormat3(),]
         scenarios = make_scenarios(server1, server2, formats)
         self.assertEqual(7, len(scenarios))
-        default_wt_format = workingtree.WorkingTreeFormat4._default_format
+        default_wt_format = workingtree.format_registry.get_default()
         wt4_format = workingtree.WorkingTreeFormat4()
         wt5_format = workingtree.WorkingTreeFormat5()
         expected_scenarios = [

=== modified file 'bzrlib/tests/test_workingtree.py'
--- bzrlib/tests/test_workingtree.py	2011-02-04 18:18:19 +0000
+++ bzrlib/tests/test_workingtree.py	2011-02-23 13:57:14 +0000
@@ -21,6 +21,7 @@
     bzrdir,
     conflicts,
     errors,
+    symbol_versioning,
     transport,
     workingtree,
     )
@@ -62,10 +63,10 @@
 class TestDefaultFormat(TestCaseWithTransport):
 
     def test_get_set_default_format(self):
-        old_format = workingtree.WorkingTreeFormat.get_default_format()
+        old_format = workingtree.format_registry.get_default()
         # default is 3
         self.assertTrue(isinstance(old_format, workingtree.WorkingTreeFormat3))
-        workingtree.WorkingTreeFormat.set_default_format(SampleTreeFormat())
+        workingtree.format_registry.set_default(SampleTreeFormat())
         try:
             # the default branch format is used by the meta dir format
             # which is not the default bzrdir format at this point
@@ -75,8 +76,8 @@
             result = dir.create_workingtree()
             self.assertEqual(result, 'A tree')
         finally:
-            workingtree.WorkingTreeFormat.set_default_format(old_format)
-        self.assertEqual(old_format, workingtree.WorkingTreeFormat.get_default_format())
+            workingtree.format_registry.set_default(old_format)
+        self.assertEqual(old_format, workingtree.format_registry.get_default())
 
     def test_open(self):
         tree = self.make_branch_and_tree('.')
@@ -184,22 +185,55 @@
         # make a branch
         format.initialize(dir)
         # register a format for it.
-        workingtree.WorkingTreeFormat.register_format(format)
-        self.assertTrue(format in workingtree.WorkingTreeFormat.get_formats())
+        self.applyDeprecated(symbol_versioning.deprecated_in((2, 4, 0)),
+            workingtree.WorkingTreeFormat.register_format, format)
+        self.assertTrue(format in 
+            self.applyDeprecated(symbol_versioning.deprecated_in((2, 4, 0)),
+                workingtree.WorkingTreeFormat.get_formats))
         # which branch.Open will refuse (not supported)
         self.assertRaises(errors.UnsupportedFormatError, workingtree.WorkingTree.open, '.')
         # but open_downlevel will work
         self.assertEqual(format.open(dir), workingtree.WorkingTree.open_downlevel('.'))
         # unregister the format
-        workingtree.WorkingTreeFormat.unregister_format(format)
-        self.assertFalse(format in workingtree.WorkingTreeFormat.get_formats())
-
-    def test_register_unregister_extra_format(self):
+        self.applyDeprecated(symbol_versioning.deprecated_in((2, 4, 0)),
+            workingtree.WorkingTreeFormat.unregister_format, format)
+        self.assertFalse(format in
+            self.applyDeprecated(symbol_versioning.deprecated_in((2, 4, 0)),
+                workingtree.WorkingTreeFormat.get_formats))
+
+
+class TestWorkingTreeFormatRegistry(TestCase):
+
+    def setUp(self):
+        super(TestWorkingTreeFormatRegistry, self).setUp()
+        self.registry = workingtree.WorkingTreeFormatRegistry()
+
+    def test_register_unregister_format(self):
+        format = SampleTreeFormat()
+        self.registry.register(format)
+        self.assertEquals(format, self.registry.get("Sample tree format."))
+        self.registry.remove(format)
+        self.assertRaises(KeyError, self.registry.get, "Sample tree format.")
+
+    def test_get_all(self):
+        format = SampleTreeFormat()
+        self.assertEquals([], self.registry._get_all())
+        self.registry.register(format)
+        self.assertEquals([format], self.registry._get_all())
+
+    def test_register_extra(self):
         format = SampleExtraTreeFormat()
-        workingtree.WorkingTreeFormat.register_extra_format(format)
-        self.assertTrue(format in workingtree.WorkingTreeFormat.get_formats())
-        workingtree.WorkingTreeFormat.unregister_extra_format(format)
-        self.assertFalse(format in workingtree.WorkingTreeFormat.get_formats())
+        self.assertEquals([], self.registry._get_all())
+        self.registry.register_extra(format)
+        self.assertEquals([format], self.registry._get_all())
+
+    def test_register_extra_lazy(self):
+        self.assertEquals([], self.registry._get_all())
+        self.registry.register_extra_lazy("bzrlib.tests.test_workingtree",
+            "SampleExtraTreeFormat")
+        formats = self.registry._get_all()
+        self.assertEquals(1, len(formats))
+        self.assertIsInstance(formats[0], SampleExtraTreeFormat)
 
 
 class TestWorkingTreeFormat3(TestCaseWithTransport):

=== modified file 'bzrlib/workingtree.py'
--- bzrlib/workingtree.py	2011-02-11 17:58:56 +0000
+++ bzrlib/workingtree.py	2011-02-23 13:57:14 +0000
@@ -58,6 +58,7 @@
     ignores,
     inventory,
     merge,
+    registry,
     revision as _mod_revision,
     revisiontree,
     trace,
@@ -2858,6 +2859,67 @@
             return path[:-len(suffix)]
 
 
+class WorkingTreeFormatRegistry(registry.FormatRegistry):
+    """Registry for working tree formats."""
+
+    def __init__(self, other_registry=None):
+        super(WorkingTreeFormatRegistry, self).__init__(other_registry)
+        self._extra_formats = []
+        self._default_format = None
+
+    def register(self, format):
+        """Register a new repository format."""
+        super(WorkingTreeFormatRegistry, self).register(
+            format.get_format_string(), format)
+
+    def remove(self, format):
+        """Remove a registered repository format."""
+        super(WorkingTreeFormatRegistry, self).remove(format.get_format_string())
+
+    def register_extra(self, format):
+        """Register a repository format that can not be used in a metadir.
+
+        This is mainly useful to allow custom repository formats, such as older
+        Bazaar formats and foreign formats, to be tested.
+        """
+        self._extra_formats.append(registry._ObjectGetter(format))
+
+    def remove_extra(self, format):
+        """Remove an extra repository format.
+        """
+        self._extra_formats.remove(registry._ObjectGetter(format))
+
+    def register_extra_lazy(self, module_name, member_name):
+        """Register a repository format lazily.
+        """
+        self._extra_formats.append(
+            registry._LazyObjectGetter(module_name, member_name))
+
+    def get_default(self):
+        """Return the current default format."""
+        return self._default_format
+
+    def set_default(self, format):
+        self._default_format = format
+
+    def _get_extra(self):
+        result = []
+        for getter in self._extra_formats:
+            f = getter.get_obj()
+            if callable(f):
+                f = f()
+            result.append(f)
+        return result
+
+    def _get_all(self):
+        """Return all repository formats, even those not usable in metadirs.
+        """
+        return [self.get(k) for k in self.keys()] + self._get_extra()
+
+
+format_registry = WorkingTreeFormatRegistry()
+
+
 class WorkingTreeFormat(object):
     """An encapsulation of the initialization and open routines for a format.
 
@@ -2876,15 +2938,6 @@
     object will be created every time regardless.
     """
 
-    _default_format = None
-    """The default format used for new trees."""
-
-    _formats = {}
-    """The known formats."""
-
-    _extra_formats = []
-    """Extra formats that can not be used in a metadir."""
-
     requires_rich_root = False
 
     upgrade_recommended = False
@@ -2902,7 +2955,7 @@
         try:
             transport = a_bzrdir.get_workingtree_transport(None)
             format_string = transport.get_bytes("format")
-            return klass._formats[format_string]
+            return format_registry.get(format_string)
         except errors.NoSuchFile:
             raise errors.NoWorkingTree(base=transport.base)
         except KeyError:
@@ -2916,9 +2969,11 @@
         return not (self == other)
 
     @classmethod
+    @symbol_versioning.deprecated_method(
+        symbol_versioning.deprecated_in((2, 4, 0)))
     def get_default_format(klass):
         """Return the current default format."""
-        return klass._default_format
+        return format_registry.get_default()
 
     def get_format_string(self):
         """Return the ASCII format string that identifies this format."""
@@ -2946,28 +3001,40 @@
         return False
 
     @classmethod
+    @symbol_versioning.deprecated_method(
+        symbol_versioning.deprecated_in((2, 4, 0)))
     def register_format(klass, format):
-        klass._formats[format.get_format_string()] = format
+        format_registry.register(format)
 
     @classmethod
+    @symbol_versioning.deprecated_method(
+        symbol_versioning.deprecated_in((2, 4, 0)))
     def register_extra_format(klass, format):
-        klass._extra_formats.append(format)
+        format_registry.register_extra(format)
 
     @classmethod
+    @symbol_versioning.deprecated_method(
+        symbol_versioning.deprecated_in((2, 4, 0)))
     def unregister_extra_format(klass, format):
-        klass._extra_formats.remove(format)
+        format_registry.unregister_extra(format)
 
     @classmethod
+    @symbol_versioning.deprecated_method(
+        symbol_versioning.deprecated_in((2, 4, 0)))
     def get_formats(klass):
-        return klass._formats.values() + klass._extra_formats
+        return format_registry._get_all()
 
     @classmethod
+    @symbol_versioning.deprecated_method(
+        symbol_versioning.deprecated_in((2, 4, 0)))
     def set_default_format(klass, format):
-        klass._default_format = format
+        format_registry.set_default(format)
 
     @classmethod
+    @symbol_versioning.deprecated_method(
+        symbol_versioning.deprecated_in((2, 4, 0)))
     def unregister_format(klass, format):
-        del klass._formats[format.get_format_string()]
+        format_registry.remove(format)
 
 
 class WorkingTreeFormat2(WorkingTreeFormat):
@@ -3194,12 +3261,15 @@
 
 
 __default_format = WorkingTreeFormat6()
-WorkingTreeFormat.register_format(__default_format)
-WorkingTreeFormat.register_format(WorkingTreeFormat5())
-WorkingTreeFormat.register_format(WorkingTreeFormat4())
-WorkingTreeFormat.register_format(WorkingTreeFormat3())
-WorkingTreeFormat.set_default_format(__default_format)
+format_registry.register_lazy("Bazaar Working Tree Format 4 (bzr 0.15)\n",
+    "bzrlib.workingtree_4", "WorkingTreeFormat4")
+format_registry.register_lazy("Bazaar Working Tree Format 5 (bzr 1.11)\n",
+    "bzrlib.workingtree_4", "WorkingTreeFormat5")
+format_registry.register_lazy("Bazaar Working Tree Format 6 (bzr 1.14)\n",
+    "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.
-WorkingTreeFormat.register_extra_format(WorkingTreeFormat2())
+format_registry.register_extra(WorkingTreeFormat2())

=== modified file 'doc/en/release-notes/bzr-2.4.txt'
--- doc/en/release-notes/bzr-2.4.txt	2011-02-22 11:59:59 +0000
+++ doc/en/release-notes/bzr-2.4.txt	2011-02-23 13:57:14 +0000
@@ -140,6 +140,10 @@
   ``InterRepository.search_missing_revision_ids`` is deprecated.  It is
   replaced by the ``revision_ids`` parameter.  (Andrew Bennetts)
 
+* Working tree formats should now be registered on the format registry
+  (``bzrlib.working_tree.format_registry``) rather than using the class
+  methods on ``WorkingTreeFormat``. (Jelmer Vernooij, #714730)
+
 Internals
 *********