Merge lp:~jelmer/brz/clone into lp:brz/3.1

[Jelmer Vernooij]

Add a 'brz clone' command.

Add a 'brz clone' command.

[Jelmer Vernooij (jelmer)]

review: Approve

[The Breezy Bot (the-breezy-bot)]

Running landing tests failed
https://ci.breezy-vcs.org/job/brz-3.1/job/brz-3.1-land/4/

[The Breezy Bot (the-breezy-bot)]

Running landing tests failed
https://ci.breezy-vcs.org/job/brz-3.1/job/brz-3.1-land/5/

[The Breezy Bot (the-breezy-bot)]

Running landing tests failed
https://ci.breezy-vcs.org/job/brz-3.1/job/brz-3.1-land/36/

[The Breezy Bot (the-breezy-bot)]

Running landing tests failed
https://ci.breezy-vcs.org/job/brz-3.1/job/brz-3.1-land/39/

=== modified file 'breezy/branch.py'
--- breezy/branch.py	2020-02-18 03:11:01 +0000
+++ breezy/branch.py	2020-03-22 21:30:11 +0000
@@ -1194,8 +1194,8 @@
         if revno < 1 or revno > self.revno():
             raise errors.InvalidRevisionNumber(revno)
 
-    def clone(self, to_controldir, revision_id=None, repository_policy=None,
-              tag_selector=None):
+    def clone(self, to_controldir, revision_id=None, name=None,
+              repository_policy=None, tag_selector=None):
         """Clone this branch into to_controldir preserving all semantic values.
 
         Most API users will want 'create_clone_on_transport', which creates a
@@ -1204,7 +1204,7 @@
         revision_id: if not None, the revision history in the new branch will
                      be truncated to end with revision_id.
         """
-        result = to_controldir.create_branch()
+        result = to_controldir.create_branch(name=name)
         with self.lock_read(), result.lock_write():
             if repository_policy is not None:
                 repository_policy.configure_branch(result)

=== modified file 'breezy/builtins.py'
--- breezy/builtins.py	2020-01-31 02:34:57 +0000
+++ breezy/builtins.py	2020-03-22 21:30:11 +0000
@@ -1442,6 +1442,7 @@
     parameter, as in "branch foo/bar -r 5".
     """
 
+    aliase = ['sprout']
     _see_also = ['checkout']
     takes_args = ['from_location', 'to_location?']
     takes_options = ['revision',
@@ -1704,6 +1705,38 @@
                                accelerator_tree, hardlink)
 
 
+class cmd_clone(Command):
+    __doc__ = """Clone a control directory.
+    """
+
+    takes_args = ['from_location', 'to_location?']
+    takes_options = ['revision',
+                     Option('no-recurse-nested',
+                            help='Do not recursively check out nested trees.'),
+                     ]
+
+    def run(self, from_location, to_location=None, revision=None, no_recurse_nested=False):
+        accelerator_tree, br_from = controldir.ControlDir.open_tree_or_branch(
+            from_location)
+        if no_recurse_nested:
+            recurse = 'none'
+        else:
+            recurse = 'down'
+        revision = _get_one_revision('branch', revision)
+        self.enter_context(br_from.lock_read())
+        if revision is not None:
+            revision_id = revision.as_revision_id(br_from)
+        else:
+            # FIXME - wt.last_revision, fallback to branch, fall back to
+            # None or perhaps NULL_REVISION to mean copy nothing
+            # RBC 20060209
+            revision_id = br_from.last_revision()
+        if to_location is None:
+            to_location = urlutils.derive_to_location(from_location)
+        target_controldir = br_from.controldir.clone(to_location, revision_id=revision_id)
+        note(gettext('Created new control directory.'))
+
+
 class cmd_renames(Command):
     __doc__ = """Show list of renamed files.
     """

=== modified file 'breezy/bzr/branch.py'
--- breezy/bzr/branch.py	2020-02-18 03:11:01 +0000
+++ breezy/bzr/branch.py	2020-03-22 21:30:11 +0000
@@ -1032,10 +1032,10 @@
 
     def _make_reference_clone_function(format, a_branch):
         """Create a clone() routine for a branch dynamically."""
-        def clone(to_bzrdir, revision_id=None,
-                  repository_policy=None, tag_selector=None):
+        def clone(to_bzrdir, revision_id=None, repository_policy=None, name=None,
+                  tag_selector=None):
             """See Branch.clone()."""
-            return format.initialize(to_bzrdir, target_branch=a_branch)
+            return format.initialize(to_bzrdir, target_branch=a_branch, name=name)
             # cannot obey revision_id limits when cloning a reference ...
             # FIXME RBC 20060210 either nuke revision_id for clone, or
             # emit some sort of warning/error to the caller ?!

=== modified file 'breezy/bzr/bzrdir.py'
--- breezy/bzr/bzrdir.py	2020-02-18 03:11:01 +0000
+++ breezy/bzr/bzrdir.py	2020-03-22 21:30:11 +0000
@@ -174,17 +174,18 @@
             local_repo = self.find_repository()
         except errors.NoRepositoryPresent:
             local_repo = None
+        local_branches = self.get_branches()
         try:
-            local_branch = self.open_branch()
-        except errors.NotBranchError:
-            local_branch = None
+            local_active_branch = local_branches['']
+        except KeyError:
+            pass
         else:
             # enable fallbacks when branch is not a branch reference
-            if local_branch.repository.has_same_location(local_repo):
-                local_repo = local_branch.repository
+            if local_active_branch.repository.has_same_location(local_repo):
+                local_repo = local_active_branch.repository
             if preserve_stacking:
                 try:
-                    stacked_on = local_branch.get_stacked_on_url()
+                    stacked_on = local_active_branch.get_stacked_on_url()
                 except (_mod_branch.UnstackableBranchFormat,
                         errors.UnstackableRepositoryFormat,
                         errors.NotStacked):
@@ -233,11 +234,11 @@
         # 1 if there is a branch present
         #   make sure its content is available in the target repository
         #   clone it.
-        if local_branch is not None:
+        for name, local_branch in local_branches.items():
             local_branch.clone(
-                result, revision_id=revision_id,
+                result, revision_id=(None if name != '' else revision_id),
                 repository_policy=repository_policy,
-                tag_selector=tag_selector)
+                name=name, tag_selector=tag_selector)
         try:
             # Cheaper to check if the target is not local, than to try making
             # the tree and fail.
@@ -1016,6 +1017,18 @@
             pass
         return self.transport.clone('checkout')
 
+    def branch_names(self):
+        """See ControlDir.branch_names."""
+        ret = []
+        try:
+            self.get_branch_reference()
+        except errors.NotBranchError:
+            pass
+        else:
+            ret.append("")
+        ret.extend(self._read_branch_list())
+        return ret
+
     def get_branches(self):
         """See ControlDir.get_branches."""
         ret = {}
@@ -1314,11 +1327,13 @@
                 remote_dir_format = RemoteBzrDirFormat()
                 remote_dir_format._network_name = self.network_name()
                 self._supply_sub_formats_to(remote_dir_format)
-                return remote_dir_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 remote_dir_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)
         # XXX: Refactor the create_prefix/no_create_prefix code into a
         #      common helper function
         # The destination may not exist - if so make it according to policy.

=== modified file 'breezy/bzr/remote.py'
--- breezy/bzr/remote.py	2020-02-19 04:50:09 +0000
+++ breezy/bzr/remote.py	2020-03-22 21:30:11 +0000
@@ -707,6 +707,23 @@
         b = self.open_branch(name=name)
         return b._format
 
+    def branch_names(self):
+        path = self._path_for_remote_call(self._client)
+        try:
+            response, handler = self._call_expecting_body(
+                b'BzrDir.get_branches', path)
+        except errors.UnknownSmartMethod:
+            self._ensure_real()
+            return self._real_bzrdir.branch_names()
+        if response[0] != b"success":
+            raise errors.UnexpectedSmartServerResponse(response)
+        body = bencode.bdecode(handler.read_body_bytes())
+        ret = []
+        for name, value in viewitems(body):
+            name = name.decode('utf-8')
+            ret.append(name)
+        return ret
+
     def get_branches(self, possible_transports=None, ignore_fallbacks=False):
         path = self._path_for_remote_call(self._client)
         try:
@@ -721,9 +738,10 @@
         ret = {}
         for name, value in viewitems(body):
             name = name.decode('utf-8')
-            ret[name] = self._open_branch(name, value[0], value[1],
-                                          possible_transports=possible_transports,
-                                          ignore_fallbacks=ignore_fallbacks)
+            ret[name] = self._open_branch(
+                name, value[0].decode('ascii'), value[1],
+                possible_transports=possible_transports,
+                ignore_fallbacks=ignore_fallbacks)
         return ret
 
     def set_branch_reference(self, target_branch, name=None):
@@ -792,8 +810,9 @@
         if kind == 'ref':
             # a branch reference, use the existing BranchReference logic.
             format = BranchReferenceFormat()
+            ref_loc = urlutils.join(self.user_url, location_or_format.decode('utf-8'))
             return format.open(self, name=name, _found=True,
-                               location=location_or_format.decode('utf-8'),
+                               location=ref_loc,
                                ignore_fallbacks=ignore_fallbacks,
                                possible_transports=possible_transports)
         branch_format_name = location_or_format

=== modified file 'breezy/bzr/smart/bzrdir.py'
--- breezy/bzr/smart/bzrdir.py	2018-11-11 04:08:32 +0000
+++ breezy/bzr/smart/bzrdir.py	2020-03-22 21:30:11 +0000
@@ -443,12 +443,19 @@
         The body is a bencoded dictionary, with values similar to the return
         value of the open branch request.
         """
-        branches = self._bzrdir.get_branches()
+        branch_names = self._bzrdir.branch_names()
         ret = {}
-        for name, b in branches.items():
+        for name in branch_names:
             if name is None:
                 name = b""
-            ret[name.encode('utf-8')] = (b"branch", b._format.network_name())
+            branch_ref = self._bzrdir.get_branch_reference(name=name)
+            if branch_ref is not None:
+                branch_ref = urlutils.relative_url(self._bzrdir.user_url, branch_ref)
+                value = (b"ref", branch_ref.encode('utf-8'))
+            else:
+                b = self._bzrdir.open_branch(name=name, ignore_fallbacks=True)
+                value = (b"branch", b._format.network_name())
+            ret[name.encode('utf-8')] = value
         return SuccessfulSmartServerResponse(
             (b"success", ), bencode.bencode(ret))
 

=== modified file 'breezy/controldir.py'
--- breezy/controldir.py	2020-02-18 03:11:01 +0000
+++ breezy/controldir.py	2020-03-22 21:30:11 +0000
@@ -129,6 +129,18 @@
         """
         return list(self.get_branches().values())
 
+    def branch_names(self):
+        """List all branch names in this control directory.
+
+        :return: List of branch names
+        """
+        try:
+            self.get_branch_reference()
+        except (errors.NotBranchError, errors.NoRepositoryPresent):
+            return []
+        else:
+            return [""]
+
     def get_branches(self):
         """Get all branches in this control directory, as a dictionary.
 

=== modified file 'breezy/git/dir.py'
--- breezy/git/dir.py	2020-02-19 04:50:09 +0000
+++ breezy/git/dir.py	2020-03-22 21:30:11 +0000
@@ -228,6 +228,7 @@
         """See ControlDir.clone_on_transport."""
         from ..repository import InterRepository
         from .mapping import default_mapping
+        from ..transport.local import LocalTransport
         if stacked_on is not None:
             raise _mod_branch.UnstackableBranchFormat(
                 self._format, self.user_url)
@@ -253,18 +254,19 @@
                                                        mapping=default_mapping)
         for name, val in viewitems(refs):
             target_git_repo.refs[name] = val
-        result_dir = self.__class__(transport, target_git_repo, format)
+        result_dir = LocalGitDir(transport, target_git_repo, format)
         if revision_id is not None:
             result_dir.open_branch().set_last_revision(revision_id)
-        try:
-            # Cheaper to check if the target is not local, than to try making
-            # the tree and fail.
-            result_dir.root_transport.local_abspath('.')
+        if not no_tree and isinstance(result_dir.root_transport, LocalTransport):
             if result_dir.open_repository().make_working_trees():
-                self.open_workingtree().clone(
-                    result_dir, revision_id=revision_id)
-        except (brz_errors.NoWorkingTree, brz_errors.NotLocalUrl):
-            pass
+                try:
+                    local_wt = self.open_workingtree()
+                except brz_errors.NoWorkingTree:
+                    pass
+                except brz_errors.NotLocalUrl:
+                    result_dir.create_workingtree(revision_id=revision_id)
+                else:
+                    local_wt.clone(result_dir, revision_id=revision_id)
 
         return result_dir
 
@@ -299,6 +301,20 @@
         """
         return UseExistingRepository(self.find_repository())
 
+    def branch_names(self):
+        from .refs import ref_to_branch_name
+        ret = []
+        for ref in self.get_refs_container().keys():
+            try:
+                branch_name = ref_to_branch_name(ref)
+            except UnicodeDecodeError:
+                trace.warning("Ignoring branch %r with unicode error ref", ref)
+                continue
+            except ValueError:
+                continue
+            ret.append(branch_name)
+        return ret
+
     def get_branches(self):
         from .refs import ref_to_branch_name
         ret = {}

=== modified file 'breezy/git/tests/test_blackbox.py'
--- breezy/git/tests/test_blackbox.py	2020-03-21 20:56:33 +0000
+++ breezy/git/tests/test_blackbox.py	2020-03-22 21:30:11 +0000
@@ -349,7 +349,7 @@
         self.run_bzr(["git-import", "--colocated", "a", "b"])
         self.assertEqual(set([".bzr"]), set(os.listdir("b")))
         self.assertEqual(set(["abranch", "bbranch"]),
-                         set(ControlDir.open("b").get_branches().keys()))
+                         set(ControlDir.open("b").branch_names()))
 
     def test_git_import_incremental(self):
         r = GitRepo.init("a", mkdir=True)
@@ -361,7 +361,7 @@
         self.run_bzr(["git-import", "--colocated", "a", "b"])
         self.assertEqual(set([".bzr"]), set(os.listdir("b")))
         b = ControlDir.open("b")
-        self.assertEqual(["abranch"], list(b.get_branches().keys()))
+        self.assertEqual(["abranch"], b.branch_names())
 
     def test_git_import_tags(self):
         r = GitRepo.init("a", mkdir=True)
@@ -373,7 +373,7 @@
         self.run_bzr(["git-import", "--colocated", "a", "b"])
         self.assertEqual(set([".bzr"]), set(os.listdir("b")))
         b = ControlDir.open("b")
-        self.assertEqual(["abranch"], list(b.get_branches().keys()))
+        self.assertEqual(["abranch"], b.branch_names())
         self.assertEqual(["atag"],
                          list(b.open_branch("abranch").tags.get_tag_dict().keys()))
 

=== modified file 'breezy/git/tests/test_remote.py'
--- breezy/git/tests/test_remote.py	2020-02-08 18:51:59 +0000
+++ breezy/git/tests/test_remote.py	2020-03-22 21:30:11 +0000
@@ -567,6 +567,8 @@
         self.assertEqual(
             {'': 'master', 'blah': 'blah', 'master': 'master'},
             {n: b.name for (n, b) in remote.get_branches().items()})
+        self.assertEqual(
+            set(['', 'blah', 'master']), set(remote.branch_names()))
 
     def test_remove_tag(self):
         c1 = self.remote_real.do_commit(

=== modified file 'breezy/info.py'
--- breezy/info.py	2019-11-19 18:10:28 +0000
+++ breezy/info.py	2020-03-22 21:30:11 +0000
@@ -457,7 +457,7 @@
         extra = []
         if repository.make_working_trees():
             extra.append('trees')
-        if len(control.get_branches()) > 0:
+        if len(control.branch_names()) > 0:
             extra.append('colocated branches')
         if extra:
             phrase += ' with ' + " and ".join(extra)

=== modified file 'breezy/plugins/weave_fmt/bzrdir.py'
--- breezy/plugins/weave_fmt/bzrdir.py	2020-02-18 03:16:21 +0000
+++ breezy/plugins/weave_fmt/bzrdir.py	2020-03-22 21:30:11 +0000
@@ -842,7 +842,7 @@
 
     def get_branch_transport(self, branch_format, name=None):
         """See BzrDir.get_branch_transport()."""
-        if name is not None:
+        if name:
             raise errors.NoColocatedBranchSupport(self)
         if branch_format is None:
             return self.transport

=== modified file 'breezy/tests/blackbox/__init__.py'
--- breezy/tests/blackbox/__init__.py	2019-06-15 17:06:40 +0000
+++ breezy/tests/blackbox/__init__.py	2020-03-22 21:30:11 +0000
@@ -51,6 +51,7 @@
         'test_check',
         'test_checkout',
         'test_clean_tree',
+        'test_clone',
         'test_command_encoding',
         'test_commit',
         'test_config',

=== added file 'breezy/tests/blackbox/test_clone.py'
--- breezy/tests/blackbox/test_clone.py	1970-01-01 00:00:00 +0000
+++ breezy/tests/blackbox/test_clone.py	2020-03-22 21:30:11 +0000
@@ -0,0 +1,70 @@
+# Copyright (C) 2006-2012, 2016 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
+
+
+"""Black-box tests for brz branch."""
+
+import os
+
+from breezy import (
+    branch,
+    controldir,
+    tests,
+    )
+from breezy.urlutils import local_path_to_url
+
+
+class TestClone(tests.TestCaseWithTransport):
+
+    def example_dir(self, path='.', format=None):
+        tree = self.make_branch_and_tree(path, format=format)
+        self.build_tree_contents([(path + '/hello', b'foo')])
+        tree.add('hello')
+        tree.commit(message='setup')
+        self.build_tree_contents([(path + '/goodbye', b'baz')])
+        tree.add('goodbye')
+        tree.commit(message='setup')
+        return tree
+
+    def test_clone(self):
+        """Branch from one branch to another."""
+        self.example_dir('a')
+        self.run_bzr('clone a b')
+        b = branch.Branch.open('b')
+        self.run_bzr('clone a c -r 1')
+        # previously was erroneously created by branching
+        self.assertFalse(b._transport.has('branch-name'))
+        b.controldir.open_workingtree().commit(message='foo', allow_pointless=True)
+
+    def test_clone_no_to_location(self):
+        """The to_location is derived from the source branch name."""
+        os.mkdir("something")
+        a = self.example_dir('something/a').branch
+        self.run_bzr('clone something/a')
+        b = branch.Branch.open('a')
+        self.assertEqual(b.last_revision_info(), a.last_revision_info())
+
+    def test_from_colocated(self):
+        """Branch from a colocated branch into a regular branch."""
+        os.mkdir('b')
+        tree = self.example_dir('b/a')
+        tree.controldir.create_branch(name='somecolo')
+        out, err = self.run_bzr('clone %s' % local_path_to_url('b/a'))
+        self.assertEqual('', out)
+        self.assertEqual('Created new control directory.\n', err)
+        self.assertPathExists('a')
+        target = controldir.ControlDir.open('a')
+        self.assertEqual(['', 'somecolo'], target.branch_names())

=== modified file 'breezy/tests/blackbox/test_switch.py'
--- breezy/tests/blackbox/test_switch.py	2019-09-01 15:33:59 +0000
+++ breezy/tests/blackbox/test_switch.py	2020-03-22 21:30:11 +0000
@@ -207,7 +207,7 @@
         self.run_bzr(['switch', '-b', 'anotherbranch'])
         self.assertEqual(
             {'', 'anotherbranch'},
-            set(tree.branch.controldir.get_branches().keys()))
+            set(tree.branch.controldir.branch_names()))
 
     def test_switch_into_unrelated_colocated(self):
         # Create a new colocated branch from an existing non-colocated branch.

=== modified file 'breezy/tests/per_bzrdir/test_bzrdir.py'
--- breezy/tests/per_bzrdir/test_bzrdir.py	2018-11-11 04:08:32 +0000
+++ breezy/tests/per_bzrdir/test_bzrdir.py	2020-03-22 21:30:11 +0000
@@ -688,4 +688,4 @@
         target_branch = repo.controldir.create_branch(name='foo')
         repo.controldir.set_branch_reference(target_branch)
         self.assertEqual({"", 'foo'},
-                         set(repo.controldir.get_branches().keys()))
+                         set(repo.controldir.branch_names()))

=== modified file 'breezy/tests/per_controldir/test_controldir.py'
--- breezy/tests/per_controldir/test_controldir.py	2019-05-29 03:22:34 +0000
+++ breezy/tests/per_controldir/test_controldir.py	2020-03-22 21:30:11 +0000
@@ -199,7 +199,7 @@
                                     "control directories without working tree")
         self.assertRaises(errors.NoWorkingTree, dir.open_workingtree)
 
-    def test_clone_bzrdir_repository_under_shared(self):
+    def test_clone_controldir_repository_under_shared(self):
         tree = self.make_branch_and_tree('commit_tree')
         self.build_tree(
             ['foo'], transport=tree.controldir.transport.clone('..'))
@@ -221,7 +221,7 @@
         self.assertNotEqual(dir.transport.base, target.transport.base)
         self.assertRaises(errors.NoRepositoryPresent, target.open_repository)
 
-    def test_clone_bzrdir_repository_branch_both_under_shared(self):
+    def test_clone_controldir_repository_branch_both_under_shared(self):
         # Create a shared repository
         try:
             shared_repo = self.make_repository('shared', shared=True)
@@ -249,7 +249,7 @@
         dir.create_branch()
         # Clone 'source' to 'target', also inside the shared repository.
         target = dir.clone(self.get_url('shared/target'))
-        # 'source', 'target', and the shared repo all have distinct bzrdirs.
+        # 'source', 'target', and the shared repo all have distinct controldirs.
         self.assertNotEqual(dir.transport.base, target.transport.base)
         self.assertNotEqual(
             dir.transport.base, shared_repo.controldir.transport.base)
@@ -258,7 +258,7 @@
         # 'commit_tree' branch.
         self.assertTrue(shared_repo.has_revision(rev1))
 
-    def test_clone_bzrdir_repository_branch_only_source_under_shared(self):
+    def test_clone_controldir_repository_branch_only_source_under_shared(self):
         try:
             shared_repo = self.make_repository('shared', shared=True)
         except errors.IncompatibleFormat:
@@ -291,7 +291,7 @@
         self.assertFalse(branch.repository.make_working_trees())
         self.assertTrue(branch.repository.is_shared())
 
-    def test_clone_bzrdir_repository_revision(self):
+    def test_clone_controldir_repository_revision(self):
         # test for revision limiting, [smoke test, not corner case checks].
         # make a repository with some revisions,
         # and clone it with a revision limit.
@@ -310,7 +310,7 @@
         dir.clone(self.get_url('target'), revision_id=rev2)
         raise TestSkipped('revision limiting not strict yet')
 
-    def test_clone_bzrdir_branch_and_repo_fixed_user_id(self):
+    def test_clone_controldir_branch_and_repo_fixed_user_id(self):
         # Bug #430868 is about an email containing '.sig'
         self.overrideEnv('BRZ_EMAIL', '[e-mail]')
         tree = self.make_branch_and_tree('commit_tree')
@@ -330,7 +330,7 @@
             tree_repo.get_signature_text(rev1),
             target.repository.get_signature_text(rev1))
 
-    def test_clone_bzrdir_branch_and_repo_into_shared_repo(self):
+    def test_clone_controldir_branch_and_repo_into_shared_repo(self):
         # by default cloning into a shared repo uses the shared repo.
         tree = self.make_branch_and_tree('commit_tree')
         self.build_tree(['commit_tree/foo'])
@@ -354,7 +354,7 @@
         self.assertEqual(source.last_revision(),
                          target.open_branch().last_revision())
 
-    def test_clone_bzrdir_branch_revision(self):
+    def test_clone_controldir_branch_revision(self):
         # test for revision limiting, [smoke test, not corner case checks].
         # make a branch with some revisions,
         # and clone it with a revision limit.
@@ -371,6 +371,23 @@
         target = dir.clone(self.get_url('target'), revision_id=rev1)
         self.assertEqual(rev1, target.open_branch().last_revision())
 
+    def test_clone_controldir_with_colocated(self):
+        if not self.bzrdir_format.colocated_branches:
+            raise TestNotApplicable(
+                'format does not supported colocated branches')
+        tree = self.make_branch_and_tree('commit_tree')
+        self.build_tree(['commit_tree/foo'])
+        tree.add('foo')
+        rev1 = tree.commit('revision 1')
+        rev2 = tree.commit('revision 2', allow_pointless=True)
+        rev3 = tree.commit('revision 2', allow_pointless=True)
+        dir = tree.branch.controldir
+        colo = dir.create_branch(name='colo')
+        colo.pull(tree.branch, stop_revision=rev1)
+        target = dir.clone(self.get_url('target'), revision_id=rev2)
+        self.assertEqual(rev2, target.open_branch().last_revision())
+        self.assertEqual(rev1, target.open_branch(name='colo').last_revision())
+
     def test_clone_on_transport_preserves_repo_format(self):
         if self.bzrdir_format == controldir.format_registry.make_controldir('default'):
             format = 'knit'
@@ -381,8 +398,8 @@
         a_dir = breezy.branch.Branch.open_from_transport(
             self.get_transport('source')).controldir
         target_transport = self.get_transport('target')
-        target_bzrdir = a_dir.clone_on_transport(target_transport)
-        target_repo = target_bzrdir.open_repository()
+        target_controldir = a_dir.clone_on_transport(target_transport)
+        target_repo = target_controldir.open_repository()
         source_branch = breezy.branch.Branch.open(
             self.get_vfs_only_url('source'))
         if isinstance(target_repo, RemoteRepository):
@@ -390,7 +407,7 @@
             target_repo = target_repo._real_repository
         self.assertEqual(target_repo._format, source_branch.repository._format)
 
-    def test_clone_bzrdir_tree_revision(self):
+    def test_clone_controldir_tree_revision(self):
         # test for revision limiting, [smoke test, not corner case checks].
         # make a tree with a revision with a last-revision
         # and clone it with a revision limit.
@@ -406,7 +423,7 @@
         self.skipIfNoWorkingTree(target)
         self.assertEqual([rev1], target.open_workingtree().get_parent_ids())
 
-    def test_clone_bzrdir_into_notrees_repo(self):
+    def test_clone_controldir_into_notrees_repo(self):
         """Cloning into a no-trees repo should not create a working tree"""
         tree = self.make_branch_and_tree('source')
         self.build_tree(['source/foo'])
@@ -514,12 +531,12 @@
         """get_branch_reference should not mask NotBranchErrors."""
         dir = self.make_controldir('source')
         if dir.has_branch():
-            # this format does not support branchless bzrdirs.
+            # this format does not support branchless controldirs.
             raise TestNotApplicable("format does not support "
                                     "branchless control directories")
         self.assertRaises(errors.NotBranchError, dir.get_branch_reference)
 
-    def test_sprout_bzrdir_empty(self):
+    def test_sprout_controldir_empty(self):
         dir = self.make_controldir('source')
         target = dir.sprout(self.get_url('target'))
         self.assertNotEqual(dir.control_transport.base,
@@ -529,7 +546,7 @@
         target.open_branch()
         self.openWorkingTreeIfLocal(target)
 
-    def test_sprout_bzrdir_empty_under_shared_repo(self):
+    def test_sprout_controldir_empty_under_shared_repo(self):
         # sprouting an empty dir into a repo uses the repo
         dir = self.make_controldir('source')
         try:
@@ -543,13 +560,13 @@
         try:
             target.open_workingtree()
         except errors.NoWorkingTree:
-            # Some bzrdirs can never have working trees.
+            # Some controldirs can never have working trees.
             repo = target.find_repository()
             self.assertFalse(repo.controldir._format.supports_workingtrees)
 
-    def test_sprout_bzrdir_empty_under_shared_repo_force_new(self):
+    def test_sprout_controldir_empty_under_shared_repo_force_new(self):
         # the force_new_repo parameter should force use of a new repo in an empty
-        # bzrdir's sprout logic
+        # controldir's sprout logic
         dir = self.make_controldir('source')
         try:
             self.make_repository('target', shared=True)
@@ -561,7 +578,7 @@
         target.open_branch()
         self.openWorkingTreeIfLocal(target)
 
-    def test_sprout_bzrdir_with_repository_to_shared(self):
+    def test_sprout_controldir_with_repository_to_shared(self):
         tree = self.make_branch_and_tree('commit_tree')
         self.build_tree(['commit_tree/foo'])
         tree.add('foo')
@@ -583,7 +600,7 @@
                             target.user_transport.base)
         self.assertTrue(shared_repo.has_revision(rev1))
 
-    def test_sprout_bzrdir_repository_branch_both_under_shared(self):
+    def test_sprout_controldir_repository_branch_both_under_shared(self):
         try:
             shared_repo = self.make_repository('shared', shared=True)
         except errors.IncompatibleFormat:
@@ -609,7 +626,7 @@
                             shared_repo.controldir.transport.base)
         self.assertTrue(shared_repo.has_revision(rev1))
 
-    def test_sprout_bzrdir_repository_branch_only_source_under_shared(self):
+    def test_sprout_controldir_repository_branch_only_source_under_shared(self):
         try:
             shared_repo = self.make_repository('shared', shared=True)
         except errors.IncompatibleFormat:
@@ -639,7 +656,7 @@
             dir.transport.base,
             shared_repo.controldir.transport.base)
         branch = target.open_branch()
-        # The sprouted bzrdir has a branch, so only revisions referenced by
+        # The sprouted controldir has a branch, so only revisions referenced by
         # that branch are copied, rather than the whole repository.  It's an
         # empty branch, so none are copied.
         self.assertEqual([], branch.repository.all_revision_ids())
@@ -647,7 +664,7 @@
             self.assertTrue(branch.repository.make_working_trees())
         self.assertFalse(branch.repository.is_shared())
 
-    def test_sprout_bzrdir_repository_under_shared_force_new_repo(self):
+    def test_sprout_controldir_repository_under_shared_force_new_repo(self):
         tree = self.make_branch_and_tree('commit_tree')
         self.build_tree(['commit_tree/foo'])
         tree.add('foo')
@@ -670,7 +687,7 @@
             target.control_transport.base)
         self.assertFalse(shared_repo.has_revision(rev1))
 
-    def test_sprout_bzrdir_repository_revision(self):
+    def test_sprout_controldir_repository_revision(self):
         # test for revision limiting, [smoke test, not corner case checks].
         # make a repository with some revisions,
         # and sprout it with a revision limit.
@@ -689,7 +706,7 @@
         self.sproutOrSkip(dir, self.get_url('target'), revision_id=rev2)
         raise TestSkipped('revision limiting not strict yet')
 
-    def test_sprout_bzrdir_branch_and_repo_shared(self):
+    def test_sprout_controldir_branch_and_repo_shared(self):
         # sprouting a branch with a repo into a shared repo uses the shared
         # repo
         tree = self.make_branch_and_tree('commit_tree')
@@ -708,7 +725,7 @@
         dir.sprout(self.get_url('target/child'))
         self.assertTrue(shared_repo.has_revision(rev1))
 
-    def test_sprout_bzrdir_branch_and_repo_shared_force_new_repo(self):
+    def test_sprout_controldir_branch_and_repo_shared_force_new_repo(self):
         # sprouting a branch with a repo into a shared repo uses the shared
         # repo
         tree = self.make_branch_and_tree('commit_tree')
@@ -729,7 +746,7 @@
             dir.control_transport.base, target.control_transport.base)
         self.assertFalse(shared_repo.has_revision(rev1))
 
-    def test_sprout_bzrdir_branch_reference(self):
+    def test_sprout_controldir_branch_reference(self):
         # sprouting should create a repository if needed and a sprouted branch.
         referenced_branch = self.make_branch('referenced')
         dir = self.make_controldir('source')
@@ -747,7 +764,7 @@
         # place
         target.open_repository()
 
-    def test_sprout_bzrdir_branch_reference_shared(self):
+    def test_sprout_controldir_branch_reference_shared(self):
         # sprouting should create a repository if needed and a sprouted branch.
         referenced_tree = self.make_branch_and_tree('referenced')
         rev1 = referenced_tree.commit('1', allow_pointless=True)
@@ -773,7 +790,7 @@
         # and we want revision '1' in the shared repo
         self.assertTrue(shared_repo.has_revision(rev1))
 
-    def test_sprout_bzrdir_branch_reference_shared_force_new_repo(self):
+    def test_sprout_controldir_branch_reference_shared_force_new_repo(self):
         # sprouting should create a repository if needed and a sprouted branch.
         referenced_tree = self.make_branch_and_tree('referenced')
         rev1 = referenced_tree.commit('1', allow_pointless=True)
@@ -799,7 +816,7 @@
         # but not the shared one
         self.assertFalse(shared_repo.has_revision(rev1))
 
-    def test_sprout_bzrdir_branch_revision(self):
+    def test_sprout_controldir_branch_revision(self):
         # test for revision limiting, [smoke test, not corner case checks].
         # make a repository with some revisions,
         # and sprout it with a revision limit.
@@ -816,7 +833,7 @@
         target = dir.sprout(self.get_url('target'), revision_id=rev1)
         self.assertEqual(rev1, target.open_branch().last_revision())
 
-    def test_sprout_bzrdir_branch_with_tags(self):
+    def test_sprout_controldir_branch_with_tags(self):
         # when sprouting a branch all revisions named in the tags are copied
         # too.
         builder = self.make_branch_builder('source')
@@ -835,7 +852,7 @@
         self.assertEqual(rev2, new_branch.tags.lookup_tag('tag-a'))
         new_branch.repository.get_revision(rev2)
 
-    def test_sprout_bzrdir_branch_with_absent_tag(self):
+    def test_sprout_controldir_branch_with_absent_tag(self):
         # tags referencing absent revisions are copied (and those absent
         # revisions do not prevent the sprout.)
         builder = self.make_branch_builder('source')
@@ -855,7 +872,7 @@
         new_branch = target.open_branch()
         self.assertEqual(b'missing-rev', new_branch.tags.lookup_tag('tag-a'))
 
-    def test_sprout_bzrdir_passing_source_branch_with_absent_tag(self):
+    def test_sprout_controldir_passing_source_branch_with_absent_tag(self):
         # tags referencing absent revisions are copied (and those absent
         # revisions do not prevent the sprout.)
         builder = self.make_branch_builder('source')
@@ -875,9 +892,9 @@
         new_branch = target.open_branch()
         self.assertEqual(b'missing-rev', new_branch.tags.lookup_tag('tag-a'))
 
-    def test_sprout_bzrdir_passing_rev_not_source_branch_copies_tags(self):
+    def test_sprout_controldir_passing_rev_not_source_branch_copies_tags(self):
         # dir.sprout(..., revision_id=b'rev1') copies rev1, and all the tags of
-        # the branch at that bzrdir, the ancestry of all of those, but no other
+        # the branch at that controldir, the ancestry of all of those, but no other
         # revs (not even the tip of the source branch).
         builder = self.make_branch_builder('source')
         base_rev = builder.build_commit(message="Base")
@@ -927,7 +944,7 @@
             sorted([base_rev, rev_b1, rev_b2, rev_c1, rev_c2]),
             sorted(new_branch.repository.all_revision_ids()))
 
-    def test_sprout_bzrdir_tree_branch_reference(self):
+    def test_sprout_controldir_tree_branch_reference(self):
         # sprouting should create a repository if needed and a sprouted branch.
         # the tree state should not be copied.
         referenced_branch = self.make_branch('referencced')
@@ -952,7 +969,7 @@
         result_tree = target.open_workingtree()
         self.assertFalse(result_tree.has_filename('subdir'))
 
-    def test_sprout_bzrdir_tree_branch_reference_revision(self):
+    def test_sprout_controldir_tree_branch_reference_revision(self):
         # sprouting should create a repository if needed and a sprouted branch.
         # the tree state should not be copied but the revision changed,
         # and the likewise the new branch should be truncated too
@@ -982,7 +999,7 @@
         self.assertEqual([rev1], target.open_workingtree().get_parent_ids())
         self.assertEqual(rev1, target.open_branch().last_revision())
 
-    def test_sprout_bzrdir_tree_revision(self):
+    def test_sprout_controldir_tree_revision(self):
         # test for revision limiting, [smoke test, not corner case checks].
         # make a tree with a revision with a last-revision
         # and sprout it with a revision limit.
@@ -1034,13 +1051,13 @@
         rev3 = builder.build_commit(message='Rev 3.')
         builder.finish_series()
         stack_on = builder.get_branch()
-        # Make a bzrdir with a default stacking policy to stack on that branch.
+        # Make a controldir with a default stacking policy to stack on that branch.
         config = self.make_controldir('policy-dir').get_config()
         try:
             config.set_default_stack_on(self.get_url('stack-on'))
         except errors.BzrError:
             raise TestNotApplicable('Only relevant for stackable formats.')
-        # Sprout the stacked-on branch into the bzrdir.
+        # Sprout the stacked-on branch into the controldir.
         sprouted = stack_on.controldir.sprout(
             self.get_url('policy-dir/sprouted'), revision_id=rev3)
         # Not all revisions are copied into the sprouted repository.
@@ -1288,6 +1305,11 @@
         repo.controldir.create_branch()
         self.assertEqual([""], list(repo.controldir.get_branches()))
 
+    def test_branch_names(self):
+        repo = self.make_repository('branch-1')
+        repo.controldir.create_branch()
+        self.assertEqual([""], repo.controldir.branch_names())
+
     def test_create_repository(self):
         # a bzrdir can construct a repository for itself.
         if not self.bzrdir_format.is_initializable():

=== modified file 'breezy/tests/per_controldir_colo/test_supported.py'
--- breezy/tests/per_controldir_colo/test_supported.py	2019-04-13 21:37:04 +0000
+++ breezy/tests/per_controldir_colo/test_supported.py	2020-03-22 21:30:11 +0000
@@ -184,6 +184,11 @@
         self.assertEqual(target_branch.base,
                          repo.controldir.get_branches()['foo'].base)
 
+    def test_branch_names(self):
+        repo = self.make_repository('branch-1')
+        target_branch = self.create_branch(repo.controldir, name='foo')
+        self.assertIn('foo', repo.controldir.branch_names())
+
     def test_branch_name_with_slash(self):
         repo = self.make_repository('branch-1')
         try:

=== modified file 'breezy/tests/test_smart.py'
--- breezy/tests/test_smart.py	2020-01-18 02:42:17 +0000
+++ breezy/tests/test_smart.py	2020-03-22 21:30:11 +0000
@@ -485,6 +485,19 @@
             (b"success", ), local_result)
         self.assertEqual(expected, request.execute(b''))
 
+    def test_ref(self):
+        backing = self.get_transport()
+        dir = self.make_controldir('foo')
+        b = self.make_branch('bar')
+        dir.set_branch_reference(b)
+        request_class = smart_dir.SmartServerBzrDirRequestGetBranches
+        request = request_class(backing)
+        local_result = bencode.bencode(
+            {b"": (b"ref", b'../bar/')})
+        expected = smart_req.SuccessfulSmartServerResponse(
+            (b"success", ), local_result)
+        self.assertEqual(expected, request.execute(b'foo'))
+
     def test_empty(self):
         backing = self.get_transport()
         self.make_controldir('.')

=== modified file 'doc/en/release-notes/brz-3.1.txt'
--- doc/en/release-notes/brz-3.1.txt	2020-03-21 20:56:33 +0000
+++ doc/en/release-notes/brz-3.1.txt	2020-03-22 21:30:11 +0000
@@ -73,6 +73,13 @@
  * When pushing to Git repositories, symrefs are now followed.
    (Jelmer Vernooij, #1800393)
 
+ * New ``brz clone`` command, which clones everything under
+   a control directory. I.e. all colocated branches, like
+   ``git clone``. (Jelmer Vernooij, #831939)
+
+ * ``brz sprout`` is now an alias for ``brz branch``.
+   (Jelmer Vernooij)
+
 Improvements
 ************