Merge lp:~jelmer/brz/trunk-merge-3.1 into lp:brz

[Jelmer Vernooij]

Merge the 3.1 branch.

Merge the 3.1 branch.

[Jelmer Vernooij (jelmer)]

review: Approve

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

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

=== modified file '.gitignore'
--- .gitignore	2019-10-13 14:45:08 +0000
+++ .gitignore	2020-05-06 02:56:30 +0000
@@ -1,1 +1,12 @@
 __pycache__
+*.pyc
+build/
+*_pyx.so
+*_pyx.c
+*_pyx.h
+*_pyx_api.h
+*_pyx.cpython-*.so
+*_c.cpython-*.so
+*_c.so
+*_pyx.cpython-*.c
+*~

=== added file 'breezy/__main__.py'
--- breezy/__main__.py	1970-01-01 00:00:00 +0000
+++ breezy/__main__.py	2020-05-06 02:56:30 +0000
@@ -0,0 +1,79 @@
+#! /usr/bin/env python3
+
+# Copyright (C) 2005-2013, 2016, 2017 Canonical Ltd
+# Copyright (C) 2018-2020 Breezy Developers
+#
+# 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
+
+from __future__ import absolute_import
+
+"""Breezy -- a free distributed version-control tool"""
+
+import os
+import sys
+import warnings
+
+
+profiling = False
+if '--profile-imports' in sys.argv:
+    import profile_imports
+    profile_imports.install()
+    profiling = True
+
+
+if os.name == "posix":
+    import locale
+    try:
+        locale.setlocale(locale.LC_ALL, '')
+    except locale.Error as e:
+        sys.stderr.write(
+            'brz: warning: %s\n'
+            '  bzr could not set the application locale.\n'
+            '  Although this should be no problem for bzr itself, it might\n'
+            '  cause problems with some plugins. To investigate the issue,\n'
+            '  look at the output of the locale(1p) tool.\n' % e)
+    # Use better default than ascii with posix filesystems that deal in bytes
+    # natively even when the C locale or no locale at all is given. Note that
+    # we need an immortal string for the hack, hence the lack of a hyphen.
+    sys._brz_default_fs_enc = "utf8"
+
+
+def main():
+    import breezy.breakin
+    breezy.breakin.hook_debugger_to_signal()
+
+    import breezy.commands
+    import breezy.trace
+
+    with breezy.initialize():
+        exit_val = breezy.commands.main()
+        if profiling:
+            profile_imports.log_stack_info(sys.stderr)
+
+    # By this point we really have completed everything we want to do, and
+    # there's no point doing any additional cleanup.  Abruptly exiting here
+    # stops any background threads getting into trouble as code is unloaded,
+    # and it may also be slightly faster, through avoiding gc of objects that
+    # are just about to be discarded anyhow.  This does mean that atexit hooks
+    # won't run but we don't use them.  Also file buffers won't be flushed,
+    # but our policy is to always close files from a finally block. -- mbp 20070215
+    exitfunc = getattr(sys, "exitfunc", None)
+    if exitfunc is not None:
+        exitfunc()
+    os._exit(exit_val)
+
+
+if __name__ == '__main__':
+    main()

=== modified file 'breezy/branch.py'
--- breezy/branch.py	2020-02-21 03:58:42 +0000
+++ breezy/branch.py	2020-05-06 02:56:30 +0000
@@ -1188,8 +1188,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
@@ -1198,7 +1198,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-02-18 01:57:45 +0000
+++ breezy/builtins.py	2020-05-06 02:56:30 +0000
@@ -1434,6 +1434,7 @@
     parameter, as in "branch foo/bar -r 5".
     """
 
+    aliase = ['sprout']
     _see_also = ['checkout']
     takes_args = ['from_location', 'to_location?']
     takes_options = ['revision',
@@ -1461,15 +1462,17 @@
                             help="Bind new branch to from location."),
                      Option('no-recurse-nested',
                             help='Do not recursively check out nested trees.'),
+                     Option('colocated-branch', short_name='b',
+                            type=str, help='Name of colocated branch to sprout.'),
                      ]
 
     def run(self, from_location, to_location=None, revision=None,
             hardlink=False, stacked=False, standalone=False, no_tree=False,
             use_existing_dir=False, switch=False, bind=False,
-            files_from=None, no_recurse_nested=False):
+            files_from=None, no_recurse_nested=False, colocated_branch=None):
         from breezy import switch as _mod_switch
         accelerator_tree, br_from = controldir.ControlDir.open_tree_or_branch(
-            from_location)
+            from_location, name=colocated_branch)
         if no_recurse_nested:
             recurse = 'none'
         else:
@@ -1695,6 +1698,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-21 03:58:42 +0000
+++ breezy/bzr/branch.py	2020-05-06 02:56:30 +0000
@@ -1023,10 +1023,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-21 03:58:42 +0000
+++ breezy/bzr/bzrdir.py	2020-05-06 02:56:30 +0000
@@ -172,17 +172,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):
@@ -231,11 +232,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.
@@ -1014,6 +1015,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 = {}
@@ -1312,11 +1325,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-21 03:58:42 +0000
+++ breezy/bzr/remote.py	2020-05-06 02:56:30 +0000
@@ -698,6 +698,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 body.items():
+            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:
@@ -712,9 +729,10 @@
         ret = {}
         for name, value in body.items():
             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):
@@ -783,8 +801,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	2020-02-18 01:57:45 +0000
+++ breezy/bzr/smart/bzrdir.py	2020-05-06 02:56:30 +0000
@@ -440,12 +440,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/config.py'
--- breezy/config.py	2020-02-18 01:57:45 +0000
+++ breezy/config.py	2020-05-06 02:56:30 +0000
@@ -530,12 +530,12 @@
 
         Something similar to 'Martin Pool <[e-mail]>'
 
-        $BRZ_EMAIL can be set to override this, then
+        $BRZ_EMAIL or $BZR_EMAIL can be set to override this, then
         the concrete policy type is checked, and finally
         $EMAIL is examined.
         If no username can be found, NoWhoami exception is raised.
         """
-        v = os.environ.get('BRZ_EMAIL')
+        v = os.environ.get('BRZ_EMAIL') or os.environ.get('BZR_EMAIL')
         if v:
             return v
         v = self._get_user_id()
@@ -2514,7 +2514,7 @@
     Option('editor',
            help='The command called to launch an editor to enter a message.'))
 option_registry.register(
-    Option('email', override_from_env=['BRZ_EMAIL'],
+    Option('email', override_from_env=['BRZ_EMAIL', 'BZR_EMAIL'],
            default=bedding.default_email, help='The users identity'))
 option_registry.register(
     Option('gpg_signing_key',

=== modified file 'breezy/controldir.py'
--- breezy/controldir.py	2020-02-21 03:58:42 +0000
+++ breezy/controldir.py	2020-05-06 02:56:30 +0000
@@ -127,6 +127,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.
 
@@ -794,7 +806,7 @@
             a_transport = new_t
 
     @classmethod
-    def open_tree_or_branch(klass, location):
+    def open_tree_or_branch(klass, location, name=None):
         """Return the branch and working tree at a location.
 
         If there is no tree at the location, tree will be None.
@@ -803,7 +815,7 @@
         :return: (tree, branch)
         """
         controldir = klass.open(location)
-        return controldir._get_tree_branch()
+        return controldir._get_tree_branch(name=name)
 
     @classmethod
     def open_containing_tree_or_branch(klass, location,

=== modified file 'breezy/git/__init__.py'
--- breezy/git/__init__.py	2020-02-18 01:57:45 +0000
+++ breezy/git/__init__.py	2020-05-06 02:56:30 +0000
@@ -147,7 +147,7 @@
 def is_github_url(url):
     (scheme, user, password, host, port,
      path) = urlutils.parse_url(url)
-    return host == "github.com"
+    return host in ("github.com", "gopkg.in")
 
 
 class RemoteGitProber(Prober):

=== modified file 'breezy/git/branch.py'
--- breezy/git/branch.py	2020-02-21 03:58:42 +0000
+++ breezy/git/branch.py	2020-05-06 02:56:30 +0000
@@ -1198,7 +1198,7 @@
             return refs
         self.target.repository.send_pack(
             get_changed_refs,
-            self.source.repository._git.object_store.generate_pack_data)
+            self.source.repository._git.generate_pack_data)
         return result
 
 

=== modified file 'breezy/git/dir.py'
--- breezy/git/dir.py	2020-02-21 03:58:42 +0000
+++ breezy/git/dir.py	2020-05-06 02:56:30 +0000
@@ -223,6 +223,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)
@@ -248,18 +249,19 @@
                                                        mapping=default_mapping)
         for name, val in refs.items():
             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
 
@@ -294,6 +296,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/mapping.py'
--- breezy/git/mapping.py	2020-02-18 01:57:45 +0000
+++ breezy/git/mapping.py	2020-05-06 02:56:30 +0000
@@ -324,7 +324,9 @@
             commit.author_timezone = commit.commit_timezone
         if u'git-gpg-signature' in rev.properties:
             commit.gpgsig = rev.properties[u'git-gpg-signature'].encode(
-                'ascii')
+                'utf-8')
+        if u'git-gpg-signature-b64' in rev.properties:
+            commit.gpgsig = base64.b64decode(rev.properties[u'git-gpg-signature-b64'])
         commit.message = self._encode_commit_message(rev, rev.message,
                                                      encoding)
         if not isinstance(commit.message, bytes):
@@ -337,7 +339,8 @@
             mapping_properties = set(
                 [u'author', u'author-timezone', u'author-timezone-neg-utc',
                  u'commit-timezone-neg-utc', u'git-implicit-encoding',
-                 u'git-gpg-signature', u'git-explicit-encoding',
+                 u'git-gpg-signature', u'git-gpg-signature-b64',
+                 u'git-explicit-encoding',
                  u'author-timestamp', u'file-modes'])
             for k, v in rev.properties.items():
                 if k not in mapping_properties:
@@ -419,8 +422,12 @@
         if commit._commit_timezone_neg_utc:
             rev.properties[u'commit-timezone-neg-utc'] = ""
         if commit.gpgsig:
-            rev.properties[u'git-gpg-signature'] = commit.gpgsig.decode(
-                'ascii')
+            try:
+                rev.properties[u'git-gpg-signature'] = commit.gpgsig.decode(
+                    'utf-8')
+            except UnicodeDecodeError:
+                rev.properties[u'git-gpg-signature-b64'] = base64.b64encode(
+                    commit.gpgsig)
         if commit.mergetag:
             for i, tag in enumerate(commit.mergetag):
                 rev.properties[u'git-mergetag-%d' % i] = tag.as_raw_string()

=== modified file 'breezy/git/object_store.py'
--- breezy/git/object_store.py	2020-02-18 01:57:45 +0000
+++ breezy/git/object_store.py	2020-05-06 02:56:30 +0000
@@ -132,7 +132,7 @@
         self._cache[tree.get_revision_id()] = tree
 
 
-def _find_missing_bzr_revids(graph, want, have):
+def _find_missing_bzr_revids(graph, want, have, shallow=None):
     """Find the revisions that have to be pushed.
 
     :param get_parent_map: Function that returns the parents for a sequence
@@ -142,13 +142,17 @@
     :return: Set of revisions to fetch
     """
     handled = set(have)
+    if shallow:
+        # Shallows themselves still need to be fetched, but let's exclude their
+        # parents.
+        for ps in graph.get_parent_map(shallow).values():
+            handled.update(ps)
+    handled.add(NULL_REVISION)
     todo = set()
     for rev in want:
         extra_todo = graph.find_unique_ancestors(rev, handled)
         todo.update(extra_todo)
         handled.update(extra_todo)
-    if NULL_REVISION in todo:
-        todo.remove(NULL_REVISION)
     return todo
 
 
@@ -755,13 +759,15 @@
         else:
             raise KeyError(sha)
 
-    def generate_lossy_pack_data(self, have, want, progress=None,
+    def generate_lossy_pack_data(self, have, want, shallow=None,
+                                 progress=None,
                                  get_tagged=None, ofs_delta=False):
         return pack_objects_to_data(
-            self.generate_pack_contents(have, want, progress, get_tagged,
+            self.generate_pack_contents(have, want, progress=progress,
+                                        shallow=shallow, get_tagged=get_tagged,
                                         lossy=True))
 
-    def generate_pack_contents(self, have, want, progress=None,
+    def generate_pack_contents(self, have, want, shallow=None, progress=None,
                                ofs_delta=False, get_tagged=None, lossy=False):
         """Iterate over the contents of a pack file.
 
@@ -790,9 +796,18 @@
                     pending.add(type_data[0])
             except KeyError:
                 pass
+        shallows = set()
+        for commit_sha in shallow or set():
+            try:
+                for (type, type_data) in ret[commit_sha]:
+                    if type != "commit":
+                        raise AssertionError("Type was %s, not commit" % type)
+                    shallows.add(type_data[0])
+            except KeyError:
+                pass
 
         graph = self.repository.get_graph()
-        todo = _find_missing_bzr_revids(graph, pending, processed)
+        todo = _find_missing_bzr_revids(graph, pending, processed, shallow)
         ret = PackTupleIterable(self)
         with ui.ui_factory.nested_progress_bar() as pb:
             for i, revid in enumerate(graph.iter_topo_order(todo)):

=== modified file 'breezy/git/remote.py'
--- breezy/git/remote.py	2020-03-07 14:46:08 +0000
+++ breezy/git/remote.py	2020-05-06 02:56:30 +0000
@@ -606,10 +606,24 @@
                     ret[tag_name_to_ref(tagname)] = new_sha
             return ret
         with source_store.lock_read():
-            if lossy:
-                generate_pack_data = source_store.generate_lossy_pack_data
-            else:
-                generate_pack_data = source_store.generate_pack_data
+            def generate_pack_data(have, want, progress=None,
+                                   ofs_delta=True):
+                git_repo = getattr(source.repository, '_git', None)
+                if git_repo:
+                    shallow = git_repo.get_shallow()
+                else:
+                    shallow = None
+                if lossy:
+                    return source_store.generate_lossy_pack_data(
+                        have, want, shallow=shallow,
+                        progress=progress, ofs_delta=ofs_delta)
+                elif shallow:
+                    return source_store.generate_pack_data(
+                        have, want, shallow=shallow,
+                        progress=progress, ofs_delta=ofs_delta)
+                else:
+                    return source_store.generate_pack_data(
+                        have, want, progress=progress, ofs_delta=ofs_delta)
             new_refs = self.send_pack(get_changed_refs, generate_pack_data)
         push_result.new_revid = repo.lookup_foreign_revision_id(
             new_refs[actual_refname])
@@ -712,7 +726,7 @@
             raise NotGitRepository()
         elif response.status != 200:
             raise GitProtocolError("unexpected http resp %d for %s" %
-                                   (response.code, url))
+                                   (response.status, url))
 
         # TODO: Optimization available by adding `preload_content=False` to the
         # request and just passing the `read` method on instead of going via

=== modified file 'breezy/git/server.py'
--- breezy/git/server.py	2020-02-18 01:57:45 +0000
+++ breezy/git/server.py	2020-05-06 02:56:30 +0000
@@ -90,12 +90,19 @@
             have = self.object_store.find_common_revisions(graph_walker)
             if wants is None:
                 return
+            shallows = getattr(graph_walker, 'shallow', frozenset())
             if isinstance(self.object_store, BazaarObjectStore):
                 return self.object_store.generate_pack_contents(
-                    have, wants, progress, get_tagged=get_tagged, lossy=True)
+                    have, wants, shallow=shallows,
+                    progress=progress, get_tagged=get_tagged, lossy=True)
             else:
-                return self.object_store.generate_pack_contents(
-                    have, wants, progress)
+                if shallows:
+                    return self.object_store.generate_pack_contents(
+                        have, wants, shallow=shallows, progress=progress)
+                else:
+                    return self.object_store.generate_pack_contents(
+                        have, wants, progress=progress)
+
 
 
 class BzrTCPGitServer(TCPGitServer):

=== modified file 'breezy/git/tests/test_blackbox.py'
--- breezy/git/tests/test_blackbox.py	2020-03-22 01:35:14 +0000
+++ breezy/git/tests/test_blackbox.py	2020-05-06 02:56:30 +0000
@@ -347,7 +347,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)
@@ -359,7 +359,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)
@@ -371,7 +371,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-18 01:57:45 +0000
+++ breezy/git/tests/test_remote.py	2020-05-06 02:56:30 +0000
@@ -565,6 +565,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/git/transportgit.py'
--- breezy/git/transportgit.py	2020-02-18 01:57:45 +0000
+++ breezy/git/transportgit.py	2020-05-06 02:56:30 +0000
@@ -424,8 +424,10 @@
                     _mod_transport.get_transport_from_path(commondir)
         else:
             self._commontransport = self._controltransport
-        object_store = TransportObjectStore(
-            self._commontransport.clone(OBJECTDIR))
+        config = self.get_config()
+        object_store = TransportObjectStore.from_config(
+            self._commontransport.clone(OBJECTDIR),
+            config)
         if refs_text is not None:
             refs_container = InfoRefsContainer(BytesIO(refs_text))
             try:
@@ -512,6 +514,25 @@
         backends.extend(StackedConfig.default_backends())
         return StackedConfig(backends, writable=writable)
 
+    # Here for compatibility with dulwich < 0.19.17
+    def generate_pack_data(self, have, want, progress=None, ofs_delta=None):
+        """Generate pack data objects for a set of wants/haves.
+
+        Args:
+          have: List of SHA1s of objects that should not be sent
+          want: List of SHA1s of objects that should be sent
+          ofs_delta: Whether OFS deltas can be included
+          progress: Optional progress reporting method
+        """
+        shallow = self.get_shallow()
+        if shallow:
+            return self.object_store.generate_pack_data(
+                have, want, shallow=shallow,
+                progress=progress, ofs_delta=ofs_delta)
+        else:
+            return self.object_store.generate_pack_data(
+                have, want, progress=progress, ofs_delta=ofs_delta)
+
     def __repr__(self):
         return "<%s for %r>" % (self.__class__.__name__, self.transport)
 
@@ -544,16 +565,38 @@
 class TransportObjectStore(PackBasedObjectStore):
     """Git-style object store that exists on disk."""
 
-    def __init__(self, transport):
+    def __init__(self, transport,
+                 loose_compression_level=-1, pack_compression_level=-1):
         """Open an object store.
 
         :param transport: Transport to open data from
         """
         super(TransportObjectStore, self).__init__()
+        self.pack_compression_level = pack_compression_level
+        self.loose_compression_level = loose_compression_level
         self.transport = transport
         self.pack_transport = self.transport.clone(PACKDIR)
         self._alternates = None
 
+    @classmethod
+    def from_config(cls, path, config):
+        try:
+            default_compression_level = int(config.get(
+                (b'core', ), b'compression').decode())
+        except KeyError:
+            default_compression_level = -1
+        try:
+            loose_compression_level = int(config.get(
+                (b'core', ), b'looseCompression').decode())
+        except KeyError:
+            loose_compression_level = default_compression_level
+        try:
+            pack_compression_level = int(config.get(
+                (b'core', ), 'packCompression').decode())
+        except KeyError:
+            pack_compression_level = default_compression_level
+        return cls(path, loose_compression_level, pack_compression_level)
+
     def __eq__(self, other):
         if not isinstance(other, TransportObjectStore):
             return False
@@ -686,7 +729,14 @@
         path = urlutils.quote_from_bytes(osutils.pathjoin(dir, file))
         if self.transport.has(path):
             return  # Already there, no need to write again
-        self.transport.put_bytes(path, obj.as_legacy_object())
+        # Backwards compatibility with Dulwich < 0.20, which doesn't support
+        # the compression_level parameter.
+        if self.loose_compression_level not in (-1, None):
+            raw_string = obj.as_legacy_object(
+                compression_level=self.loose_compression_level)
+        else:
+            raw_string = obj.as_legacy_object()
+        self.transport.put_bytes(path, raw_string)
 
     def move_in_pack(self, f):
         """Move a specific file containing a pack into the pack directory.

=== modified file 'breezy/git/tree.py'
--- breezy/git/tree.py	2020-02-18 01:57:45 +0000
+++ breezy/git/tree.py	2020-05-06 02:56:30 +0000
@@ -1670,9 +1670,11 @@
                     e, osutils._fs_enc)
             if stat.S_ISDIR(st.st_mode):
                 blob = Tree()
-            else:
+            elif stat.S_ISREG(st.st_mode) or stat.S_ISLNK(st.st_mode):
                 blob = blob_from_path_and_stat(
                     target.abspath(e).encode(osutils._fs_enc), st)
+            else:
+                continue
             store.add_object(blob)
             np = np.encode('utf-8')
             blobs[np] = (blob.id, cleanup_mode(st.st_mode))

=== modified file 'breezy/git/workingtree.py'
--- breezy/git/workingtree.py	2020-02-21 03:58:42 +0000
+++ breezy/git/workingtree.py	2020-05-06 02:56:30 +0000
@@ -124,7 +124,7 @@
             index_path = os.path.join(self.basedir, relpath.decode('utf-8'), '.git', 'index')
         else:
             index_path = self.control_transport.local_abspath(
-                posixpath.join('modules', info[1], 'index'))
+                posixpath.join('modules', info[1].decode('utf-8'), 'index'))
         return Index(index_path)
 
     def lock_read(self):
@@ -814,7 +814,11 @@
                     ie = self._get_file_ie(name, path, value, dir_ids[parent])
                     yield (posixpath.relpath(path, from_dir), "V", ie.kind, ie)
                 else:
-                    ie = fk_entries[kind]()
+                    try:
+                        ie = fk_entries[kind]()
+                    except KeyError:
+                        # unsupported kind
+                        continue
                     yield (posixpath.relpath(path, from_dir),
                            ("I" if self.is_ignored(path) else "?"), kind, ie)
 

=== modified file 'breezy/info.py'
--- breezy/info.py	2020-02-18 01:57:45 +0000
+++ breezy/info.py	2020-05-06 02:56:30 +0000
@@ -455,7 +455,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/darcs/__init__.py'
--- breezy/plugins/darcs/__init__.py	2020-02-18 01:57:45 +0000
+++ breezy/plugins/darcs/__init__.py	2020-05-06 02:56:30 +0000
@@ -57,11 +57,11 @@
 
     def open(self, transport, _found=False):
         """Open this directory."""
-        raise DarcsUnsupportedError(self)
+        raise DarcsUnsupportedError()
 
     def check_support_status(self, allow_unsupported, recommend_upgrade=True,
                              basedir=None):
-        raise DarcsUnsupportedError(self)
+        raise DarcsUnsupportedError()
 
     def open(self, transport):
         # Raise NotBranchError if there is nothing there
@@ -73,11 +73,13 @@
 
     @classmethod
     def priority(klass, transport):
+        if 'darcs' in transport.base:
+            return 90
         return 100
 
     @classmethod
     def probe_transport(klass, transport):
-        if transport.has('_darcs'):
+        if transport.has('_darcs/format'):
             return DarcsDirFormat()
         raise errors.NotBranchError(path=transport.base)
 

=== modified file 'breezy/plugins/fastimport/tests/test_head_tracking.py'
--- breezy/plugins/fastimport/tests/test_head_tracking.py	2020-02-18 01:57:45 +0000
+++ breezy/plugins/fastimport/tests/test_head_tracking.py	2020-05-06 02:56:30 +0000
@@ -24,7 +24,7 @@
 
 import testtools
 
-from .reftracker import (
+from fastimport.reftracker import (
     RefTracker,
     )
 

=== modified file 'breezy/plugins/propose/__init__.py'
--- breezy/plugins/propose/__init__.py	2020-02-18 01:57:45 +0000
+++ breezy/plugins/propose/__init__.py	2020-05-06 02:56:30 +0000
@@ -40,3 +40,11 @@
 hosters.register_lazy(
     "gitlab", "breezy.plugins.propose.gitlabs",
     "GitLab")
+
+
+def test_suite():
+    from unittest import TestSuite
+    from .tests import test_suite
+    result = TestSuite()
+    result.addTest(test_suite())
+    return result

=== modified file 'breezy/plugins/propose/gitlabs.py'
--- breezy/plugins/propose/gitlabs.py	2020-03-22 01:35:14 +0000
+++ breezy/plugins/propose/gitlabs.py	2020-05-06 02:56:30 +0000
@@ -166,9 +166,15 @@
         raise NotGitLabUrl(url)
     path = path.strip('/')
     parts = path.split('/')
+    if len(parts) < 2:
+        raise NotMergeRequestUrl(host, url)
     if parts[-2] != 'merge_requests':
         raise NotMergeRequestUrl(host, url)
-    return host, '/'.join(parts[:-2]), int(parts[-1])
+    if parts[-3] == '-':
+        project_name = '/'.join(parts[:-3])
+    else:
+        project_name = '/'.join(parts[:-2])
+    return host, project_name, int(parts[-1])
 
 
 class GitLabMergeProposal(MergeProposal):
@@ -280,6 +286,10 @@
     def base_url(self):
         return self.transport.base
 
+    @property
+    def base_hostname(self):
+        return urlutils.parse_url(self.base_url)[3]
+
     def _api_request(self, method, path, fields=None, body=None):
         return self.transport.request(
             method, urlutils.join(self.base_url, 'api', 'v4', path),
@@ -374,6 +384,15 @@
             parameters['owner_id'] = urlutils.quote(owner, '')
         return self._list_paged(path, parameters, per_page=DEFAULT_PAGE_SIZE)
 
+    def _get_merge_request(self, project, merge_id):
+        path = 'projects/%s/merge_requests/%d' % (urlutils.quote(str(project), ''), merge_id)
+        response = self._api_request('GET', path)
+        if response.status == 403:
+            raise errors.PermissionDenied(response.text)
+        if response.status != 200:
+            raise errors.InvalidHttpResponse(path, response.text)
+        return json.loads(response.data)
+
     def _list_projects(self, owner):
         path = 'users/%s/projects' % urlutils.quote(str(owner), '')
         parameters = {}
@@ -390,7 +409,7 @@
     def _create_mergerequest(
             self, title, source_project_id, target_project_id,
             source_branch_name, target_branch_name, description,
-            labels=None):
+            labels=None, allow_collaboration=False):
         path = 'projects/%s/merge_requests' % source_project_id
         fields = {
             'title': title,
@@ -398,6 +417,7 @@
             'target_branch': target_branch_name,
             'target_project_id': target_project_id,
             'description': description,
+            'allow_collaboration': allow_collaboration,
             }
         if labels:
             fields['labels'] = labels
@@ -484,7 +504,7 @@
             (host, project, branch_name) = parse_gitlab_branch_url(branch)
         except NotGitLabUrl:
             return False
-        return (self.base_url == ('https://%s' % host))
+        return self.base_hostname == host
 
     def check(self):
         response = self._api_request('GET', 'user')
@@ -539,15 +559,15 @@
         except NotGitLabUrl:
             raise UnsupportedHoster(url)
         except NotMergeRequestUrl as e:
-            if self.base_url == ('https://%s' % e.host):
+            if self.base_hostname == e.host:
                 raise
             else:
                 raise UnsupportedHoster(url)
-        if self.base_url != ('https://%s' % host):
+        if self.base_hostname != host:
             raise UnsupportedHoster(url)
         project = self._get_project(project)
-        mr = project.mergerequests.get(merge_id)
-        return GitLabMergeProposal(mr)
+        mr = self._get_merge_request(project['path_with_namespace'], merge_id)
+        return GitLabMergeProposal(self, mr)
 
     def delete_project(self, project):
         path = 'projects/%s' % urlutils.quote(str(project), '')
@@ -623,7 +643,7 @@
         try:
             merge_request = self.gl._create_mergerequest(**kwargs)
         except MergeRequestExists:
-            raise ProposalExists(self.source_branch.user_url)
+            raise MergeProposalExists(self.source_branch.user_url)
         return GitLabMergeProposal(self.gl, merge_request)
 
 

=== added directory 'breezy/plugins/propose/tests'
=== added file 'breezy/plugins/propose/tests/__init__.py'
--- breezy/plugins/propose/tests/__init__.py	1970-01-01 00:00:00 +0000
+++ breezy/plugins/propose/tests/__init__.py	2020-05-06 02:56:30 +0000
@@ -0,0 +1,26 @@
+# Copyright (C) 2020 Jelmer Vernooij <[e-mail]>
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+from unittest import TestLoader, TestSuite
+
+
+def test_suite():
+    result = TestSuite()
+    from . import test_gitlab
+
+    loader = TestLoader()
+    result.addTests(loader.loadTestsFromModule(test_gitlab))
+    return result

=== added file 'breezy/plugins/propose/tests/test_gitlab.py'
--- breezy/plugins/propose/tests/test_gitlab.py	1970-01-01 00:00:00 +0000
+++ breezy/plugins/propose/tests/test_gitlab.py	2020-05-06 02:56:30 +0000
@@ -0,0 +1,52 @@
+# Copyright (C) 2020 Jelmer Vernooij <[e-mail]>
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+from breezy.tests import TestCase
+
+from breezy.plugins.propose.gitlabs import (
+    parse_gitlab_merge_request_url,
+    NotMergeRequestUrl,
+    NotGitLabUrl,
+    )
+
+
+class ParseGitLabMergeRequestUrlTests(TestCase):
+
+    def test_invalid(self):
+        self.assertRaises(
+            NotMergeRequestUrl, parse_gitlab_merge_request_url,
+            "https://salsa.debian.org/")
+        self.assertRaises(
+            NotGitLabUrl, parse_gitlab_merge_request_url,
+            "bzr://salsa.debian.org/")
+        self.assertRaises(
+            NotGitLabUrl, parse_gitlab_merge_request_url,
+            "https:///salsa.debian.org/")
+        self.assertRaises(
+            NotMergeRequestUrl, parse_gitlab_merge_request_url,
+            "https://salsa.debian.org/jelmer/salsa")
+
+    def test_old_style(self):
+        self.assertEqual(
+            ('salsa.debian.org', 'jelmer/salsa', 4),
+            parse_gitlab_merge_request_url(
+                'https://salsa.debian.org/jelmer/salsa/merge_requests/4'))
+
+    def test_new_style(self):
+        self.assertEqual(
+            ('salsa.debian.org', 'jelmer/salsa', 4),
+            parse_gitlab_merge_request_url(
+                'https://salsa.debian.org/jelmer/salsa/-/merge_requests/4'))

=== modified file 'breezy/plugins/weave_fmt/bzrdir.py'
--- breezy/plugins/weave_fmt/bzrdir.py	2020-02-21 03:58:42 +0000
+++ breezy/plugins/weave_fmt/bzrdir.py	2020-05-06 02:56:30 +0000
@@ -840,7 +840,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-05-06 02:56:30 +0000
@@ -51,6 +51,7 @@
         'test_check',
         'test_checkout',
         'test_clean_tree',
+        'test_clone',
         'test_command_encoding',
         'test_commit',
         'test_config',

=== modified file 'breezy/tests/blackbox/test_branch.py'
--- breezy/tests/blackbox/test_branch.py	2020-01-19 14:49:03 +0000
+++ breezy/tests/blackbox/test_branch.py	2020-05-06 02:56:30 +0000
@@ -107,6 +107,17 @@
         self.assertEqual('Branched 0 revisions.\n', err)
         self.assertPathExists('a')
 
+    def test_from_name(self):
+        """Branch from a colocated branch into a regular branch."""
+        os.mkdir('b')
+        tree = self.example_branch('b/a', format='development-colo')
+        tree.controldir.create_branch(name='somecolo')
+        out, err = self.run_bzr('branch -b somecolo %s' %
+                                local_path_to_url('b/a'))
+        self.assertEqual('', out)
+        self.assertEqual('Branched 0 revisions.\n', err)
+        self.assertPathExists('a')
+
     def test_branch_broken_pack(self):
         """branching with a corrupted pack file."""
         self.example_branch('a')

=== 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-05-06 02:56:30 +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-05-06 02:56:30 +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-05-06 02:56:30 +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-05-06 02:56:30 +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-05-06 02:56:30 +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/per_workingtree/test_changes_from.py'
--- breezy/tests/per_workingtree/test_changes_from.py	2019-06-30 12:59:05 +0000
+++ breezy/tests/per_workingtree/test_changes_from.py	2020-05-06 02:56:30 +0000
@@ -16,6 +16,8 @@
 
 """Test Tree.changes_from() for WorkingTree specific scenarios."""
 
+import socket
+
 from breezy import revision
 from breezy.tests.per_workingtree import TestCaseWithWorkingTree
 
@@ -54,3 +56,19 @@
         self.assertEqual([], d.renamed)
         self.assertEqual([], d.copied)
         self.assertEqual([], d.modified)
+
+    def test_socket(self):
+        s = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+        s.bind('tree/socketpath')
+        s.listen(1)
+        empty_tree = self.tree.branch.repository.revision_tree(
+            revision.NULL_REVISION)
+        d = self.tree.changes_from(
+            empty_tree, specific_files=['socketpath'],
+            want_unversioned=True)
+        self.assertEqual([], d.added)
+        self.assertEqual([], d.removed)
+        self.assertEqual([], d.renamed)
+        self.assertEqual([], d.copied)
+        self.assertEqual([], d.modified)
+        self.assertIn([x.path[1] for x in d.unversioned], [['socketpath'], []])

=== modified file 'breezy/tests/test_bzrdir.py'
--- breezy/tests/test_bzrdir.py	2020-01-19 03:22:04 +0000
+++ breezy/tests/test_bzrdir.py	2020-05-06 02:56:30 +0000
@@ -821,6 +821,20 @@
         self.assertEqual(os.path.realpath('topdir/foo'),
                          self.local_branch_path(branch))
 
+    def test_open_tree_or_branch_named(self):
+        tree = self.make_branch_and_tree('topdir')
+        self.assertRaises(
+            NotBranchError,
+            bzrdir.BzrDir.open_tree_or_branch, 'topdir', name='missing')
+        tree.branch.controldir.create_branch('named')
+        tree, branch = bzrdir.BzrDir.open_tree_or_branch('topdir', name='named')
+        self.assertEqual(os.path.realpath('topdir'),
+                         os.path.realpath(tree.basedir))
+        self.assertEqual(os.path.realpath('topdir'),
+                         self.local_branch_path(branch))
+        self.assertEqual(branch.name, 'named')
+        self.assertIs(tree.controldir, branch.controldir)
+
     def test_open_from_transport(self):
         # transport pointing at bzrdir should give a bzrdir with root transport
         # set to the given transport

=== modified file 'breezy/tests/test_config.py'
--- breezy/tests/test_config.py	2020-02-07 02:14:30 +0000
+++ breezy/tests/test_config.py	2020-05-06 02:56:30 +0000
@@ -1481,6 +1481,13 @@
         self.assertEqual("Robert Collins <[e-mail]>",
                          my_config.username())
 
+    def test_BRZ_EMAIL_OVERRIDES(self):
+        self.overrideEnv('BZR_EMAIL', "Robert Collins <[e-mail]>")
+        branch = FakeBranch()
+        my_config = config.BranchConfig(branch)
+        self.assertEqual("Robert Collins <[e-mail]>",
+                         my_config.username())
+
     def test_get_user_option_global(self):
         my_config = self.get_branch_config(global_config=sample_config_text)
         self.assertEqual('something',
@@ -4645,8 +4652,16 @@
 
     def test_default_email_uses_BRZ_EMAIL(self):
         conf = config.MemoryStack(b'email=[e-mail]')
-        # BRZ_EMAIL takes precedence over EMAIL
+        # BRZ_EMAIL takes precedence over BZR_EMAIL and EMAIL
         self.overrideEnv('BRZ_EMAIL', '[e-mail]')
+        self.overrideEnv('BZR_EMAIL', '[e-mail]')
+        self.overrideEnv('EMAIL', '[e-mail]')
+        self.assertEqual('[e-mail]', conf.get('email'))
+
+    def test_default_email_uses_BZR_EMAIL(self):
+        conf = config.MemoryStack(b'email=[e-mail]')
+        # BZR_EMAIL takes precedence over EMAIL
+        self.overrideEnv('BZR_EMAIL', '[e-mail]')
         self.overrideEnv('EMAIL', '[e-mail]')
         self.assertEqual('[e-mail]', conf.get('email'))
 

=== 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-05-06 02:56:30 +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 'breezy/transport/http/__init__.py'
--- breezy/transport/http/__init__.py	2020-02-18 01:57:45 +0000
+++ breezy/transport/http/__init__.py	2020-05-06 02:56:30 +0000
@@ -1811,10 +1811,14 @@
                 report_activity=self._report_activity, ca_certs=ca_certs)
 
     def request(self, method, url, fields=None, headers=None, **urlopen_kw):
+        body = urlopen_kw.pop('body', None)
         if fields is not None:
             data = urlencode(fields).encode()
+            if body is not None:
+                raise ValueError(
+                    'body and fields are mutually exclusive')
         else:
-            data = urlopen_kw.pop('body', None)
+            data = body
         if headers is None:
             headers = {}
         request = Request(method, url, data, headers)

=== modified file 'brz'
--- brz	2020-02-18 01:57:45 +0000
+++ brz	2020-05-06 02:56:30 +0000
@@ -78,30 +78,8 @@
             breezy._format_version_tuple(_script_version),
             __file__))
 
-
-import breezy.breakin
-breezy.breakin.hook_debugger_to_signal()
-
-import breezy.commands
-import breezy.trace
-
-
 if __name__ == '__main__':
-    with breezy.initialize():
-        exit_val = breezy.commands.main()
-        if profiling:
-            profile_imports.log_stack_info(sys.stderr)
-
-    # By this point we really have completed everything we want to do, and
-    # there's no point doing any additional cleanup.  Abruptly exiting here
-    # stops any background threads getting into trouble as code is unloaded,
-    # and it may also be slightly faster, through avoiding gc of objects that
-    # are just about to be discarded anyhow.  This does mean that atexit hooks
-    # won't run but we don't use them.  Also file buffers won't be flushed,
-    # but our policy is to always close files from a finally block. -- mbp 20070215
-    exitfunc = getattr(sys, "exitfunc", None)
-    if exitfunc is not None:
-        exitfunc()
-    os._exit(exit_val)
+    from breezy.__main__ import main
+    main()
 else:
     raise ImportError("The brz script cannot be imported.")

=== 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-05-06 02:56:30 +0000
@@ -73,6 +73,20 @@
  * 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)
+
+ * ``brz branch`` now accepts a ``-b`` flag with the
+   name of the colocated branch to sprout.
+   (Jelmer Vernooij, #1869977)
+
+ * Add a ``breezy.__main__`` module so that
+   ``python3 -m breezy`` works. (Jelmer Vernooij)
+
 Improvements
 ************
 
@@ -117,6 +131,10 @@
  * ``.git/config`` is now consulted to determine the users' identity
    for commits, and the gpg_signing_key. (Jelmer Vernooij)
 
+ * Ignore special files (fifos, block/character devices, sockets)
+   when finding changes in Git working trees. (Jelmer Vernooij, #1857244)
+
+
 Bug Fixes
 *********
 
@@ -154,6 +172,12 @@
 * Fix ``setup_ui=False`` when initializing Breezy.
   (Jelmer Vernooij, #1852647)
 
+* Fix backwards compatibility with Bazaar by supporting the
+  $BZR_EMAIL variable. (Jelmer Vernooij, #1869178)
+
+* Cope with non-ascii characters in Git signatures.
+  (Jelmer Vernooij, #1869533)
+
 Documentation
 *************
 

=== modified file 'doc/en/user-guide/setting_up_email.txt'
--- doc/en/user-guide/setting_up_email.txt	2017-07-30 16:59:50 +0000
+++ doc/en/user-guide/setting_up_email.txt	2020-05-06 02:56:30 +0000
@@ -30,7 +30,9 @@
 
 The order of precedence is
 
- 1. If the ``BZR_EMAIL`` environment variable is set.
+ 1. If the ``BRZ_EMAIL`` environment variable is set.
+ #. If the ``BZR_EMAIL`` environment variable is set, for backwards
+    compatibility with Bazaar.
  #. If an email is set for your current branch in the ``locations.conf``
     file.
  #. If an email is set four your current branch in the
@@ -90,7 +92,7 @@
 
 Setting email via environment variable
 --------------------------------------
-The final method Breezy will use is checking for the ``BZR_EMAIL``
+The final method Breezy will use is checking for the ``BRZ_EMAIL``
 and ``EMAIL`` environment variables.  Generally, you would use this
 method to override the email in a script context.  If you would like
 to set a general default, then please see the ini methods above.