Rev 298: Add --scheme option to svn-import command. in http://people.samba.org/bzr/jelmer/bzr-svn/bzr.dev

[Jelmer Vernooij]

------------------------------------------------------------
revno: 298
revision-id: jelmer at samba.org-20061226004354-6ky4mphocf8qe6cp
parent: jelmer at samba.org-20061226002708-dpl9ryphuyi9i63v
committer: Jelmer Vernooij <jelmer at samba.org>
branch nick: main
timestamp: Tue 2006-12-26 01:43:54 +0100
message:
  Add --scheme option to svn-import command.
modified:
  __init__.py                    __init__.py-20051008155114-eae558e6cf149e1d
  scheme.py                      scheme.py-20060516195850-95181aae6b272f9e
  tests/test_scheme.py           test_scheme.py-20060621221855-va2xabhlxpmc9llx-1
=== modified file '__init__.py'
--- a/__init__.py	2006-12-19 21:23:21 +0000
+++ b/__init__.py	2006-12-26 00:43:54 +0000
@@ -103,14 +103,19 @@
     """
     takes_args = ['url', 'output_dir']
     takes_options = [Option('trees', help='Create working trees'),
-                     Option('shared', help='Create shared repository')]
+                     Option('shared', help='Create shared repository'),
+                     Option('scheme', help='Branching scheme (none, trunk, or trunk-INT)')]
 
     @display_command
-    def run(self, url, output_dir, trees=False, shared=False):
+    def run(self, url, output_dir, trees=False, shared=False, scheme="trunk"):
         from convert import convert_repository
-        from scheme import TrunkBranchingScheme
-        # TODO: support non-trunk branching schemes
-        convert_repository(url, output_dir, TrunkBranchingScheme(), shared, 
+        from scheme import BranchingScheme
+
+        scheme_ = BranchingScheme.find_scheme(scheme)
+        if scheme_ is None:
+            raise BzrError('No such branching scheme %r' % scheme)
+
+        convert_repository(url, output_dir, scheme_, shared, 
                            trees)
 
 

=== modified file 'scheme.py'
--- a/scheme.py	2006-07-30 11:56:36 +0000
+++ b/scheme.py	2006-12-26 00:43:54 +0000
@@ -51,6 +51,22 @@
                 return TrunkBranchingScheme(level=i)
 
         return NoBranchingScheme()
+
+    @staticmethod
+    def find_scheme(name):
+        if name == "trunk":
+            return TrunkBranchingScheme()
+
+        if name.startswith("trunk-"):
+            try:
+                return TrunkBranchingScheme(level=int(name[len("trunk-"):]))
+            except ValueError:
+                return None
+
+        if name == "none":
+            return NoBranchingScheme()
+
+        return None
                 
 
 class TrunkBranchingScheme:

=== modified file 'tests/test_scheme.py'
--- a/tests/test_scheme.py	2006-07-30 11:56:36 +0000
+++ b/tests/test_scheme.py	2006-12-26 00:43:54 +0000
@@ -20,29 +20,67 @@
 from scheme import (ListBranchingScheme, NoBranchingScheme, 
                     BranchingScheme, TrunkBranchingScheme)
 
-class NoScheme(TestCase):
-    def test_is_branch(self):
-        scheme = NoBranchingScheme()
-        self.assertTrue(scheme.is_branch(""))
-        self.assertTrue(scheme.is_branch("/"))
-        self.assertFalse(scheme.is_branch("/foo"))
-        self.assertFalse(scheme.is_branch("/foo/foo"))
-        self.assertFalse(scheme.is_branch("foo/bar"))
-        self.assertFalse(scheme.is_branch("//foo/bar"))
-
-    def test_unprefix(self):
-        scheme = NoBranchingScheme()
-        self.assertEqual(scheme.unprefix(""), ("", ""))
-        self.assertEqual(scheme.unprefix("/"), ("", ""))
-        self.assertEqual(scheme.unprefix("foo/foo"), ("", "foo/foo"))
-        self.assertEqual(scheme.unprefix("/foo/foo"), ("", "foo/foo"))
-
-    def test_guess(self):
+class BranchingSchemeTest(TestCase):
+    def test_guess_empty(self):
         self.assertIsInstance(BranchingScheme.guess_scheme(""), 
                               NoBranchingScheme)
+
+    def test_guess_not_convenience(self):
         self.assertIsInstance(BranchingScheme.guess_scheme("foo"), 
                               NoBranchingScheme)
 
+    def test_find_scheme_no(self):
+        self.assertIsInstance(BranchingScheme.find_scheme("none"),
+                              NoBranchingScheme)
+
+    def test_find_scheme_invalid(self):
+        self.assertIs(None, BranchingScheme.find_scheme("foo"))
+
+    def test_find_scheme_trunk(self):
+        scheme = BranchingScheme.find_scheme("trunk")
+        self.assertIsInstance(scheme, TrunkBranchingScheme)
+        self.assertEqual(0, scheme.level)
+
+    def test_find_scheme_trunk_0(self):
+        scheme = BranchingScheme.find_scheme("trunk-0")
+        self.assertIsInstance(scheme, TrunkBranchingScheme)
+        self.assertEqual(0, scheme.level)
+
+    def test_find_scheme_trunk_2(self):
+        scheme = BranchingScheme.find_scheme("trunk-2")
+        self.assertIsInstance(scheme, TrunkBranchingScheme)
+        self.assertEqual(2, scheme.level)
+
+    def test_find_scheme_trunk_invalid(self):
+        scheme = BranchingScheme.find_scheme("trunk-invalid")
+        self.assertIs(None, scheme)
+
+
+class NoScheme(TestCase):
+    def test_is_branch_empty(self):
+        self.assertTrue(NoBranchingScheme().is_branch(""))
+
+    def test_is_branch_slash(self):
+        self.assertTrue(NoBranchingScheme().is_branch("/"))
+
+    def test_is_branch_dir_slash(self):
+        self.assertFalse(NoBranchingScheme().is_branch("/foo"))
+
+    def test_is_branch_dir_slash_nested(self):
+        self.assertFalse(NoBranchingScheme().is_branch("/foo/foo"))
+
+    def test_is_branch_dir(self):
+        self.assertFalse(NoBranchingScheme().is_branch("foo/bar"))
+
+    def test_is_branch_dir_doubleslash(self):
+        self.assertFalse(NoBranchingScheme().is_branch("//foo/bar"))
+
+    def test_unprefix(self):
+        self.assertEqual(NoBranchingScheme().unprefix(""), ("", ""))
+        self.assertEqual(NoBranchingScheme().unprefix("/"), ("", ""))
+        self.assertEqual(NoBranchingScheme().unprefix("foo/foo"), ("", "foo/foo"))
+        self.assertEqual(NoBranchingScheme().unprefix("/foo/foo"), ("", "foo/foo"))
+
 class ListScheme(TestCase):
     def test_is_branch(self):
         scheme = ListBranchingScheme(["foo", "bar/bloe"])
@@ -121,17 +159,17 @@
     def test_guess(self):
         scheme = BranchingScheme.guess_scheme("trunk") 
         self.assertIsInstance(scheme, TrunkBranchingScheme)
-        self.assertEqual(scheme.level, 0)
+        self.assertEqual(0, scheme.level)
         scheme = BranchingScheme.guess_scheme("branches/foo/bar")
         self.assertIsInstance(scheme, TrunkBranchingScheme)
-        self.assertEqual(scheme.level, 0)
+        self.assertEqual(0, scheme.level)
         scheme = BranchingScheme.guess_scheme("test/branches/foo/bar")
         self.assertIsInstance(scheme, TrunkBranchingScheme)
-        self.assertEqual(scheme.level, 1)
+        self.assertEqual(1, scheme.level)
         scheme = BranchingScheme.guess_scheme("test/bar/branches/foo/bar")
         self.assertIsInstance(scheme, TrunkBranchingScheme)
-        self.assertEqual(scheme.level, 2)
+        self.assertEqual(2, scheme.level)
         scheme = BranchingScheme.guess_scheme("branches/trunk")
         self.assertIsInstance(scheme, TrunkBranchingScheme)
-        self.assertEqual(scheme.level, 0)
+        self.assertEqual(0, scheme.level)