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

[Jelmer Vernooij]

Merge lp:brz/3.1.

Merge lp:brz/3.1.

[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/722/

=== modified file 'breezy/branch.py'
--- breezy/branch.py	2020-02-18 01:57:45 +0000
+++ breezy/branch.py	2020-02-21 04:09:29 +0000
@@ -1188,7 +1188,8 @@
         if revno < 1 or revno > self.revno():
             raise errors.InvalidRevisionNumber(revno)
 
-    def clone(self, to_controldir, revision_id=None, repository_policy=None):
+    def clone(self, to_controldir, revision_id=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
@@ -1201,11 +1202,12 @@
         with self.lock_read(), result.lock_write():
             if repository_policy is not None:
                 repository_policy.configure_branch(result)
-            self.copy_content_into(result, revision_id=revision_id)
+            self.copy_content_into(
+                result, revision_id=revision_id, tag_selector=tag_selector)
         return result
 
     def sprout(self, to_controldir, revision_id=None, repository_policy=None,
-               repository=None, lossy=False):
+               repository=None, lossy=False, tag_selector=None):
         """Create a new line of development from the branch, into to_controldir.
 
         to_controldir controls the branch format.
@@ -1222,7 +1224,8 @@
         with self.lock_read(), result.lock_write():
             if repository_policy is not None:
                 repository_policy.configure_branch(result)
-            self.copy_content_into(result, revision_id=revision_id)
+            self.copy_content_into(
+                result, revision_id=revision_id, tag_selector=tag_selector)
             master_url = self.get_bound_location()
             if master_url is None:
                 result.set_parent(self.user_url)
@@ -1255,14 +1258,16 @@
                 revno = 1
         destination.set_last_revision_info(revno, revision_id)
 
-    def copy_content_into(self, destination, revision_id=None):
+    def copy_content_into(self, destination, revision_id=None, tag_selector=None):
         """Copy the content of self into destination.
 
         revision_id: if not None, the revision history in the new branch will
                      be truncated to end with revision_id.
+        tag_selector: Optional callback that receives a tag name
+            and should return a boolean to indicate whether a tag should be copied
         """
         return InterBranch.get(self, destination).copy_content_into(
-            revision_id=revision_id)
+            revision_id=revision_id, tag_selector=tag_selector)
 
     def update_references(self, target):
         if not self._format.supports_reference_locations:
@@ -1307,7 +1312,8 @@
 
     def create_clone_on_transport(self, to_transport, revision_id=None,
                                   stacked_on=None, create_prefix=False,
-                                  use_existing_dir=False, no_tree=None):
+                                  use_existing_dir=False, no_tree=None,
+                                  tag_selector=None):
         """Create a clone of this branch and its bzrdir.
 
         :param to_transport: The transport to clone onto.
@@ -1327,7 +1333,7 @@
         dir_to = self.controldir.clone_on_transport(
             to_transport, revision_id=revision_id, stacked_on=stacked_on,
             create_prefix=create_prefix, use_existing_dir=use_existing_dir,
-            no_tree=no_tree)
+            no_tree=no_tree, tag_selector=tag_selector)
         return dir_to.open_branch()
 
     def create_checkout(self, to_location, revision_id=None,
@@ -2054,7 +2060,7 @@
         raise NotImplementedError(klass._get_branch_formats_to_test)
 
     def pull(self, overwrite=False, stop_revision=None,
-             possible_transports=None, local=False):
+             possible_transports=None, local=False, tag_selector=None):
         """Mirror source into target branch.
 
         The target branch is considered to be 'local', having low latency.
@@ -2064,18 +2070,21 @@
         raise NotImplementedError(self.pull)
 
     def push(self, overwrite=False, stop_revision=None, lossy=False,
-             _override_hook_source_branch=None):
+             _override_hook_source_branch=None, tag_selector=None):
         """Mirror the source branch into the target branch.
 
         The source branch is considered to be 'local', having low latency.
         """
         raise NotImplementedError(self.push)
 
-    def copy_content_into(self, revision_id=None):
+    def copy_content_into(self, revision_id=None, tag_selector=None):
         """Copy the content of source into target
 
-        revision_id: if not None, the revision history in the new branch will
-                     be truncated to end with revision_id.
+        :param revision_id:
+            if not None, the revision history in the new branch will
+            be truncated to end with revision_id.
+        :param tag_selector: Optional callback that can decide
+            to copy or not copy tags.
         """
         raise NotImplementedError(self.copy_content_into)
 
@@ -2122,7 +2131,7 @@
             return format._custom_format
         return format
 
-    def copy_content_into(self, revision_id=None):
+    def copy_content_into(self, revision_id=None, tag_selector=None):
         """Copy the content of source into target
 
         revision_id: if not None, the revision history in the new branch will
@@ -2139,7 +2148,7 @@
                 if parent:
                     self.target.set_parent(parent)
             if self.source._push_should_merge_tags():
-                self.source.tags.merge_to(self.target.tags)
+                self.source.tags.merge_to(self.target.tags, selector=tag_selector)
 
     def fetch(self, stop_revision=None, limit=None, lossy=False):
         if self.target.base == self.source.base:
@@ -2200,7 +2209,8 @@
 
     def pull(self, overwrite=False, stop_revision=None,
              possible_transports=None, run_hooks=True,
-             _override_hook_target=None, local=False):
+             _override_hook_target=None, local=False,
+             tag_selector=None):
         """Pull from source into self, updating my master if any.
 
         :param run_hooks: Private parameter - if false, this branch
@@ -2231,15 +2241,17 @@
             if master_branch:
                 # pull from source into master.
                 master_branch.pull(
-                    self.source, overwrite, stop_revision, run_hooks=False)
+                    self.source, overwrite, stop_revision, run_hooks=False,
+                    tag_selector=tag_selector)
             return self._pull(
                 overwrite, stop_revision, _hook_master=master_branch,
                 run_hooks=run_hooks,
                 _override_hook_target=_override_hook_target,
-                merge_tags_to_master=not source_is_master)
+                merge_tags_to_master=not source_is_master,
+                tag_selector=tag_selector)
 
     def push(self, overwrite=False, stop_revision=None, lossy=False,
-             _override_hook_source_branch=None):
+             _override_hook_source_branch=None, tag_selector=None):
         """See InterBranch.push.
 
         This is the basic concrete implementation of push()
@@ -2271,18 +2283,21 @@
                 with master_branch.lock_write():
                     # push into the master from the source branch.
                     master_inter = InterBranch.get(self.source, master_branch)
-                    master_inter._basic_push(overwrite, stop_revision)
+                    master_inter._basic_push(
+                        overwrite, stop_revision, tag_selector=tag_selector)
                     # and push into the target branch from the source. Note
                     # that we push from the source branch again, because it's
                     # considered the highest bandwidth repository.
-                    result = self._basic_push(overwrite, stop_revision)
+                    result = self._basic_push(
+                        overwrite, stop_revision, tag_selector=tag_selector)
                     result.master_branch = master_branch
                     result.local_branch = self.target
                     _run_hooks()
             else:
                 master_branch = None
                 # no master branch
-                result = self._basic_push(overwrite, stop_revision)
+                result = self._basic_push(
+                    overwrite, stop_revision, tag_selector=tag_selector)
                 # TODO: Why set master_branch and local_branch if there's no
                 # binding?  Maybe cleaner to just leave them unset? -- mbp
                 # 20070504
@@ -2291,7 +2306,7 @@
                 _run_hooks()
             return result
 
-    def _basic_push(self, overwrite, stop_revision):
+    def _basic_push(self, overwrite, stop_revision, tag_selector=None):
         """Basic implementation of push without bound branches or hooks.
 
         Must be called with source read locked and target write locked.
@@ -2310,7 +2325,7 @@
         if self.source._push_should_merge_tags():
             result.tag_updates, result.tag_conflicts = (
                 self.source.tags.merge_to(
-                    self.target.tags, "tags" in overwrite))
+                    self.target.tags, "tags" in overwrite, selector=tag_selector))
         self.update_references()
         result.new_revno, result.new_revid = self.target.last_revision_info()
         return result
@@ -2318,7 +2333,7 @@
     def _pull(self, overwrite=False, stop_revision=None,
               possible_transports=None, _hook_master=None, run_hooks=True,
               _override_hook_target=None, local=False,
-              merge_tags_to_master=True):
+              merge_tags_to_master=True, tag_selector=None):
         """See Branch.pull.
 
         This function is the core worker, used by GenericInterBranch.pull to
@@ -2362,7 +2377,8 @@
             result.tag_updates, result.tag_conflicts = (
                 self.source.tags.merge_to(
                     self.target.tags, "tags" in overwrite,
-                    ignore_master=not merge_tags_to_master))
+                    ignore_master=not merge_tags_to_master,
+                    selector=tag_selector))
             self.update_references()
             result.new_revno, result.new_revid = (
                 self.target.last_revision_info())

=== modified file 'breezy/bzr/branch.py'
--- breezy/bzr/branch.py	2020-02-18 01:57:45 +0000
+++ breezy/bzr/branch.py	2020-02-21 04:09:29 +0000
@@ -27,6 +27,8 @@
     lockdir,
     rio,
     shelf,
+    )
+from breezy.bzr import (
     tag as _mod_tag,
     )
 """)
@@ -1022,7 +1024,7 @@
     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):
+                  repository_policy=None, tag_selector=None):
             """See Branch.clone()."""
             return format.initialize(to_bzrdir, target_branch=a_branch)
             # cannot obey revision_id limits when cloning a reference ...

=== modified file 'breezy/bzr/bzrdir.py'
--- breezy/bzr/bzrdir.py	2020-02-18 01:57:45 +0000
+++ breezy/bzr/bzrdir.py	2020-02-21 04:09:29 +0000
@@ -141,7 +141,8 @@
 
     def clone_on_transport(self, transport, revision_id=None,
                            force_new_repo=False, preserve_stacking=False, stacked_on=None,
-                           create_prefix=False, use_existing_dir=True, no_tree=False):
+                           create_prefix=False, use_existing_dir=True, no_tree=False,
+                           tag_selector=None):
         """Clone this bzrdir and its contents to transport verbatim.
 
         :param transport: The transport for the location to produce the clone
@@ -233,7 +234,8 @@
         if local_branch is not None:
             local_branch.clone(
                 result, revision_id=revision_id,
-                repository_policy=repository_policy)
+                repository_policy=repository_policy,
+                tag_selector=tag_selector)
         try:
             # Cheaper to check if the target is not local, than to try making
             # the tree and fail.

=== modified file 'breezy/bzr/knitpack_repo.py'
--- breezy/bzr/knitpack_repo.py	2020-02-18 01:57:45 +0000
+++ breezy/bzr/knitpack_repo.py	2020-02-21 04:09:29 +0000
@@ -264,8 +264,6 @@
 class RepositoryFormatKnitPack5(RepositoryFormatPack):
     """Repository that supports external references to allow stacking.
 
-    New in release 1.6.
-
     Supports external lookups, which results in non-truncated ghosts after
     reconcile compared to pack-0.92 formats.
     """
@@ -303,8 +301,6 @@
 class RepositoryFormatKnitPack5RichRoot(RepositoryFormatPack):
     """A repository with rich roots and stacking.
 
-    New in release 1.6.1.
-
     Supports stacking on other repositories, allowing data to be accessed
     without being stored locally.
     """
@@ -344,8 +340,6 @@
 class RepositoryFormatKnitPack5RichRootBroken(RepositoryFormatPack):
     """A repository with rich roots and external references.
 
-    New in release 1.6.
-
     Supports external lookups, which results in non-truncated ghosts after
     reconcile compared to pack-0.92 formats.
 

=== modified file 'breezy/bzr/remote.py'
--- breezy/bzr/remote.py	2020-02-18 01:57:45 +0000
+++ breezy/bzr/remote.py	2020-02-21 04:09:29 +0000
@@ -4019,12 +4019,12 @@
                 source, overwrite=overwrite, stop_revision=stop_revision,
                 _override_hook_target=self, **kwargs)
 
-    def push(self, target, overwrite=False, stop_revision=None, lossy=False):
+    def push(self, target, overwrite=False, stop_revision=None, lossy=False, tag_selector=None):
         with self.lock_read():
             self._ensure_real()
             return self._real_branch.push(
                 target, overwrite=overwrite, stop_revision=stop_revision, lossy=lossy,
-                _override_hook_source_branch=self)
+                _override_hook_source_branch=self, tag_selector=tag_selector)
 
     def peek_lock_mode(self):
         return self._lock_mode

=== added file 'breezy/bzr/tag.py'
--- breezy/bzr/tag.py	1970-01-01 00:00:00 +0000
+++ breezy/bzr/tag.py	2020-02-21 04:09:29 +0000
@@ -0,0 +1,113 @@
+# Copyright (C) 2005-2012 Canonical Ltd
+# Copyright (C) 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
+
+from ..tag import Tags
+
+from .. import (
+    bencode,
+    errors,
+    trace,
+    )
+
+
+class BasicTags(Tags):
+    """Tag storage in an unversioned branch control file.
+    """
+
+    def set_tag(self, tag_name, tag_target):
+        """Add a tag definition to the branch.
+
+        Behaviour if the tag is already present is not defined (yet).
+        """
+        # all done with a write lock held, so this looks atomic
+        with self.branch.lock_write():
+            master = self.branch.get_master_branch()
+            if master is not None:
+                master.tags.set_tag(tag_name, tag_target)
+            td = self.get_tag_dict()
+            td[tag_name] = tag_target
+            self._set_tag_dict(td)
+
+    def lookup_tag(self, tag_name):
+        """Return the referent string of a tag"""
+        td = self.get_tag_dict()
+        try:
+            return td[tag_name]
+        except KeyError:
+            raise errors.NoSuchTag(tag_name)
+
+    def get_tag_dict(self):
+        with self.branch.lock_read():
+            try:
+                tag_content = self.branch._get_tags_bytes()
+            except errors.NoSuchFile:
+                # ugly, but only abentley should see this :)
+                trace.warning('No branch/tags file in %s.  '
+                              'This branch was probably created by bzr 0.15pre.  '
+                              'Create an empty file to silence this message.'
+                              % (self.branch, ))
+                return {}
+            return self._deserialize_tag_dict(tag_content)
+
+    def delete_tag(self, tag_name):
+        """Delete a tag definition.
+        """
+        with self.branch.lock_write():
+            d = self.get_tag_dict()
+            try:
+                del d[tag_name]
+            except KeyError:
+                raise errors.NoSuchTag(tag_name)
+            master = self.branch.get_master_branch()
+            if master is not None:
+                try:
+                    master.tags.delete_tag(tag_name)
+                except errors.NoSuchTag:
+                    pass
+            self._set_tag_dict(d)
+
+    def _set_tag_dict(self, new_dict):
+        """Replace all tag definitions
+
+        WARNING: Calling this on an unlocked branch will lock it, and will
+        replace the tags without warning on conflicts.
+
+        :param new_dict: Dictionary from tag name to target.
+        """
+        return self.branch._set_tags_bytes(self._serialize_tag_dict(new_dict))
+
+    def _serialize_tag_dict(self, tag_dict):
+        td = dict((k.encode('utf-8'), v)
+                  for k, v in tag_dict.items())
+        return bencode.bencode(td)
+
+    def _deserialize_tag_dict(self, tag_content):
+        """Convert the tag file into a dictionary of tags"""
+        # was a special case to make initialization easy, an empty definition
+        # is an empty dictionary
+        if tag_content == b'':
+            return {}
+        try:
+            r = {}
+            for k, v in bencode.bdecode(tag_content).items():
+                r[k.decode('utf-8')] = v
+            return r
+        except ValueError as e:
+            raise ValueError("failed to deserialize tag dictionary %r: %s"
+                             % (tag_content, e))

=== modified file 'breezy/controldir.py'
--- breezy/controldir.py	2020-02-18 01:57:45 +0000
+++ breezy/controldir.py	2020-02-21 04:09:29 +0000
@@ -398,7 +398,8 @@
         raise NotImplementedError(self.sprout)
 
     def push_branch(self, source, revision_id=None, overwrite=False,
-                    remember=False, create_prefix=False, lossy=False):
+                    remember=False, create_prefix=False, lossy=False,
+                    tag_selector=None):
         """Push the source branch into this ControlDir."""
         br_to = None
         # If we can open a branch, use its direct repository, otherwise see
@@ -422,7 +423,9 @@
                 # revision
                 revision_id = source.last_revision()
             repository_to.fetch(source.repository, revision_id=revision_id)
-            br_to = source.sprout(self, revision_id=revision_id, lossy=lossy)
+            br_to = source.sprout(
+                self, revision_id=revision_id, lossy=lossy,
+                tag_selector=tag_selector)
             if source.get_push_location() is None or remember:
                 # FIXME: Should be done only if we succeed ? -- vila 2012-01-18
                 source.set_push_location(br_to.base)
@@ -442,17 +445,19 @@
                 tree_to = self.open_workingtree()
             except errors.NotLocalUrl:
                 push_result.branch_push_result = source.push(
-                    br_to, overwrite, stop_revision=revision_id, lossy=lossy)
+                    br_to, overwrite, stop_revision=revision_id, lossy=lossy,
+                    tag_selector=tag_selector)
                 push_result.workingtree_updated = False
             except errors.NoWorkingTree:
                 push_result.branch_push_result = source.push(
-                    br_to, overwrite, stop_revision=revision_id, lossy=lossy)
+                    br_to, overwrite, stop_revision=revision_id, lossy=lossy,
+                    tag_selector=tag_selector)
                 push_result.workingtree_updated = None  # Not applicable
             else:
                 with tree_to.lock_write():
                     push_result.branch_push_result = source.push(
                         tree_to.branch, overwrite, stop_revision=revision_id,
-                        lossy=lossy)
+                        lossy=lossy, tag_selector=tag_selector)
                     tree_to.update()
                 push_result.workingtree_updated = True
             push_result.old_revno = push_result.branch_push_result.old_revno
@@ -491,7 +496,7 @@
         raise NotImplementedError(self.check_conversion_target)
 
     def clone(self, url, revision_id=None, force_new_repo=False,
-              preserve_stacking=False):
+              preserve_stacking=False, tag_selector=None):
         """Clone this controldir and its contents to url verbatim.
 
         :param url: The url create the clone at.  If url's last component does
@@ -507,11 +512,13 @@
         return self.clone_on_transport(_mod_transport.get_transport(url),
                                        revision_id=revision_id,
                                        force_new_repo=force_new_repo,
-                                       preserve_stacking=preserve_stacking)
+                                       preserve_stacking=preserve_stacking,
+                                       tag_selector=tag_selector)
 
     def clone_on_transport(self, transport, revision_id=None,
                            force_new_repo=False, preserve_stacking=False, stacked_on=None,
-                           create_prefix=False, use_existing_dir=True, no_tree=False):
+                           create_prefix=False, use_existing_dir=True, no_tree=False,
+                           tag_selector=None):
         """Clone this controldir and its contents to transport verbatim.
 
         :param transport: The transport for the location to produce the clone

=== modified file 'breezy/git/branch.py'
--- breezy/git/branch.py	2020-02-18 01:57:45 +0000
+++ breezy/git/branch.py	2020-02-21 04:09:29 +0000
@@ -41,7 +41,6 @@
     lock,
     repository as _mod_repository,
     revision,
-    tag,
     trace,
     transport,
     urlutils,
@@ -50,6 +49,10 @@
 from ..revision import (
     NULL_REVISION,
     )
+from ..tag import (
+    Tags,
+    InterTags,
+    )
 from ..trace import (
     is_quiet,
     mutter,
@@ -111,44 +114,75 @@
         return self._lookup_revno(self.new_revid)
 
 
-class GitTags(tag.BasicTags):
-    """Ref-based tag dictionary."""
-
-    def __init__(self, branch):
-        self.branch = branch
-        self.repository = branch.repository
-
-    def _merge_to_remote_git(self, target_repo, source_tag_refs,
-                             overwrite=False):
+class InterTagsFromGitToRemoteGit(InterTags):
+
+    @classmethod
+    def is_compatible(klass, source, target):
+        if not isinstance(source, GitTags):
+            return False
+        if not isinstance(target, GitTags):
+            return False
+        if getattr(target.branch.repository, "_git", None) is not None:
+            return False
+        return True
+
+    def merge(self, overwrite=False, ignore_master=False, selector=None):
+        if self.source.branch.repository.has_same_location(self.target.branch.repository):
+            return {}, []
         updates = {}
         conflicts = []
+        source_tag_refs = self.source.branch.get_tag_refs()
 
         def get_changed_refs(old_refs):
             ret = dict(old_refs)
             for ref_name, tag_name, peeled, unpeeled in (
                     source_tag_refs.iteritems()):
+                if selector and not selector(tag_name):
+                    continue
                 if old_refs.get(ref_name) == unpeeled:
                     pass
                 elif overwrite or ref_name not in old_refs:
                     ret[ref_name] = unpeeled
-                    updates[tag_name] = target_repo.lookup_foreign_revision_id(
+                    updates[tag_name] = self.target.branch.repository.lookup_foreign_revision_id(
                         peeled)
+                    self.target.branch._tag_refs = None
                 else:
                     conflicts.append(
                         (tag_name,
                          self.repository.lookup_foreign_revision_id(peeled),
-                         target_repo.lookup_foreign_revision_id(
+                         self.target.branch.repository.lookup_foreign_revision_id(
                              old_refs[ref_name])))
             return ret
-        target_repo.controldir.send_pack(
+        self.target.branch.repository.controldir.send_pack(
             get_changed_refs, lambda have, want: [])
-        return updates, conflicts
-
-    def _merge_to_local_git(self, target_repo, source_tag_refs,
-                            overwrite=False):
+        return updates, set(conflicts)
+
+
+class InterTagsFromGitToLocalGit(InterTags):
+
+    @classmethod
+    def is_compatible(klass, source, target):
+        if not isinstance(source, GitTags):
+            return False
+        if not isinstance(target, GitTags):
+            return False
+        if getattr(target.branch.repository, "_git", None) is None:
+            return False
+        return True
+
+    def merge(self, overwrite=False, ignore_master=False, selector=None):
+        if self.source.branch.repository.has_same_location(self.target.branch.repository):
+            return {}, []
+
         conflicts = []
         updates = {}
+        source_tag_refs = self.source.branch.get_tag_refs()
+
+        target_repo = self.target.branch.repository
+
         for ref_name, tag_name, peeled, unpeeled in source_tag_refs:
+            if selector and not selector(tag_name):
+                continue
             if target_repo._git.refs.get(ref_name) == unpeeled:
                 pass
             elif overwrite or ref_name not in target_repo._git.refs:
@@ -164,9 +198,10 @@
                                   tag_name)
                     continue
                 target_repo._git.refs[ref_name] = unpeeled or peeled
+                self.target.branch._tag_refs = None
             else:
                 try:
-                    source_revid = self.repository.lookup_foreign_revision_id(
+                    source_revid = self.source.branch.repository.lookup_foreign_revision_id(
                         peeled)
                     target_revid = target_repo.lookup_foreign_revision_id(
                         target_repo._git.refs[ref_name])
@@ -179,32 +214,54 @@
                                   tag_name)
                     continue
                 conflicts.append((tag_name, source_revid, target_revid))
-        return updates, conflicts
-
-    def _merge_to_git(self, to_tags, source_tag_refs, overwrite=False):
-        target_repo = to_tags.repository
-        if self.repository.has_same_location(target_repo):
-            return {}, []
-        try:
-            if getattr(target_repo, "_git", None):
-                return self._merge_to_local_git(
-                    target_repo, source_tag_refs, overwrite)
-            else:
-                return self._merge_to_remote_git(
-                    target_repo, source_tag_refs, overwrite)
-        finally:
-            to_tags.branch._tag_refs = None
-
-    def _merge_to_non_git(self, to_tags, source_tag_refs, overwrite=False):
+        return updates, set(conflicts)
+
+
+class InterTagsFromGitToNonGit(InterTags):
+
+    @classmethod
+    def is_compatible(klass, source, target):
+        if not isinstance(source, GitTags):
+            return False
+        if isinstance(target, GitTags):
+            return False
+        return True
+
+    def merge(self, overwrite=False, ignore_master=False, selector=None):
+        """See Tags.merge_to."""
+        source_tag_refs = self.source.branch.get_tag_refs()
+        if ignore_master:
+            master = None
+        else:
+            master = self.target.branch.get_master_branch()
+        with contextlib.ExitStack() as es:
+            if master is not None:
+                es.enter_context(master.lock_write())
+            updates, conflicts = self._merge_to(
+                self.target, source_tag_refs, overwrite=overwrite,
+                selector=selector)
+            if master is not None:
+                extra_updates, extra_conflicts = self._merge_to(
+                    master.tags, overwrite=overwrite,
+                    source_tag_refs=source_tag_refs,
+                    ignore_master=ignore_master, selector=selector)
+                updates.update(extra_updates)
+                conflicts.update(extra_conflicts)
+            return updates, conflicts
+
+    def _merge_to(self, to_tags, source_tag_refs, overwrite=False,
+                  selector=None):
         unpeeled_map = defaultdict(set)
         conflicts = []
         updates = {}
         result = dict(to_tags.get_tag_dict())
         for ref_name, tag_name, peeled, unpeeled in source_tag_refs:
+            if selector and not selector(tag_name):
+                continue
             if unpeeled is not None:
                 unpeeled_map[peeled].add(unpeeled)
             try:
-                bzr_revid = self.branch.lookup_foreign_revision_id(peeled)
+                bzr_revid = self.source.branch.lookup_foreign_revision_id(peeled)
             except NotCommitError:
                 continue
             if result.get(tag_name) == bzr_revid:
@@ -219,36 +276,20 @@
             map_file = UnpeelMap.from_repository(to_tags.branch.repository)
             map_file.update(unpeeled_map)
             map_file.save_in_repository(to_tags.branch.repository)
-        return updates, conflicts
-
-    def merge_to(self, to_tags, overwrite=False, ignore_master=False,
-                 source_tag_refs=None):
-        """See Tags.merge_to."""
-        if source_tag_refs is None:
-            source_tag_refs = self.branch.get_tag_refs()
-        if self == to_tags:
-            return {}, []
-        if isinstance(to_tags, GitTags):
-            return self._merge_to_git(to_tags, source_tag_refs,
-                                      overwrite=overwrite)
-        else:
-            if ignore_master:
-                master = None
-            else:
-                master = to_tags.branch.get_master_branch()
-            with contextlib.ExitStack() as es:
-                if master is not None:
-                    es.enter_context(master.lock_write())
-                updates, conflicts = self._merge_to_non_git(
-                    to_tags, source_tag_refs, overwrite=overwrite)
-                if master is not None:
-                    extra_updates, extra_conflicts = self.merge_to(
-                        master.tags, overwrite=overwrite,
-                        source_tag_refs=source_tag_refs,
-                        ignore_master=ignore_master)
-                    updates.update(extra_updates)
-                    conflicts += extra_conflicts
-                return updates, conflicts
+        return updates, set(conflicts)
+
+
+InterTags.register_optimiser(InterTagsFromGitToRemoteGit)
+InterTags.register_optimiser(InterTagsFromGitToLocalGit)
+InterTags.register_optimiser(InterTagsFromGitToNonGit)
+
+
+class GitTags(Tags):
+    """Ref-based tag dictionary."""
+
+    def __init__(self, branch):
+        self.branch = branch
+        self.repository = branch.repository
 
     def get_tag_dict(self):
         ret = {}
@@ -262,6 +303,15 @@
                 ret[tag_name] = bzr_revid
         return ret
 
+    def lookup_tag(self, tag_name):
+        """Return the referent string of a tag"""
+        # TODO(jelmer): Replace with something more efficient for local tags.
+        td = self.get_tag_dict()
+        try:
+            return td[tag_name]
+        except KeyError:
+            raise errors.NoSuchTag(tag_name)
+
 
 class LocalGitTagDict(GitTags):
     """Dictionary with tags in a local repository."""
@@ -612,9 +662,10 @@
                 return revision.NULL_REVISION
             return self.lookup_foreign_revision_id(self.head)
 
-    def _basic_push(self, target, overwrite=False, stop_revision=None):
+    def _basic_push(self, target, overwrite=False, stop_revision=None,
+                    tag_selector=None):
         return branch.InterBranch.get(self, target)._basic_push(
-            overwrite, stop_revision)
+            overwrite, stop_revision, tag_selector=tag_selector)
 
     def lookup_foreign_revision_id(self, foreign_revid):
         try:
@@ -934,7 +985,7 @@
             stop_revision, fetch_tags=fetch_tags, limit=limit, lossy=lossy)
         return _mod_repository.FetchResult()
 
-    def fetch_objects(self, stop_revision, fetch_tags, limit=None, lossy=False):
+    def fetch_objects(self, stop_revision, fetch_tags, limit=None, lossy=False, tag_selector=None):
         interrepo = self._get_interrepo(self.source, self.target)
         if fetch_tags is None:
             c = self.source.get_config_stack()
@@ -952,7 +1003,7 @@
             else:
                 self._last_revid = stop_revision
             real = interrepo.get_determine_wants_revids(
-                [self._last_revid], include_tags=fetch_tags)
+                [self._last_revid], include_tags=fetch_tags, tag_selector=tag_selector)
             return real(heads)
         pack_hint, head, refs = interrepo.fetch_objects(
             determine_wants, self.source.mapping, limit=limit,
@@ -962,8 +1013,8 @@
             self.target.repository.pack(hint=pack_hint)
         return head, refs
 
-    def _update_revisions(self, stop_revision=None, overwrite=False):
-        head, refs = self.fetch_objects(stop_revision, fetch_tags=None)
+    def _update_revisions(self, stop_revision=None, overwrite=False, tag_selector=None):
+        head, refs = self.fetch_objects(stop_revision, fetch_tags=None, tag_selector=tag_selector)
         if overwrite:
             prev_last_revid = None
         else:
@@ -988,7 +1039,7 @@
             pass
 
     def _basic_pull(self, stop_revision, overwrite, run_hooks,
-                    _override_hook_target, _hook_master):
+                    _override_hook_target, _hook_master, tag_selector=None):
         if overwrite is True:
             overwrite = set(["history", "tags"])
         elif not overwrite:
@@ -1005,7 +1056,8 @@
             (result.old_revno, result.old_revid) = \
                 self.target.last_revision_info()
             result.new_git_head, remote_refs = self._update_revisions(
-                stop_revision, overwrite=("history" in overwrite))
+                stop_revision, overwrite=("history" in overwrite),
+                tag_selector=tag_selector)
             tags_ret = self.source.tags.merge_to(
                 self.target.tags, ("tags" in overwrite), ignore_master=True)
             if isinstance(tags_ret, tuple):
@@ -1028,7 +1080,7 @@
 
     def pull(self, overwrite=False, stop_revision=None,
              possible_transports=None, _hook_master=None, run_hooks=True,
-             _override_hook_target=None, local=False):
+             _override_hook_target=None, local=False, tag_selector=None):
         """See Branch.pull.
 
         :param _hook_master: Private parameter - set the branch to
@@ -1066,9 +1118,10 @@
                 master_branch = None
             return self._basic_pull(stop_revision, overwrite, run_hooks,
                                     _override_hook_target,
-                                    _hook_master=master_branch)
+                                    _hook_master=master_branch,
+                                    tag_selector=tag_selector)
 
-    def _basic_push(self, overwrite, stop_revision):
+    def _basic_push(self, overwrite, stop_revision, tag_selector=None):
         if overwrite is True:
             overwrite = set(["history", "tags"])
         elif not overwrite:
@@ -1078,9 +1131,11 @@
         result.target_branch = self.target
         result.old_revno, result.old_revid = self.target.last_revision_info()
         result.new_git_head, remote_refs = self._update_revisions(
-            stop_revision, overwrite=("history" in overwrite))
+            stop_revision, overwrite=("history" in overwrite),
+            tag_selector=tag_selector)
         tags_ret = self.source.tags.merge_to(
-            self.target.tags, "tags" in overwrite, ignore_master=True)
+            self.target.tags, "tags" in overwrite, ignore_master=True,
+            selector=tag_selector)
         (result.tag_updates, result.tag_conflicts) = tags_ret
         result.new_revno, result.new_revid = self.target.last_revision_info()
         self.update_references(revid=result.new_revid)
@@ -1109,7 +1164,7 @@
         return (isinstance(source, LocalGitBranch) and
                 isinstance(target, RemoteGitBranch))
 
-    def _basic_push(self, overwrite, stop_revision):
+    def _basic_push(self, overwrite, stop_revision, tag_selector=None):
         result = GitBranchPushResult()
         result.source_branch = self.source
         result.target_branch = self.target
@@ -1134,6 +1189,8 @@
             result.new_revid = stop_revision
             for name, sha in (
                     self.source.repository._git.refs.as_dict(b"refs/tags").items()):
+                if tag_selector and not tag_selector(name):
+                    continue
                 if sha not in self.source.repository._git:
                     trace.mutter('Ignoring missing SHA: %s', sha)
                     continue
@@ -1173,7 +1230,7 @@
         interrepo.fetch_objects(determine_wants, limit=limit, lossy=lossy)
         return _mod_repository.FetchResult()
 
-    def _basic_push(self, overwrite=False, stop_revision=None):
+    def _basic_push(self, overwrite=False, stop_revision=None, tag_selector=None):
         if overwrite is True:
             overwrite = set(["history", "tags"])
         elif not overwrite:
@@ -1189,8 +1246,8 @@
             other_branch=self.source)
         tags_ret = self.source.tags.merge_to(
             self.target.tags,
-            source_tag_refs=remote_refs_dict_to_tag_refs(refs),
-            overwrite=("tags" in overwrite))
+            overwrite=("tags" in overwrite),
+            selector=tag_selector)
         if isinstance(tags_ret, tuple):
             (result.tag_updates, result.tag_conflicts) = tags_ret
         else:
@@ -1218,7 +1275,8 @@
         return result.refs, stop_revision
 
     def pull(self, stop_revision=None, overwrite=False,
-             possible_transports=None, run_hooks=True, local=False):
+             possible_transports=None, run_hooks=True, local=False,
+             tag_selector=None):
         # This type of branch can't be bound.
         if local:
             raise errors.LocalRequiresBoundBranch()
@@ -1239,7 +1297,7 @@
                 other_branch=self.source)
             tags_ret = self.source.tags.merge_to(
                 self.target.tags, overwrite=("tags" in overwrite),
-                source_tag_refs=remote_refs_dict_to_tag_refs(refs))
+                selector=tag_selector)
             if isinstance(tags_ret, tuple):
                 (result.tag_updates, result.tag_conflicts) = tags_ret
             else:
@@ -1307,7 +1365,7 @@
                     refs[ref] = (None, revid)
         return refs, main_ref, (stop_revno, stop_revision)
 
-    def _update_refs(self, result, old_refs, new_refs, overwrite):
+    def _update_refs(self, result, old_refs, new_refs, overwrite, tag_selector):
         mutter("updating refs. old refs: %r, new refs: %r",
                old_refs, new_refs)
         result.tag_updates = {}
@@ -1346,6 +1404,8 @@
                 except ValueError:
                     pass
                 else:
+                    if tag_selector and not tag_selector(tag_name):
+                        continue
                     result.tag_updates[tag_name] = revid
                 ret[ref] = (git_sha, revid)
             else:
@@ -1381,7 +1441,8 @@
             for (old_revid, (new_sha, new_revid)) in revidmap.items()})
 
     def pull(self, overwrite=False, stop_revision=None, local=False,
-             possible_transports=None, run_hooks=True, _stop_revno=None):
+             possible_transports=None, run_hooks=True, _stop_revno=None,
+             tag_selector=None):
         result = GitBranchPullResult()
         result.source_branch = self.source
         result.target_branch = self.target
@@ -1390,7 +1451,7 @@
                 stop_revision, stop_revno=_stop_revno)
 
             def update_refs(old_refs):
-                return self._update_refs(result, old_refs, new_refs, overwrite)
+                return self._update_refs(result, old_refs, new_refs, overwrite, tag_selector)
             try:
                 result.revidmap, old_refs, new_refs = (
                     self.interrepo.fetch_refs(update_refs, lossy=False))
@@ -1410,7 +1471,8 @@
         return result
 
     def push(self, overwrite=False, stop_revision=None, lossy=False,
-             _override_hook_source_branch=None, _stop_revno=None):
+             _override_hook_source_branch=None, _stop_revno=None,
+             tag_selector=None):
         result = GitBranchPushResult()
         result.source_branch = self.source
         result.target_branch = self.target
@@ -1421,7 +1483,7 @@
                 stop_revision, stop_revno=_stop_revno)
 
             def update_refs(old_refs):
-                return self._update_refs(result, old_refs, new_refs, overwrite)
+                return self._update_refs(result, old_refs, new_refs, overwrite, tag_selector)
             try:
                 result.revidmap, old_refs, new_refs = (
                     self.interrepo.fetch_refs(

=== modified file 'breezy/git/dir.py'
--- breezy/git/dir.py	2020-02-18 01:57:45 +0000
+++ breezy/git/dir.py	2020-02-21 04:09:29 +0000
@@ -218,7 +218,8 @@
     def clone_on_transport(self, transport, revision_id=None,
                            force_new_repo=False, preserve_stacking=False,
                            stacked_on=None, create_prefix=False,
-                           use_existing_dir=True, no_tree=False):
+                           use_existing_dir=True, no_tree=False,
+                           tag_selector=None):
         """See ControlDir.clone_on_transport."""
         from ..repository import InterRepository
         from .mapping import default_mapping
@@ -240,7 +241,7 @@
         interrepo = InterRepository.get(source_repo, target_repo)
         if revision_id is not None:
             determine_wants = interrepo.get_determine_wants_revids(
-                [revision_id], include_tags=True)
+                [revision_id], include_tags=True, tag_selector=tag_selector)
         else:
             determine_wants = interrepo.determine_wants_all
         (pack_hint, _, refs) = interrepo.fetch_objects(determine_wants,
@@ -312,7 +313,7 @@
 
     def push_branch(self, source, revision_id=None, overwrite=False,
                     remember=False, create_prefix=False, lossy=False,
-                    name=None):
+                    name=None, tag_selector=None):
         """Push the source branch into this ControlDir."""
         push_result = GitPushResult()
         push_result.workingtree_updated = None
@@ -325,7 +326,7 @@
         target = self.open_branch(name, nascent_ok=True)
         push_result.branch_push_result = source.push(
             target, overwrite=overwrite, stop_revision=revision_id,
-            lossy=lossy)
+            lossy=lossy, tag_selector=tag_selector)
         push_result.new_revid = push_result.branch_push_result.new_revid
         push_result.old_revid = push_result.branch_push_result.old_revid
         try:

=== modified file 'breezy/git/interrepo.py'
--- breezy/git/interrepo.py	2020-02-18 01:57:45 +0000
+++ breezy/git/interrepo.py	2020-02-21 04:09:29 +0000
@@ -75,6 +75,7 @@
     )
 from .refs import (
     is_tag,
+    ref_to_tag_name,
     )
 from .repository import (
     GitRepository,
@@ -403,7 +404,7 @@
     def _target_has_shas(self, shas):
         raise NotImplementedError(self._target_has_shas)
 
-    def get_determine_wants_heads(self, wants, include_tags=False):
+    def get_determine_wants_heads(self, wants, include_tags=False, tag_selector=None):
         wants = set(wants)
 
         def determine_wants(refs):
@@ -416,7 +417,11 @@
                 for k, sha in refs.items():
                     if k.endswith(ANNOTATED_TAG_SUFFIX):
                         continue
-                    if not is_tag(k):
+                    try:
+                        tag_name = ref_to_tag_name(k)
+                    except ValueError:
+                        continue
+                    if tag_selector and not tag_selector(tag_name):
                         continue
                     if sha == ZERO_SHA:
                         continue
@@ -502,14 +507,15 @@
         """
         raise NotImplementedError(self.fetch_objects)
 
-    def get_determine_wants_revids(self, revids, include_tags=False):
+    def get_determine_wants_revids(self, revids, include_tags=False, tag_selector=None):
         wants = set()
         for revid in set(revids):
             if self.target.has_revision(revid):
                 continue
             git_sha, mapping = self.source.lookup_bzr_revision_id(revid)
             wants.add(git_sha)
-        return self.get_determine_wants_heads(wants, include_tags=include_tags)
+        return self.get_determine_wants_heads(
+            wants, include_tags=include_tags, tag_selector=tag_selector)
 
     def fetch(self, revision_id=None, find_ghosts=False,
               mapping=None, fetch_spec=None, include_tags=False, lossy=False):
@@ -682,14 +688,14 @@
         result.refs = wants_recorder.remote_refs
         return result
 
-    def get_determine_wants_revids(self, revids, include_tags=False):
+    def get_determine_wants_revids(self, revids, include_tags=False, tag_selector=None):
         wants = set()
         for revid in set(revids):
             if revid == NULL_REVISION:
                 continue
             git_sha, mapping = self.source.lookup_bzr_revision_id(revid)
             wants.add(git_sha)
-        return self.get_determine_wants_heads(wants, include_tags=include_tags)
+        return self.get_determine_wants_heads(wants, include_tags=include_tags, tag_selector=tag_selector)
 
     def get_determine_wants_branches(self, branches, include_tags=False):
         def determine_wants(refs):

=== modified file 'breezy/git/workingtree.py'
--- breezy/git/workingtree.py	2020-02-18 01:57:45 +0000
+++ breezy/git/workingtree.py	2020-02-21 04:09:29 +0000
@@ -1210,12 +1210,12 @@
 
     def pull(self, source, overwrite=False, stop_revision=None,
              change_reporter=None, possible_transports=None, local=False,
-             show_base=False):
+             show_base=False, tag_selector=None):
         with self.lock_write(), source.lock_read():
             old_revision = self.branch.last_revision()
             count = self.branch.pull(source, overwrite, stop_revision,
                                      possible_transports=possible_transports,
-                                     local=local)
+                                     local=local, tag_selector=tag_selector)
             self._update_git_tree(
                 old_revision=old_revision,
                 new_revision=self.branch.last_revision(),

=== modified file 'breezy/plugins/propose/github.py'
--- breezy/plugins/propose/github.py	2020-02-18 01:57:45 +0000
+++ breezy/plugins/propose/github.py	2020-02-21 04:09:29 +0000
@@ -275,11 +275,12 @@
             return json.loads(response.text)
         raise InvalidHttpResponse(path, response.text)
 
-    def _create_pull(self, path, title, head, base, body=None, labels=None, assignee=None):
+    def _create_pull(self, path, title, head, base, body=None, labels=None, assignee=None, draft=False):
         data = {
             'title': title,
             'head': head,
             'base': base,
+            'draft': draft,
         }
         if labels is not None:
             data['labels'] = labels
@@ -373,7 +374,7 @@
 
     def publish_derived(self, local_branch, base_branch, name, project=None,
                         owner=None, revision_id=None, overwrite=False,
-                        allow_lossy=True):
+                        allow_lossy=True, tag_selector=None):
         base_owner, base_project, base_branch_name = parse_github_branch_url(base_branch)
         base_repo = self._get_repo(base_owner, base_project)
         if owner is None:
@@ -393,13 +394,14 @@
         try:
             push_result = remote_dir.push_branch(
                 local_branch, revision_id=revision_id, overwrite=overwrite,
-                name=name)
+                name=name, tag_selector=tag_selector)
         except errors.NoRoundtrippingSupport:
             if not allow_lossy:
                 raise
             push_result = remote_dir.push_branch(
                 local_branch, revision_id=revision_id,
-                overwrite=overwrite, name=name, lossy=True)
+                overwrite=overwrite, name=name, lossy=True,
+                tag_selector=tag_selector)
         return push_result.target_branch, github_url_to_bzr_url(
             remote_repo['html_url'], name)
 

=== modified file 'breezy/plugins/propose/gitlabs.py'
--- breezy/plugins/propose/gitlabs.py	2020-02-18 01:57:45 +0000
+++ breezy/plugins/propose/gitlabs.py	2020-02-21 04:09:29 +0000
@@ -413,7 +413,7 @@
 
     def publish_derived(self, local_branch, base_branch, name, project=None,
                         owner=None, revision_id=None, overwrite=False,
-                        allow_lossy=True):
+                        allow_lossy=True, tag_selector=None):
         (host, base_project, base_branch_name) = parse_gitlab_branch_url(base_branch)
         if owner is None:
             owner = self._get_logged_in_username()
@@ -428,13 +428,13 @@
         try:
             push_result = remote_dir.push_branch(
                 local_branch, revision_id=revision_id, overwrite=overwrite,
-                name=name)
+                name=name, tag_selector=tag_selector)
         except errors.NoRoundtrippingSupport:
             if not allow_lossy:
                 raise
             push_result = remote_dir.push_branch(
                 local_branch, revision_id=revision_id, overwrite=overwrite,
-                name=name, lossy=True)
+                name=name, lossy=True, tag_selector=tag_selector)
         public_url = gitlab_url_to_bzr_url(
             target_project['http_url_to_repo'], name)
         return push_result.target_branch, public_url

=== modified file 'breezy/plugins/propose/launchpad.py'
--- breezy/plugins/propose/launchpad.py	2020-02-18 01:57:45 +0000
+++ breezy/plugins/propose/launchpad.py	2020-02-21 04:09:29 +0000
@@ -258,7 +258,8 @@
         return "~%s/%s" % (owner, project)
 
     def _publish_git(self, local_branch, base_path, name, owner, project=None,
-                     revision_id=None, overwrite=False, allow_lossy=True):
+                     revision_id=None, overwrite=False, allow_lossy=True,
+                     tag_selector=None):
         to_path = self._get_derived_git_path(base_path, owner, project)
         to_transport = get_transport("git+ssh://git.launchpad.net/" + to_path)
         try:
@@ -270,21 +271,23 @@
         if dir_to is None:
             try:
                 br_to = local_branch.create_clone_on_transport(
-                    to_transport, revision_id=revision_id, name=name)
+                    to_transport, revision_id=revision_id, name=name,
+                    tag_selector=tag_selector)
             except errors.NoRoundtrippingSupport:
                 br_to = local_branch.create_clone_on_transport(
                     to_transport, revision_id=revision_id, name=name,
-                    lossy=True)
+                    lossy=True, tag_selector=tag_selector)
         else:
             try:
                 dir_to = dir_to.push_branch(
-                    local_branch, revision_id, overwrite=overwrite, name=name)
+                    local_branch, revision_id, overwrite=overwrite, name=name,
+                    tag_selector=tag_selector)
             except errors.NoRoundtrippingSupport:
                 if not allow_lossy:
                     raise
                 dir_to = dir_to.push_branch(
                     local_branch, revision_id, overwrite=overwrite, name=name,
-                    lossy=True)
+                    lossy=True, tag_selector=tag_selector)
             br_to = dir_to.target_branch
         return br_to, (
             "https://git.launchpad.net/%s/+ref/%s" % (to_path, name))
@@ -310,7 +313,7 @@
 
     def _publish_bzr(self, local_branch, base_branch, name, owner,
                      project=None, revision_id=None, overwrite=False,
-                     allow_lossy=True):
+                     allow_lossy=True, tag_selector=None):
         to_path = self._get_derived_bzr_path(base_branch, name, owner, project)
         to_transport = get_transport("lp:" + to_path)
         try:
@@ -321,10 +324,11 @@
 
         if dir_to is None:
             br_to = local_branch.create_clone_on_transport(
-                to_transport, revision_id=revision_id)
+                to_transport, revision_id=revision_id, tag_selector=tag_selector)
         else:
             br_to = dir_to.push_branch(
-                local_branch, revision_id, overwrite=overwrite).target_branch
+                local_branch, revision_id, overwrite=overwrite,
+                tag_selector=tag_selector).target_branch
         return br_to, ("https://code.launchpad.net/" + to_path)
 
     def _split_url(self, url):
@@ -341,7 +345,7 @@
 
     def publish_derived(self, local_branch, base_branch, name, project=None,
                         owner=None, revision_id=None, overwrite=False,
-                        allow_lossy=True):
+                        allow_lossy=True, tag_selector=None):
         """Publish a branch to the site, derived from base_branch.
 
         :param base_branch: branch to derive the new branch from
@@ -360,12 +364,12 @@
             return self._publish_bzr(
                 local_branch, base_branch, name, project=project, owner=owner,
                 revision_id=revision_id, overwrite=overwrite,
-                allow_lossy=allow_lossy)
+                allow_lossy=allow_lossy, tag_selector=tag_selector)
         elif base_vcs == 'git':
             return self._publish_git(
                 local_branch, base_path, name, project=project, owner=owner,
                 revision_id=revision_id, overwrite=overwrite,
-                allow_lossy=allow_lossy)
+                allow_lossy=allow_lossy, tag_selector=tag_selector)
         else:
             raise AssertionError('not a valid Launchpad URL')
 

=== modified file 'breezy/plugins/weave_fmt/bzrdir.py'
--- breezy/plugins/weave_fmt/bzrdir.py	2020-02-18 01:57:45 +0000
+++ breezy/plugins/weave_fmt/bzrdir.py	2020-02-21 04:09:29 +0000
@@ -745,7 +745,7 @@
         return self._format.__class__()
 
     def clone(self, url, revision_id=None, force_new_repo=False,
-              preserve_stacking=False):
+              preserve_stacking=False, tag_selector=None):
         """See ControlDir.clone().
 
         force_new_repo has no effect, since this family of formats always
@@ -757,7 +757,7 @@
         result = self._format._initialize_for_clone(url)
         self.open_repository().clone(result, revision_id=revision_id)
         from_branch = self.open_branch()
-        from_branch.clone(result, revision_id=revision_id)
+        from_branch.clone(result, revision_id=revision_id, tag_selector=tag_selector)
         try:
             tree = self.open_workingtree()
         except errors.NotLocalUrl:

=== modified file 'breezy/propose.py'
--- breezy/propose.py	2020-02-18 01:57:45 +0000
+++ breezy/propose.py	2020-02-21 04:09:29 +0000
@@ -237,7 +237,7 @@
 
     def publish_derived(self, new_branch, base_branch, name, project=None,
                         owner=None, revision_id=None, overwrite=False,
-                        allow_lossy=True):
+                        allow_lossy=True, tag_selector=None):
         """Publish a branch to the site, derived from base_branch.
 
         :param base_branch: branch to derive the new branch from

=== modified file 'breezy/tag.py'
--- breezy/tag.py	2020-02-18 01:57:45 +0000
+++ breezy/tag.py	2020-02-21 04:09:29 +0000
@@ -24,29 +24,22 @@
 
 from collections import defaultdict
 import contextlib
+import itertools
+import re
+import sys
 
 # NOTE: I was going to call this tags.py, but vim seems to think all files
 # called tags* are ctags files... mbp 20070220.
 
+from .inter import InterObject
 from .registry import Registry
-from .lazy_import import lazy_import
-lazy_import(globals(), """
-import itertools
-import re
-import sys
-
-from breezy import (
-    bencode,
-    trace,
-    )
-""")
 
 from . import (
     errors,
     )
 
 
-def _reconcile_tags(source_dict, dest_dict, overwrite):
+def _reconcile_tags(source_dict, dest_dict, overwrite, selector):
     """Do a two-way merge of two tag dictionaries.
 
     * only in source => source value
@@ -62,6 +55,8 @@
     updates = {}
     result = dict(dest_dict)  # copy
     for name, target in source_dict.items():
+        if selector and not selector(name):
+            continue
         if result.get(name) == target:
             pass
         elif name not in result or overwrite:
@@ -72,7 +67,7 @@
     return result, updates, conflicts
 
 
-class _Tags(object):
+class Tags(object):
 
     def __init__(self, branch):
         self.branch = branch
@@ -83,21 +78,39 @@
         raise NotImplementedError(self.get_tag_dict)
 
     def get_reverse_tag_dict(self):
-        """Return a dictionary mapping revision ids to list of tags.
-        """
-        raise NotImplementedError(self.get_reverse_tag_dict)
-
-    def merge_to(self, to_tags, overwrite=False, ignore_master=False):
-        """Merge new tags from this tags container into another.
-
-        :param to_tags: Tags container to merge into
-        :param overwrite: Whether to overwrite existing, divergent, tags.
+        """Returns a dict with revisions as keys
+           and a list of tags for that revision as value"""
+        d = self.get_tag_dict()
+        rev = defaultdict(set)
+        for key in d:
+            rev[d[key]].add(key)
+        return rev
+
+    def merge_to(self, to_tags, overwrite=False, ignore_master=False, selector=None):
+        """Copy tags between repositories if necessary and possible.
+
+        This method has common command-line behaviour about handling
+        error cases.
+
+        All new definitions are copied across, except that tags that already
+        exist keep their existing definitions.
+
+        :param to_tags: Branch to receive these tags
+        :param overwrite: Overwrite conflicting tags in the target branch
         :param ignore_master: Do not modify the tags in the target's master
             branch (if any).  Default is false (so the master will be updated).
-            New in bzr 2.3.
-        :return: Tuple with tag updates as dictionary and tag conflicts
+
+        :returns: Tuple with tag_updates and tag_conflicts.
+            tag_updates is a dictionary with new tags, None is used for
+            removed tags
+            tag_conflicts is a set of tags that conflicted, each of which is
+            (tagname, source_target, dest_target), or None if no copying was
+            done.
         """
-        raise NotImplementedError(self.merge_to)
+        intertags = InterTags.get(self, to_tags)
+        return intertags.merge(
+            overwrite=overwrite, ignore_master=ignore_master,
+            selector=selector)
 
     def set_tag(self, tag_name, revision):
         """Set a tag.
@@ -127,18 +140,21 @@
         raise NotImplementedError(self.delete_tag)
 
     def rename_revisions(self, rename_map):
-        """Replace revision ids according to a rename map.
+        """Rename revisions in this tags dictionary.
 
-        :param rename_map: Dictionary mapping old revision ids to
-            new revision ids.
+        :param rename_map: Dictionary mapping old revids to new revids
         """
-        raise NotImplementedError(self.rename_revisions)
+        reverse_tags = self.get_reverse_tag_dict()
+        for revid, names in reverse_tags.items():
+            if revid in rename_map:
+                for name in names:
+                    self.set_tag(name, rename_map[revid])
 
     def has_tag(self, tag_name):
         return tag_name in self.get_tag_dict()
 
 
-class DisabledTags(_Tags):
+class DisabledTags(Tags):
     """Tag storage that refuses to store anything.
 
     This is used by older formats that can't store tags.
@@ -153,7 +169,7 @@
     lookup_tag = _not_supported
     delete_tag = _not_supported
 
-    def merge_to(self, to_tags, overwrite=False, ignore_master=False):
+    def merge_to(self, to_tags, overwrite=False, ignore_master=False, selector=None):
         # we never have anything to copy
         return {}, []
 
@@ -166,102 +182,19 @@
         return {}
 
 
-class BasicTags(_Tags):
-    """Tag storage in an unversioned branch control file.
+class InterTags(InterObject):
+    """Operations between sets of tags.
     """
 
-    def set_tag(self, tag_name, tag_target):
-        """Add a tag definition to the branch.
-
-        Behaviour if the tag is already present is not defined (yet).
-        """
-        # all done with a write lock held, so this looks atomic
-        with self.branch.lock_write():
-            master = self.branch.get_master_branch()
-            if master is not None:
-                master.tags.set_tag(tag_name, tag_target)
-            td = self.get_tag_dict()
-            td[tag_name] = tag_target
-            self._set_tag_dict(td)
-
-    def lookup_tag(self, tag_name):
-        """Return the referent string of a tag"""
-        td = self.get_tag_dict()
-        try:
-            return td[tag_name]
-        except KeyError:
-            raise errors.NoSuchTag(tag_name)
-
-    def get_tag_dict(self):
-        with self.branch.lock_read():
-            try:
-                tag_content = self.branch._get_tags_bytes()
-            except errors.NoSuchFile:
-                # ugly, but only abentley should see this :)
-                trace.warning('No branch/tags file in %s.  '
-                              'This branch was probably created by bzr 0.15pre.  '
-                              'Create an empty file to silence this message.'
-                              % (self.branch, ))
-                return {}
-            return self._deserialize_tag_dict(tag_content)
-
-    def get_reverse_tag_dict(self):
-        """Returns a dict with revisions as keys
-           and a list of tags for that revision as value"""
-        d = self.get_tag_dict()
-        rev = defaultdict(set)
-        for key in d:
-            rev[d[key]].add(key)
-        return rev
-
-    def delete_tag(self, tag_name):
-        """Delete a tag definition.
-        """
-        with self.branch.lock_write():
-            d = self.get_tag_dict()
-            try:
-                del d[tag_name]
-            except KeyError:
-                raise errors.NoSuchTag(tag_name)
-            master = self.branch.get_master_branch()
-            if master is not None:
-                try:
-                    master.tags.delete_tag(tag_name)
-                except errors.NoSuchTag:
-                    pass
-            self._set_tag_dict(d)
-
-    def _set_tag_dict(self, new_dict):
-        """Replace all tag definitions
-
-        WARNING: Calling this on an unlocked branch will lock it, and will
-        replace the tags without warning on conflicts.
-
-        :param new_dict: Dictionary from tag name to target.
-        """
-        return self.branch._set_tags_bytes(self._serialize_tag_dict(new_dict))
-
-    def _serialize_tag_dict(self, tag_dict):
-        td = dict((k.encode('utf-8'), v)
-                  for k, v in tag_dict.items())
-        return bencode.bencode(td)
-
-    def _deserialize_tag_dict(self, tag_content):
-        """Convert the tag file into a dictionary of tags"""
-        # was a special case to make initialization easy, an empty definition
-        # is an empty dictionary
-        if tag_content == b'':
-            return {}
-        try:
-            r = {}
-            for k, v in bencode.bdecode(tag_content).items():
-                r[k.decode('utf-8')] = v
-            return r
-        except ValueError as e:
-            raise ValueError("failed to deserialize tag dictionary %r: %s"
-                             % (tag_content, e))
-
-    def merge_to(self, to_tags, overwrite=False, ignore_master=False):
+    _optimisers = []
+    """The available optimised InterTags types."""
+
+    @classmethod
+    def is_compatible(klass, source, target):
+        # This is the default implementation
+        return True
+
+    def merge(self, overwrite=False, ignore_master=False, selector=None):
         """Copy tags between repositories if necessary and possible.
 
         This method has common command-line behaviour about handling
@@ -274,7 +207,9 @@
         :param overwrite: Overwrite conflicting tags in the target branch
         :param ignore_master: Do not modify the tags in the target's master
             branch (if any).  Default is false (so the master will be updated).
-            New in bzr 2.3.
+        :param selector: Callback that determines whether a tag should be
+            copied. It should take a tag name and as argument and return a
+            boolean.
 
         :returns: Tuple with tag_updates and tag_conflicts.
             tag_updates is a dictionary with new tags, None is used for
@@ -284,12 +219,12 @@
             done.
         """
         with contextlib.ExitStack() as stack:
-            if self.branch == to_tags.branch:
+            if self.source.branch == self.target.branch:
                 return {}, []
-            if not self.branch.supports_tags():
+            if not self.source.branch.supports_tags():
                 # obviously nothing to copy
                 return {}, []
-            source_dict = self.get_tag_dict()
+            source_dict = self.source.get_tag_dict()
             if not source_dict:
                 # no tags in the source, and we don't want to clobber anything
                 # that's in the destination
@@ -306,44 +241,35 @@
             # Ideally we'd improve this API to report the different conflicts
             # more clearly to the caller, but we don't want to break plugins
             # such as bzr-builddeb that use this API.
-            stack.enter_context(to_tags.branch.lock_write())
+            stack.enter_context(self.target.branch.lock_write())
             if ignore_master:
                 master = None
             else:
-                master = to_tags.branch.get_master_branch()
+                master = self.target.branch.get_master_branch()
             if master is not None:
                 stack.enter_context(master.lock_write())
-            updates, conflicts = self._merge_to(to_tags, source_dict, overwrite)
+            updates, conflicts = self._merge_to(
+                self.target, source_dict, overwrite, selector=selector)
             if master is not None:
-                extra_updates, extra_conflicts = self._merge_to(master.tags,
-                                                                source_dict, overwrite)
+                extra_updates, extra_conflicts = self._merge_to(
+                    master.tags, source_dict, overwrite, selector=selector)
                 updates.update(extra_updates)
                 conflicts += extra_conflicts
             # We use set() to remove any duplicate conflicts from the master
             # branch.
             return updates, set(conflicts)
 
-    def _merge_to(self, to_tags, source_dict, overwrite):
+    @classmethod
+    def _merge_to(cls, to_tags, source_dict, overwrite, selector):
         dest_dict = to_tags.get_tag_dict()
         result, updates, conflicts = _reconcile_tags(
-            source_dict, dest_dict, overwrite)
+            source_dict, dest_dict, overwrite, selector)
         if result != dest_dict:
             to_tags._set_tag_dict(result)
         return updates, conflicts
 
-    def rename_revisions(self, rename_map):
-        """Rename revisions in this tags dictionary.
-
-        :param rename_map: Dictionary mapping old revids to new revids
-        """
-        reverse_tags = self.get_reverse_tag_dict()
-        for revid, names in reverse_tags.items():
-            if revid in rename_map:
-                for name in names:
-                    self.set_tag(name, rename_map[revid])
-
-
-class MemoryTags(_Tags):
+
+class MemoryTags(Tags):
 
     def __init__(self, tag_dict):
         self._tag_dict = tag_dict
@@ -359,15 +285,6 @@
         except KeyError:
             raise errors.NoSuchTag(tag_name)
 
-    def get_reverse_tag_dict(self):
-        """Returns a dict with revisions as keys
-           and a list of tags for that revision as value"""
-        d = self.get_tag_dict()
-        rev = defaultdict(set)
-        for key in d:
-            rev[d[key]].add(key)
-        return rev
-
     def set_tag(self, name, revid):
         self._tag_dict[name] = revid
 
@@ -385,11 +302,11 @@
     def _set_tag_dict(self, result):
         self._tag_dict = dict(result.items())
 
-    def merge_to(self, to_tags, overwrite=False, ignore_master=False):
+    def merge_to(self, to_tags, overwrite=False, ignore_master=False, selector=None):
         source_dict = self.get_tag_dict()
         dest_dict = to_tags.get_tag_dict()
         result, updates, conflicts = _reconcile_tags(
-            source_dict, dest_dict, overwrite)
+            source_dict, dest_dict, overwrite, selector)
         if result != dest_dict:
             to_tags._set_tag_dict(result)
         return updates, conflicts
@@ -441,3 +358,6 @@
 tag_sort_methods.register("alpha", sort_alpha, 'Sort tags lexicographically.')
 tag_sort_methods.register("time", sort_time, 'Sort tags chronologically.')
 tag_sort_methods.default_key = "natural"
+
+
+InterTags.register_optimiser(InterTags)

=== modified file 'breezy/tests/per_branch/test_pull.py'
--- breezy/tests/per_branch/test_pull.py	2018-11-17 20:50:40 +0000
+++ breezy/tests/per_branch/test_pull.py	2020-02-21 04:09:29 +0000
@@ -118,7 +118,7 @@
         self.assertEqual(p1, result.old_revid)
         self.assertEqual(2, result.new_revno)
         self.assertEqual(m1, result.new_revid)
-        self.assertEqual([], result.tag_conflicts)
+        self.assertEqual([], list(result.tag_conflicts))
 
     def test_pull_overwrite(self):
         tree_a = self.make_branch_and_tree('tree_a')

=== modified file 'breezy/tests/per_branch/test_tags.py'
--- breezy/tests/per_branch/test_tags.py	2019-02-02 21:58:23 +0000
+++ breezy/tests/per_branch/test_tags.py	2020-02-21 04:09:29 +0000
@@ -142,6 +142,21 @@
         self.assertEqual(updates, {})
         self.assertEqual(b2.tags.lookup_tag('conflicts'), revid2)
 
+    def test_merge_tags_selector(self):
+        b1, [revid, revid1] = self.make_branch_with_revision_tuple('b1', 2)
+        w2 = b1.controldir.sprout('b2', revision_id=revid).open_workingtree()
+        revid2 = w2.commit('revision 2')
+        b2 = w2.branch
+        # if there are tags in the source and not the destination, then they
+        # just go across
+        b1.tags.set_tag('tag1', revid)
+        b1.tags.set_tag('tag2', revid2)
+        updates, conflicts = b1.tags.merge_to(b2.tags, selector=lambda x: x == 'tag1')
+        self.assertEqual({'tag1': revid}, updates)
+        self.assertEqual(set(), set(conflicts))
+        self.assertEqual(b2.tags.lookup_tag('tag1'), revid)
+        self.assertRaises(errors.NoSuchTag, b2.tags.lookup_tag, 'tag2')
+
     def test_unicode_tag(self):
         tag_name = u'\u3070'
         b1, [revid] = self.make_branch_with_revision_tuple('b', 1)

=== modified file 'breezy/tests/per_controldir/test_push.py'
--- breezy/tests/per_controldir/test_push.py	2019-02-15 03:42:06 +0000
+++ breezy/tests/per_controldir/test_push.py	2020-02-21 04:09:29 +0000
@@ -99,3 +99,14 @@
         self.assertEqual(2, result.branch_push_result.new_revno)
         self.assertEqual(tree.branch.base, result.source_branch.base)
         self.assertEqual(dir.open_branch().base, result.target_branch.base)
+
+    def test_push_tag_selector(self):
+        tree, rev1 = self.create_simple_tree()
+        try:
+            tree.branch.tags.set_tag('tag1', rev1)
+        except TagsNotSupported:
+            raise TestNotApplicable('tags not supported')
+        tree.branch.tags.set_tag('tag2', rev1)
+        dir = self.make_repository('dir').controldir
+        dir.push_branch(tree.branch, tag_selector=lambda x: x == 'tag1')
+        self.assertEqual({'tag1': rev1}, dir.open_branch().tags.get_tag_dict())

=== modified file 'breezy/tests/per_interbranch/test_pull.py'
--- breezy/tests/per_interbranch/test_pull.py	2018-11-11 04:08:32 +0000
+++ breezy/tests/per_interbranch/test_pull.py	2020-02-21 04:09:29 +0000
@@ -144,7 +144,7 @@
         self.assertEqual(p1, result.old_revid)
         self.assertEqual(2, result.new_revno)
         self.assertEqual(m1, result.new_revid)
-        self.assertEqual([], result.tag_conflicts)
+        self.assertEqual([], list(result.tag_conflicts))
 
     def test_pull_overwrite(self):
         tree_a = self.make_from_branch_and_tree('tree_a')
@@ -180,6 +180,26 @@
         self.assertEqual(tree_b.branch.last_revision(),
                          tree_a.branch.last_revision())
 
+    def test_pull_tag_selector(self):
+        if not self.branch_format_from.supports_tags():
+            raise TestNotApplicable('from format does not support tags')
+        if not self.branch_format_to.supports_tags():
+            raise TestNotApplicable('to format does not support tags')
+        tree_a = self.make_from_branch_and_tree('tree_a')
+        revid1 = tree_a.commit('message 1')
+        try:
+            tree_b = self.sprout_to(
+                tree_a.controldir, 'tree_b').open_workingtree()
+        except errors.NoRoundtrippingSupport:
+            raise TestNotApplicable(
+                'lossless push between %r and %r not supported' %
+                (self.branch_format_from, self.branch_format_to))
+        tree_b.branch.tags.set_tag('tag1', revid1)
+        tree_b.branch.tags.set_tag('tag2', revid1)
+        tree_b.branch.get_config_stack().set('branch.fetch_tags', True)
+        tree_a.pull(tree_b.branch, tag_selector=lambda x: x == 'tag1')
+        self.assertEqual({'tag1': revid1}, tree_a.branch.tags.get_tag_dict())
+
 
 class TestPullHook(TestCaseWithInterBranch):
 

=== modified file 'breezy/tests/per_interbranch/test_push.py'
--- breezy/tests/per_interbranch/test_push.py	2020-02-07 02:14:30 +0000
+++ breezy/tests/per_interbranch/test_push.py	2020-02-21 04:09:29 +0000
@@ -374,6 +374,26 @@
         self.overrideAttr(SmartServerRepositoryGetParentMap,
                           'no_extra_results', True)
 
+    def test_push_tag_selector(self):
+        if not self.branch_format_from.supports_tags():
+            raise tests.TestNotApplicable('from format does not support tags')
+        if not self.branch_format_to.supports_tags():
+            raise tests.TestNotApplicable('to format does not support tags')
+        tree_a = self.make_from_branch_and_tree('tree_a')
+        revid1 = tree_a.commit('message 1')
+        try:
+            tree_b = self.sprout_to(
+                tree_a.controldir, 'tree_b').open_workingtree()
+        except errors.NoRoundtrippingSupport:
+            raise tests.TestNotApplicable(
+                'lossless push between %r and %r not supported' %
+                (self.branch_format_from, self.branch_format_to))
+        tree_b.branch.tags.set_tag('tag1', revid1)
+        tree_b.branch.tags.set_tag('tag2', revid1)
+        tree_b.branch.get_config_stack().set('branch.fetch_tags', True)
+        tree_b.branch.push(tree_a.branch, tag_selector=lambda x: x == 'tag1')
+        self.assertEqual({'tag1': revid1}, tree_a.branch.tags.get_tag_dict())
+
 
 class TestPushHook(TestCaseWithInterBranch):
 

=== modified file 'breezy/tests/test_foreign.py'
--- breezy/tests/test_foreign.py	2018-11-25 20:44:56 +0000
+++ breezy/tests/test_foreign.py	2020-02-21 04:09:29 +0000
@@ -171,7 +171,7 @@
     def is_compatible(source, target):
         return isinstance(target, DummyForeignVcsBranch)
 
-    def push(self, overwrite=False, stop_revision=None, lossy=False):
+    def push(self, overwrite=False, stop_revision=None, lossy=False, tag_selector=None):
         if not lossy:
             raise errors.NoRoundtrippingSupport(self.source, self.target)
         result = branch.BranchPushResult()

=== modified file 'breezy/tests/test_tag.py'
--- breezy/tests/test_tag.py	2019-02-01 16:29:45 +0000
+++ breezy/tests/test_tag.py	2020-02-21 04:09:29 +0000
@@ -22,10 +22,12 @@
     errors,
     )
 from breezy.tag import (
-    BasicTags,
     DisabledTags,
     MemoryTags,
     )
+from breezy.bzr.tag import (
+    BasicTags,
+    )
 from breezy.tests import (
     TestCase,
     TestCaseWithTransport,
@@ -120,6 +122,17 @@
         self.assertEqual({u'tag-2': b'z'}, updates)
         self.assertEqual(b'z', b.tags.lookup_tag('tag-2'))
 
+    def test_merge_to_with_selector(self):
+        a = self.make_branch_supporting_tags('a')
+        b = self.make_branch_supporting_tags('b')
+        # simple merge
+        a.tags.set_tag('tag-1', b'x')
+        a.tags.set_tag('tag-2', b'y')
+        updates, conflicts = a.tags.merge_to(b.tags, selector=lambda x: x == 'tag-1')
+        self.assertEqual(list(conflicts), [])
+        self.assertEqual({u'tag-1': b'x'}, updates)
+        self.assertRaises(errors.NoSuchTag, b.tags.lookup_tag, 'tag-2')
+
 
 class TestTagsInCheckouts(TestCaseWithTransport):
     """Tests for how tags are synchronised between the master and child branch

=== modified file 'breezy/workingtree.py'
--- breezy/workingtree.py	2020-02-18 01:57:45 +0000
+++ breezy/workingtree.py	2020-02-21 04:09:29 +0000
@@ -819,13 +819,13 @@
 
     def pull(self, source, overwrite=False, stop_revision=None,
              change_reporter=None, possible_transports=None, local=False,
-             show_base=False):
+             show_base=False, tag_selector=None):
         with self.lock_write(), source.lock_read():
             old_revision_info = self.branch.last_revision_info()
             basis_tree = self.basis_tree()
             count = self.branch.pull(source, overwrite, stop_revision,
                                      possible_transports=possible_transports,
-                                     local=local)
+                                     local=local, tag_selector=tag_selector)
             new_revision_info = self.branch.last_revision_info()
             if new_revision_info != old_revision_info:
                 repository = self.branch.repository