Merge lp:~jelmer/brz/rebase into lp:brz

[Jelmer Vernooij]

Port the rewrite plugin to breezy.

Port the rewrite plugin to breezy.

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

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

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

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

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

=== added directory 'breezy/plugins/rewrite'
=== added file 'breezy/plugins/rewrite/README'
--- breezy/plugins/rewrite/README	1970-01-01 00:00:00 +0000
+++ breezy/plugins/rewrite/README	2020-01-11 23:46:53 +0000
@@ -0,0 +1,59 @@
+This plugin provides various commands for rewriting Bazaar revisions in 
+an automated fashion. 
+
+It includes a 'bzr rebase' command, in the same fashion of the 
+famous ``git rebase`` command.
+
+==========
+How to use
+==========
+Simply run ``bzr rebase``, optionally specifying an upstream branch. If no 
+branch is specified, it will use the current parent branch (which is usually 
+what you want).
+
+If the rebase fails halfway through, perhaps because of conflicts 
+replaying a revision, it will abort. When it's aborted, you can either resolve
+the conflicts (using "bzr resolve") and run ``bzr rebase-continue`` or 
+abort the rebase and undo all changes it's done using ``bzr rebase-abort``. 
+The current state of the rebase can be viewed with the ``bzr rebase-todo`` 
+command. See "bzr help rebase" for more details.
+
+In the future, I hope it can also support rebasing on top of an unrelated 
+branch.
+
+============
+How it works
+============
+The plugin will start off by writing a plan for the rebase, which it 
+will write to .bzr/checkout/rebase-state. If the rebase is interrupted 
+(conflicts that have to be resolved by the user) and 
+needs to be continued or aborted, it will read this file to see what needs 
+(still) needs to be done.
+
+The rebase-state file contains the following information:
+ * last-revision-info when the rebase was started
+ * map of revisions that need to be replaced. In simple situations, 
+   this would contain the revision on top of which the rebase is taking 
+   place and the revisions that are only on the branch that is being 
+   rebased.
+
+   The map is from old revid to a tuple with new revid and new parents.
+
+   For example, in the following scenario:
+
+   A -> B -> C -> D main
+        \ -> E -> F next
+
+   Where next would be rebased on top of main, the replace map would look 
+   something like this:
+
+	E -> (E', [D])
+	F -> (F', [E'])
+
+The rebase plan contains the newly generated revision ids so that it is 
+not necessary to update it after each revision that has been written 
+because the new generated revision ids would have to be known when rewriting 
+their children.
+
+The 'rebase-of' revision property of newly created revisions 
+will be set to the revision id of the revision they are a rewrite of.

=== added file 'breezy/plugins/rewrite/__init__.py'
--- breezy/plugins/rewrite/__init__.py	1970-01-01 00:00:00 +0000
+++ breezy/plugins/rewrite/__init__.py	2020-01-11 23:46:53 +0000
@@ -0,0 +1,76 @@
+# Copyright (C) 2007 by 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
+"""Rebase support.
+
+The Bazaar rebase plugin adds support for rebasing branches to Bazaar.
+It adds the command 'rebase' to Bazaar. When conflicts occur when replaying
+patches, the user can resolve the conflict and continue the rebase using the
+'rebase-continue' command or abort using the 'rebase-abort' command.
+"""
+
+from __future__ import absolute_import
+
+from ... import errors
+from ...commands import plugin_cmds
+
+from ...bzr.bzrdir import BzrFormat
+
+BzrFormat.register_feature(b"rebase-v1")
+
+from ...i18n import load_plugin_translations
+translation = load_plugin_translations("bzr-rewrite")
+gettext = translation.gettext
+
+for cmd in ['rebase', 'rebase_abort', 'rebase_continue', 'rebase_todo',
+            'replay', 'pseudonyms', 'rebase_foreign']:
+    plugin_cmds.register_lazy("cmd_%s" % cmd, [], __name__ + ".commands")
+
+
+def show_rebase_summary(params):
+    if getattr(params.new_tree, "_format", None) is None:
+        return
+    features = getattr(params.new_tree._format, "features", None)
+    if features is None:
+        return
+    if "rebase-v1" not in features:
+        return
+    from .rebase import (
+        RebaseState1,
+        rebase_todo,
+        )
+    state = RebaseState1(params.new_tree)
+    try:
+        replace_map = state.read_plan()[1]
+    except errors.NoSuchFile:
+        return
+    todo = list(rebase_todo(params.new_tree.branch.repository, replace_map))
+    params.to_file.write('Rebase in progress. (%d revisions left)\n' % len(todo))
+
+
+from ...hooks import install_lazy_named_hook
+
+install_lazy_named_hook(
+    'breezy.status', 'hooks', 'post_status',
+    show_rebase_summary, 'rewrite status')
+
+
+def load_tests(loader, basic_tests, pattern):
+    testmod_names = [
+        'tests',
+        ]
+    basic_tests.addTest(loader.loadTestsFromModuleNames(
+        ["%s.%s" % (__name__, tmn) for tmn in testmod_names]))
+    return basic_tests

=== added file 'breezy/plugins/rewrite/commands.py'
--- breezy/plugins/rewrite/commands.py	1970-01-01 00:00:00 +0000
+++ breezy/plugins/rewrite/commands.py	2020-01-11 23:46:53 +0000
@@ -0,0 +1,529 @@
+# Copyright (C) 2007 by 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
+
+"""Bazaar command-line subcommands."""
+
+from __future__ import absolute_import
+
+from ...commands import (
+    Command,
+    display_command,
+    )
+from ...errors import (
+    BzrCommandError,
+    ConflictsInTree,
+    NoSuchFile,
+    NoWorkingTree,
+    UncommittedChanges,
+    )
+from ...option import (
+    Option,
+    )
+from ...trace import (
+    note,
+    )
+
+from ...i18n import gettext
+
+
+def finish_rebase(state, wt, replace_map, replayer):
+    from .rebase import (
+        rebase,
+        )
+    try:
+        # Start executing plan from current Branch.last_revision()
+        rebase(wt.branch.repository, replace_map, replayer)
+    except ConflictsInTree:
+        raise BzrCommandError(gettext(
+            "A conflict occurred replaying a commit."
+            " Resolve the conflict and run 'brz rebase-continue' or "
+            "run 'brz rebase-abort'."))
+    # Remove plan file
+    state.remove_plan()
+
+
+class cmd_rebase(Command):
+    """Re-base a branch.
+
+    Rebasing is the process of taking a branch and modifying the history so
+    that it appears to start from a different point. This can be useful
+    to clean up the history before submitting your changes. The tree at the
+    end of the process will be the same as if you had merged the other branch,
+    but the history will be different.
+
+    The command takes the location of another branch on to which the branch in
+    the specified directory (by default, the current working directory)
+    will be rebased. If a branch is not specified then the parent branch
+    is used, and this is usually the desired result.
+
+    The first step identifies the revisions that are in the current branch that
+    are not in the parent branch. The current branch is then set to be at the
+    same revision as the target branch, and each revision is replayed on top
+    of the branch. At the end of the process it will appear as though your
+    current branch was branched off the current last revision of the target.
+
+    Each revision that is replayed may cause conflicts in the tree. If this
+    happens the command will stop and allow you to fix them up. Resolve the
+    commits as you would for a merge, and then run 'brz resolve' to marked
+    them as resolved. Once you have resolved all the conflicts you should
+    run 'brz rebase-continue' to continue the rebase operation.
+
+    If conflicts are encountered and you decide that you do not wish to continue
+    you can run 'brz rebase-abort'.
+
+    The '--onto' option allows you to specify a different revision in the
+    target branch to start at when replaying the revisions. This means that
+    you can change the point at which the current branch will appear to be
+    branched from when the operation completes.
+    """
+    takes_args = ['upstream_location?']
+    takes_options = [
+        'revision', 'merge-type', 'verbose',
+        Option(
+            'dry-run',
+            help="Show what would be done, but don't actually do anything."),
+        Option(
+            'always-rebase-merges',
+            help="Don't skip revisions that merge already present revisions."),
+        Option(
+            'pending-merges',
+            help="Rebase pending merges onto local branch."),
+        Option(
+            'onto', help='Different revision to replay onto.',
+            type=str),
+        Option(
+            'directory',
+            short_name='d',
+            help="Branch to replay onto, rather than the one containing the working directory.",
+            type=str)
+        ]
+
+    @display_command
+    def run(self, upstream_location=None, onto=None, revision=None,
+            merge_type=None, verbose=False, dry_run=False,
+            always_rebase_merges=False, pending_merges=False,
+            directory="."):
+        from ...branch import Branch
+        from ...revisionspec import RevisionSpec
+        from ...workingtree import WorkingTree
+        from .rebase import (
+            generate_simple_plan,
+            rebase,
+            RebaseState1,
+            WorkingTreeRevisionRewriter,
+            regenerate_default_revid,
+            rebase_todo,
+            )
+        if revision is not None and pending_merges:
+            raise BzrCommandError(gettext(
+                "--revision and --pending-merges are mutually exclusive"))
+
+        wt = WorkingTree.open_containing(directory)[0]
+        wt.lock_write()
+        try:
+            state = RebaseState1(wt)
+            if upstream_location is None:
+                if pending_merges:
+                    upstream_location = directory
+                else:
+                    upstream_location = wt.branch.get_parent()
+                    if upstream_location is None:
+                        raise BzrCommandError(gettext("No upstream branch specified."))
+                    note(gettext("Rebasing on %s"), upstream_location)
+            upstream = Branch.open_containing(upstream_location)[0]
+            upstream_repository = upstream.repository
+            upstream_revision = upstream.last_revision()
+            # Abort if there already is a plan file
+            if state.has_plan():
+                raise BzrCommandError(gettext(
+                    "A rebase operation was interrupted. "
+                    "Continue using 'brz rebase-continue' or abort using 'brz "
+                    "rebase-abort'"))
+
+            start_revid = None
+            stop_revid = None
+            if revision is not None:
+                if len(revision) == 1:
+                    if revision[0] is not None:
+                        stop_revid = revision[0].as_revision_id(wt.branch)
+                elif len(revision) == 2:
+                    if revision[0] is not None:
+                        start_revid = revision[0].as_revision_id(wt.branch)
+                    if revision[1] is not None:
+                        stop_revid = revision[1].as_revision_id(wt.branch)
+                else:
+                    raise BzrCommandError(gettext(
+                        "--revision takes only one or two arguments"))
+
+            if pending_merges:
+                wt_parents = wt.get_parent_ids()
+                if len(wt_parents) in (0, 1):
+                    raise BzrCommandError(gettext("No pending merges present."))
+                elif len(wt_parents) > 2:
+                    raise BzrCommandError(gettext(
+                        "Rebasing more than one pending merge not supported"))
+                stop_revid = wt_parents[1]
+                assert stop_revid is not None, "stop revid invalid"
+
+            # Check for changes in the working tree.
+            if (not pending_merges and
+                    wt.basis_tree().changes_from(wt).has_changed()):
+                raise UncommittedChanges(wt)
+
+            # Pull required revisions
+            wt.branch.repository.fetch(upstream_repository, upstream_revision)
+            if onto is None:
+                onto = upstream.last_revision()
+            else:
+                rev_spec = RevisionSpec.from_string(onto)
+                onto = rev_spec.as_revision_id(upstream)
+
+            wt.branch.repository.fetch(upstream_repository, revision_id=onto)
+
+            if stop_revid is None:
+                stop_revid = wt.branch.last_revision()
+            repo_graph = wt.branch.repository.get_graph()
+            our_new, onto_unique = repo_graph.find_difference(stop_revid, onto)
+
+            if start_revid is None:
+                if not onto_unique:
+                    self.outf.write(gettext("No revisions to rebase.\n"))
+                    return
+                if not our_new:
+                    self.outf.write(gettext(
+                        "Base branch is descendant of current "
+                        "branch. Pulling instead.\n"))
+                    if not dry_run:
+                        wt.pull(upstream, stop_revision=onto)
+                    return
+            # else: include extra revisions needed to make start_revid mean
+            # something.
+
+            # Create plan
+            replace_map = generate_simple_plan(
+                our_new, start_revid, stop_revid, onto, repo_graph,
+                lambda revid, ps: regenerate_default_revid(
+                    wt.branch.repository, revid),
+                not always_rebase_merges)
+
+            if verbose or dry_run:
+                todo = list(rebase_todo(wt.branch.repository, replace_map))
+                note(gettext('%d revisions will be rebased:') % len(todo))
+                for revid in todo:
+                    note("%s" % revid)
+
+            if not dry_run:
+                # Write plan file
+                state.write_plan(replace_map)
+
+                replayer = WorkingTreeRevisionRewriter(wt, state, merge_type=merge_type)
+
+                finish_rebase(state, wt, replace_map, replayer)
+        finally:
+            wt.unlock()
+
+
+class cmd_rebase_abort(Command):
+    """Abort an interrupted rebase."""
+
+    takes_options = [
+        Option(
+            'directory',
+            short_name='d',
+            help="Branch to replay onto, rather than the one containing the working directory.",
+            type=str)]
+
+    @display_command
+    def run(self, directory="."):
+        from .rebase import (
+            RebaseState1,
+            complete_revert,
+            )
+        from ...workingtree import WorkingTree
+        wt = WorkingTree.open_containing(directory)[0]
+        wt.lock_write()
+        try:
+            state = RebaseState1(wt)
+            # Read plan file and set last revision
+            try:
+                last_rev_info = state.read_plan()[0]
+            except NoSuchFile:
+                raise BzrCommandError("No rebase to abort")
+            complete_revert(wt, [last_rev_info[1]])
+            state.remove_plan()
+        finally:
+            wt.unlock()
+
+
+class cmd_rebase_continue(Command):
+    """Continue an interrupted rebase after resolving conflicts."""
+    takes_options = [
+        'merge-type', Option(
+            'directory',
+            short_name='d',
+            help="Branch to replay onto, rather than the one containing the working directory.",
+            type=str)]
+
+    @display_command
+    def run(self, merge_type=None, directory="."):
+        from .rebase import (
+            RebaseState1,
+            WorkingTreeRevisionRewriter,
+            )
+        from ...workingtree import WorkingTree
+        wt = WorkingTree.open_containing(directory)[0]
+        wt.lock_write()
+        try:
+            state = RebaseState1(wt)
+            replayer = WorkingTreeRevisionRewriter(wt, state, merge_type=merge_type)
+            # Abort if there are any conflicts
+            if len(wt.conflicts()) != 0:
+                raise BzrCommandError(gettext(
+                    "There are still conflicts present. "
+                    "Resolve the conflicts and then run "
+                    "'brz resolve' and try again."))
+            # Read plan file
+            try:
+                replace_map = state.read_plan()[1]
+            except NoSuchFile:
+                raise BzrCommandError(gettext("No rebase to continue"))
+            oldrevid = state.read_active_revid()
+            if oldrevid is not None:
+                oldrev = wt.branch.repository.get_revision(oldrevid)
+                replayer.commit_rebase(oldrev, replace_map[oldrevid][0])
+            finish_rebase(state, wt, replace_map, replayer)
+        finally:
+            wt.unlock()
+
+
+class cmd_rebase_todo(Command):
+    """Print list of revisions that still need to be replayed as part of the
+    current rebase operation.
+
+    """
+
+    takes_options = [
+        Option(
+            'directory',
+            short_name='d',
+            help="Branch to replay onto, rather than the one containing the working directory.",
+            type=str)]
+
+    def run(self, directory="."):
+        from .rebase import (
+            RebaseState1,
+            rebase_todo,
+            )
+        from ...workingtree import WorkingTree
+        wt = WorkingTree.open_containing(directory)[0]
+        with wt.lock_read():
+            state = RebaseState1(wt)
+            try:
+                replace_map = state.read_plan()[1]
+            except NoSuchFile:
+                raise BzrCommandError(gettext("No rebase in progress"))
+            currentrevid = state.read_active_revid()
+            if currentrevid is not None:
+                note(gettext("Currently replaying: %s") % currentrevid)
+            for revid in rebase_todo(wt.branch.repository, replace_map):
+                note(gettext("{0} -> {1}").format(revid, replace_map[revid][0]))
+
+
+class cmd_replay(Command):
+    """Replay commits from another branch on top of this one.
+
+    """
+
+    takes_options = [
+        'revision', 'merge-type',
+        Option(
+            'directory',
+            short_name='d',
+            help="Branch to replay onto, rather than the one containing the working directory.",
+            type=str)]
+    takes_args = ['location']
+    hidden = True
+
+    def run(self, location, revision=None, merge_type=None, directory="."):
+        from ...branch import Branch
+        from ...workingtree import WorkingTree
+        from ... import ui
+        from .rebase import (
+            RebaseState1,
+            regenerate_default_revid,
+            WorkingTreeRevisionRewriter,
+            )
+
+        from_branch = Branch.open_containing(location)[0]
+
+        if revision is not None:
+            if len(revision) == 1:
+                if revision[0] is not None:
+                    todo = [revision[0].as_revision_id(from_branch)]
+            elif len(revision) == 2:
+                from_revno, from_revid = revision[0].in_history(from_branch)
+                to_revno, to_revid = revision[1].in_history(from_branch)
+                if to_revid is None:
+                    to_revno = from_branch.revno()
+                todo = []
+                for revno in range(from_revno, to_revno + 1):
+                    todo.append(from_branch.get_rev_id(revno))
+            else:
+                raise BzrCommandError(gettext(
+                    "--revision takes only one or two arguments"))
+        else:
+            raise BzrCommandError(gettext("--revision is mandatory"))
+
+        wt = WorkingTree.open(directory)
+        wt.lock_write()
+        try:
+            state = RebaseState1(wt)
+            replayer = WorkingTreeRevisionRewriter(wt, state, merge_type=merge_type)
+            pb = ui.ui_factory.nested_progress_bar()
+            try:
+                for revid in todo:
+                    pb.update(gettext("replaying commits"), todo.index(revid), len(todo))
+                    wt.branch.repository.fetch(from_branch.repository, revid)
+                    newrevid = regenerate_default_revid(wt.branch.repository, revid)
+                    replayer(revid, newrevid, [wt.last_revision()])
+            finally:
+                pb.finished()
+        finally:
+            wt.unlock()
+
+
+class cmd_pseudonyms(Command):
+    """Show a list of 'pseudonym' revisions.
+
+    Pseudonym revisions are revisions that are roughly the same revision,
+    usually because they were converted from the same revision in a
+    foreign version control system.
+    """
+
+    takes_args = ['repository?']
+    hidden = True
+
+    def run(self, repository=None):
+        from ...controldir import ControlDir
+        dir, _ = ControlDir.open_containing(repository)
+        r = dir.find_repository()
+        from .pseudonyms import find_pseudonyms
+        for pseudonyms in find_pseudonyms(r, r.all_revision_ids()):
+            self.outf.write(", ".join(pseudonyms) + "\n")
+
+
+class cmd_rebase_foreign(Command):
+    """Rebase revisions based on a branch created with a different import tool.
+
+    This will change the identity of revisions whose parents
+    were mapped from revisions in the other version control system.
+
+    You are recommended to run "brz check" in the local repository
+    after running this command.
+    """
+    takes_args = ['new_base?']
+    takes_options = [
+        'verbose',
+        Option("idmap-file", help="Write map with old and new revision ids.",
+               type=str),
+        Option(
+            'directory',
+            short_name='d',
+            help="Branch to replay onto, rather than the one containing the working directory.",
+            type=str)
+        ]
+
+    def run(self, new_base=None, verbose=False, idmap_file=None, directory="."):
+        from ... import (
+            urlutils,
+            )
+        from ...branch import Branch
+        from ...workingtree import WorkingTree
+        from .pseudonyms import (
+            find_pseudonyms,
+            generate_rebase_map_from_pseudonyms,
+            pseudonyms_as_dict,
+            )
+        from .upgrade import (
+            create_deterministic_revid,
+            upgrade_branch,
+            )
+        from ...foreign import (
+            update_workingtree_fileids,
+            )
+
+        try:
+            wt_to = WorkingTree.open(directory)
+            branch_to = wt_to.branch
+        except NoWorkingTree:
+            wt_to = None
+            branch_to = Branch.open(directory)
+
+        stored_loc = branch_to.get_parent()
+        if new_base is None:
+            if stored_loc is None:
+                raise BzrCommandError(gettext(
+                    "No pull location known or specified."))
+            else:
+                display_url = urlutils.unescape_for_display(
+                    stored_loc, self.outf.encoding)
+                self.outf.write(gettext("Using saved location: %s\n") % display_url)
+                new_base = Branch.open(stored_loc)
+        else:
+            new_base = Branch.open(new_base)
+
+        branch_to.repository.fetch(
+            new_base.repository, revision_id=branch_to.last_revision())
+
+        pseudonyms = pseudonyms_as_dict(find_pseudonyms(
+            branch_to.repository, branch_to.repository.all_revision_ids()))
+
+        def generate_rebase_map(revision_id):
+            return generate_rebase_map_from_pseudonyms(
+                pseudonyms, branch_to.repository.get_ancestry(revision_id),
+                branch_to.repository.get_ancestry(new_base.last_revision()))
+        def determine_new_revid(old_revid, new_parents):
+            return create_deterministic_revid(old_revid, new_parents)
+        branch_to.lock_write()
+        try:
+            graph = branch_to.repository.get_graph()
+            renames = upgrade_branch(
+                branch_to, generate_rebase_map,
+                determine_new_revid, allow_changes=True,
+                verbose=verbose)
+            if wt_to is not None:
+                basis_tree = wt_to.basis_tree()
+                basis_tree.lock_read()
+                try:
+                    update_workingtree_fileids(wt_to, basis_tree)
+                finally:
+                    basis_tree.unlock()
+        finally:
+            branch_to.unlock()
+
+        if renames == {}:
+            note(gettext("Nothing to do."))
+
+        if idmap_file is not None:
+            f = open(idmap_file, 'w')
+            try:
+                for oldid, newid in renames.iteritems():
+                    f.write("%s\t%s\n" % (oldid, newid))
+            finally:
+                f.close()
+
+        if wt_to is not None:
+            wt_to.set_last_revision(branch_to.last_revision())

=== added file 'breezy/plugins/rewrite/maptree.py'
--- breezy/plugins/rewrite/maptree.py	1970-01-01 00:00:00 +0000
+++ breezy/plugins/rewrite/maptree.py	2020-01-11 23:46:53 +0000
@@ -0,0 +1,124 @@
+# Copyright (C) 2006-2007 by Jelmer Vernooij
+#
+# 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
+"""Map Tree."""
+
+from __future__ import absolute_import
+
+def map_file_ids(repository, old_parents, new_parents):
+    """Try to determine the equivalent file ids in two sets of parents.
+
+    :param repository: Repository to use
+    :param old_parents: List of revision ids of old parents
+    :param new_parents: List of revision ids of new parents
+    """
+    assert len(old_parents) == len(new_parents)
+    ret = {}
+    for (oldp, newp) in zip(old_parents, new_parents):
+        oldtree = repository.revision_tree(oldp)
+        newtree = repository.revision_tree(newp)
+        for path, ie in oldtree.iter_entries_by_dir():
+            file_id = newtree.path2id(path)
+            if file_id is not None:
+                ret[ie.file_id] = file_id
+    return ret
+
+
+class MapTree(object):
+    """Wrapper around a tree that translates file ids.
+    """
+
+    def __init__(self, oldtree, fileid_map):
+        """Create a new MapTree.
+
+        :param oldtree: Old tree to map to.
+        :param fileid_map: Map with old -> new file ids.
+        """
+        self.oldtree = oldtree
+        self.map = fileid_map
+
+    def old_id(self, file_id):
+        """Look up the original file id of a file.
+
+        :param file_id: New file id
+        :return: Old file id if mapped, otherwise new file id
+        """
+        for x in self.map:
+            if self.map[x] == file_id:
+                return x
+        return file_id
+
+    def new_id(self, file_id):
+        """Look up the new file id of a file.
+
+        :param file_id: Old file id
+        :return: New file id
+        """
+        try:
+            return self.map[file_id]
+        except KeyError:
+            return file_id
+
+    def get_file_sha1(self, path, file_id=None):
+        "See Tree.get_file_sha1()."""
+        return self.oldtree.get_file_sha1(path)
+
+    def get_file_with_stat(self, path, file_id=None):
+        "See Tree.get_file_with_stat()."""
+        if getattr(self.oldtree, "get_file_with_stat", None) is not None:
+            return self.oldtree.get_file_with_stat(path=path)
+        else:
+            return self.get_file(path), None
+
+    def get_file(self, path, file_id=None):
+        "See Tree.get_file()."""
+        return self.oldtree.get_file(path)
+
+    def is_executable(self, path, file_id=None):
+        "See Tree.is_executable()."""
+        return self.oldtree.is_executable(path)
+
+    def has_filename(self, filename):
+        "See Tree.has_filename()."""
+        return self.oldtree.has_filename(filename)
+
+    def path_content_summary(self, path):
+        "See Tree.path_content_summary()."""
+        return self.oldtree.path_content_summary(path)
+
+    def map_ie(self, ie):
+        """Fix the references to old file ids in an inventory entry.
+
+        :param ie: Inventory entry to map
+        :return: New inventory entry
+        """
+        new_ie = ie.copy()
+        new_ie.file_id = self.new_id(new_ie.file_id)
+        new_ie.parent_id = self.new_id(new_ie.parent_id)
+        return new_ie
+
+    def iter_entries_by_dir(self):
+        """See Tree.iter_entries_by_dir."""
+        for path, ie in self.oldtree.iter_entries_by_dir():
+            yield path, self.map_ie(ie)
+
+    def path2id(self, path):
+        file_id = self.oldtree.path2id(path)
+        if file_id is None:
+            return None
+        return self.new_id(file_id)
+
+    def id2path(self, file_id):
+        return self.oldtree.id2path(self.old_id(file_id=file_id))

=== added file 'breezy/plugins/rewrite/pseudonyms.py'
--- breezy/plugins/rewrite/pseudonyms.py	1970-01-01 00:00:00 +0000
+++ breezy/plugins/rewrite/pseudonyms.py	2020-01-11 23:46:53 +0000
@@ -0,0 +1,211 @@
+# Copyright (C) 2009 by 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
+
+"""Revision pseudonyms."""
+
+from __future__ import absolute_import
+
+from collections import defaultdict
+
+from breezy import (
+    errors,
+    foreign,
+    ui,
+    urlutils,
+    )
+
+
+def parse_git_svn_id(text):
+    """Parse a git svn id string.
+
+    :param text: git svn id
+    :return: URL, revision number, uuid
+    """
+    (head, uuid) = text.rsplit(" ", 1)
+    (full_url, rev) = head.rsplit("@", 1)
+    return (full_url.encode("utf-8"), int(rev), uuid.encode("utf-8"))
+
+
+class SubversionBranchUrlFinder(object):
+
+    def __init__(self):
+        self._roots = defaultdict(set)
+
+    def find_root(self, uuid, url):
+        for root in self._roots[uuid]:
+            if url.startswith(root):
+                return root
+        try:
+            from subvertpy.ra import RemoteAccess
+        except ImportError:
+            return None
+        c = RemoteAccess(url)
+        root = c.get_repos_root()
+        self._roots[uuid].add(root)
+        return root
+
+    def find_branch_path(self, uuid, url):
+        root = self.find_root(uuid, url)
+        if root is None:
+            return None
+        assert url.startswith(root)
+        return url[len(root):].strip("/")
+
+
+svn_branch_path_finder = SubversionBranchUrlFinder()
+
+
+def _extract_converted_from_revid(rev):
+    if "converted-from" not in rev.properties:
+        return
+
+    for line in rev.properties.get("converted-from", "").splitlines():
+        (kind, serialized_foreign_revid) = line.split(" ", 1)
+        yield (kind, serialized_foreign_revid)
+
+
+def _extract_cscvs(rev):
+    """Older-style launchpad-cscvs import."""
+    if "cscvs-svn-branch-path" not in rev.properties:
+        return
+    yield (
+        "svn", "%s:%s:%s" % (
+            rev.properties["cscvs-svn-repository-uuid"],
+            rev.properties["cscvs-svn-revision-number"],
+            urlutils.quote(rev.properties["cscvs-svn-branch-path"].strip("/"))))
+
+
+def _extract_git_svn_id(rev):
+    if "git-svn-id" not in rev.properties:
+        return
+    (full_url, revnum, uuid) = parse_git_svn_id(rev.properties['git-svn-id'])
+    branch_path = svn_branch_path_finder.find_branch_path(uuid, full_url)
+    if branch_path is not None:
+        yield ("svn", "%s:%d:%s" % (uuid, revnum, urlutils.quote(branch_path)))
+
+
+def _extract_foreign_revision(rev):
+    # Perhaps 'rev' is a foreign revision ?
+    if getattr(rev, "foreign_revid", None) is not None:
+        yield ("svn", rev.mapping.vcs.serialize_foreign_revid(rev.foreign_revid))
+
+
+def _extract_foreign_revid(rev):
+    # Try parsing the revision id
+    try:
+        foreign_revid, mapping = \
+            foreign.foreign_vcs_registry.parse_revision_id(rev.revision_id)
+    except errors.InvalidRevisionId:
+        pass
+    else:
+        yield (
+            mapping.vcs.abbreviation,
+            mapping.vcs.serialize_foreign_revid(foreign_revid))
+
+
+def _extract_debian_md5sum(rev):
+    if 'deb-md5' in rev.properties:
+        yield ("debian-md5sum", rev.properties["deb-md5"])
+
+
+_foreign_revid_extractors = [
+    _extract_converted_from_revid,
+    _extract_cscvs,
+    _extract_git_svn_id,
+    _extract_foreign_revision,
+    _extract_foreign_revid,
+    _extract_debian_md5sum,
+    ]
+
+
+def extract_foreign_revids(rev):
+    """Find ids of semi-equivalent revisions in foreign VCS'es.
+
+    :param: Bazaar revision object
+    :return: Set with semi-equivalent revisions.
+    """
+    ret = set()
+    for extractor in _foreign_revid_extractors:
+        ret.update(extractor(rev))
+    return ret
+
+
+def find_pseudonyms(repository, revids):
+    """Find revisions that are pseudonyms of each other.
+
+    :param repository: Repository object
+    :param revids: Sequence of revision ids to check
+    :return: Iterable over sets of pseudonyms
+    """
+    # Where have foreign revids ended up?
+    conversions = defaultdict(set)
+    # What are native revids conversions of?
+    conversion_of = defaultdict(set)
+    revs = repository.get_revisions(revids)
+    pb = ui.ui_factory.nested_progress_bar()
+    try:
+        for i, rev in enumerate(revs):
+            pb.update("finding pseudonyms", i, len(revs))
+            for foreign_revid in extract_foreign_revids(rev):
+                conversion_of[rev.revision_id].add(foreign_revid)
+                conversions[foreign_revid].add(rev.revision_id)
+    finally:
+        pb.finished()
+    done = set()
+    for foreign_revid in conversions.keys():
+        ret = set()
+        check = set(conversions[foreign_revid])
+        while check:
+            x = check.pop()
+            extra = set()
+            for frevid in conversion_of[x]:
+                extra.update(conversions[frevid])
+                del conversions[frevid]
+            del conversion_of[x]
+            check.update(extra)
+            ret.add(x)
+        if len(ret) > 1:
+            yield ret
+
+
+def pseudonyms_as_dict(l):
+    """Convert an iterable over pseudonyms to a dictionary.
+
+    :param l: Iterable over sets of pseudonyms
+    :return: Dictionary with pseudonyms for each revid.
+    """
+    ret = {}
+    for pns in l:
+        for pn in pns:
+            ret[pn] = pns - set([pn])
+    return ret
+
+
+def generate_rebase_map_from_pseudonyms(pseudonym_dict, existing, desired):
+    """Create a rebase map from pseudonyms and existing/desired ancestry.
+
+    :param pseudonym_dict: Dictionary with pseudonym as returned by
+        pseudonyms_as_dict()
+    :param existing: Existing ancestry, might need to be rebased
+    :param desired: Desired ancestry
+    :return: rebase map, as dictionary
+    """
+    rebase_map = {}
+    for revid in existing:
+        for pn in pseudonym_dict.get(revid, []):
+            if pn in desired:
+                rebase_map[revid] = pn
+    return rebase_map

=== added file 'breezy/plugins/rewrite/rebase.py'
--- breezy/plugins/rewrite/rebase.py	1970-01-01 00:00:00 +0000
+++ breezy/plugins/rewrite/rebase.py	2020-01-11 23:46:53 +0000
@@ -0,0 +1,604 @@
+# Copyright (C) 2006-2007 by Jelmer Vernooij
+#
+# 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
+
+"""Rebase."""
+
+from __future__ import absolute_import
+
+import os
+
+from ... import (
+    config as _mod_config,
+    osutils,
+    )
+from ...errors import (
+    BzrError,
+    NoSuchFile,
+    UnknownFormatError,
+    NoCommonAncestor,
+    UnrelatedBranches,
+    )
+from ...bzr.generate_ids import gen_revision_id
+from ...graph import FrozenHeadsCache
+from ...merge import Merger
+from ...revision import NULL_REVISION
+from ...trace import mutter
+from ...tsort import topo_sort
+from ...tree import TreeChange
+from ... import ui
+
+from .maptree import (
+    MapTree,
+    map_file_ids,
+    )
+
+REBASE_PLAN_FILENAME = 'rebase-plan'
+REBASE_CURRENT_REVID_FILENAME = 'rebase-current'
+REBASE_PLAN_VERSION = 1
+REVPROP_REBASE_OF = 'rebase-of'
+
+class RebaseState(object):
+
+    def has_plan(self):
+        """Check whether there is a rebase plan present.
+
+        :return: boolean
+        """
+        raise NotImplementedError(self.has_plan)
+
+    def read_plan(self):
+        """Read a rebase plan file.
+
+        :return: Tuple with last revision info and replace map.
+        """
+        raise NotImplementedError(self.read_plan)
+
+    def write_plan(self, replace_map):
+        """Write a rebase plan file.
+
+        :param replace_map: Replace map (old revid -> (new revid, new parents))
+        """
+        raise NotImplementedError(self.write_plan)
+
+    def remove_plan(self):
+        """Remove a rebase plan file.
+        """
+        raise NotImplementedError(self.remove_plan)
+
+    def write_active_revid(self, revid):
+        """Write the id of the revision that is currently being rebased.
+
+        :param revid: Revision id to write
+        """
+        raise NotImplementedError(self.write_active_revid)
+
+    def read_active_revid(self):
+        """Read the id of the revision that is currently being rebased.
+
+        :return: Id of the revision that is being rebased.
+        """
+        raise NotImplementedError(self.read_active_revid)
+
+
+class RebaseState1(RebaseState):
+
+    def __init__(self, wt):
+        self.wt = wt
+        self.transport = wt._transport
+
+    def has_plan(self):
+        """See `RebaseState`."""
+        try:
+            return self.transport.get_bytes(REBASE_PLAN_FILENAME) != b''
+        except NoSuchFile:
+            return False
+
+    def read_plan(self):
+        """See `RebaseState`."""
+        text = self.transport.get_bytes(REBASE_PLAN_FILENAME)
+        if text == b'':
+            raise NoSuchFile(REBASE_PLAN_FILENAME)
+        return unmarshall_rebase_plan(text)
+
+    def write_plan(self, replace_map):
+        """See `RebaseState`."""
+        self.wt.update_feature_flags({b"rebase-v1": b"write-required"})
+        content = marshall_rebase_plan(
+            self.wt.branch.last_revision_info(), replace_map)
+        assert isinstance(content, bytes)
+        self.transport.put_bytes(REBASE_PLAN_FILENAME, content)
+
+    def remove_plan(self):
+        """See `RebaseState`."""
+        self.wt.update_feature_flags({b"rebase-v1": None})
+        self.transport.put_bytes(REBASE_PLAN_FILENAME, b'')
+
+    def write_active_revid(self, revid):
+        """See `RebaseState`."""
+        if revid is None:
+            revid = NULL_REVISION
+        assert isinstance(revid, bytes)
+        self.transport.put_bytes(REBASE_CURRENT_REVID_FILENAME, revid)
+
+    def read_active_revid(self):
+        """See `RebaseState`."""
+        try:
+            text = self.transport.get_bytes(REBASE_CURRENT_REVID_FILENAME).rstrip(b"\n")
+            if text == NULL_REVISION:
+                return None
+            return text
+        except NoSuchFile:
+            return None
+
+
+def marshall_rebase_plan(last_rev_info, replace_map):
+    """Marshall a rebase plan.
+
+    :param last_rev_info: Last revision info tuple.
+    :param replace_map: Replace map (old revid -> (new revid, new parents))
+    :return: string
+    """
+    ret = b"# Bazaar rebase plan %d\n" % REBASE_PLAN_VERSION
+    ret += b"%d %s\n" % last_rev_info
+    for oldrev in replace_map:
+        (newrev, newparents) = replace_map[oldrev]
+        ret += b"%s %s" % (oldrev, newrev) + \
+            b"".join([b" %s" % p for p in newparents]) + b"\n"
+    return ret
+
+
+def unmarshall_rebase_plan(text):
+    """Unmarshall a rebase plan.
+
+    :param text: Text to parse
+    :return: Tuple with last revision info, replace map.
+    """
+    lines = text.split(b'\n')
+    # Make sure header is there
+    if lines[0] != b"# Bazaar rebase plan %d" % REBASE_PLAN_VERSION:
+        raise UnknownFormatError(lines[0])
+
+    pts = lines[1].split(b" ", 1)
+    last_revision_info = (int(pts[0]), pts[1])
+    replace_map = {}
+    for l in lines[2:]:
+        if l == b"":
+            # Skip empty lines
+            continue
+        pts = l.split(b" ")
+        replace_map[pts[0]] = (pts[1], tuple(pts[2:]))
+    return (last_revision_info, replace_map)
+
+
+def regenerate_default_revid(repository, revid):
+    """Generate a revision id for the rebase of an existing revision.
+
+    :param repository: Repository in which the revision is present.
+    :param revid: Revision id of the revision that is being rebased.
+    :return: new revision id."""
+    if revid == NULL_REVISION:
+        return NULL_REVISION
+    rev = repository.get_revision(revid)
+    return gen_revision_id(rev.committer, rev.timestamp)
+
+
+def generate_simple_plan(todo_set, start_revid, stop_revid, onto_revid, graph,
+                         generate_revid, skip_full_merged=False):
+    """Create a simple rebase plan that replays history based
+    on one revision being replayed on top of another.
+
+    :param todo_set: A set of revisions to rebase. Only the revisions
+        topologically between stop_revid and start_revid (inclusive) are
+        rebased; other revisions are ignored (and references to them are
+        preserved).
+    :param start_revid: Id of revision at which to start replaying
+    :param stop_revid: Id of revision until which to stop replaying
+    :param onto_revid: Id of revision on top of which to replay
+    :param graph: Graph object
+    :param generate_revid: Function for generating new revision ids
+    :param skip_full_merged: Skip revisions that merge already merged
+                             revisions.
+
+    :return: replace map
+    """
+    assert start_revid is None or start_revid in todo_set, \
+        "invalid start revid(%r), todo_set(%r)" % (start_revid, todo_set)
+    assert stop_revid is None or stop_revid in todo_set, "invalid stop_revid"
+    replace_map = {}
+    parent_map = graph.get_parent_map(todo_set)
+    order = topo_sort(parent_map)
+    if stop_revid is None:
+        stop_revid = order[-1]
+    if start_revid is None:
+        # We need a common base.
+        lca = graph.find_lca(stop_revid, onto_revid)
+        if lca == set([NULL_REVISION]):
+            raise UnrelatedBranches()
+        start_revid = order[0]
+    todo = order[order.index(start_revid):order.index(stop_revid) + 1]
+    heads_cache = FrozenHeadsCache(graph)
+    # XXX: The output replacemap'd parents should get looked up in some manner
+    # by the heads cache? RBC 20080719
+    for oldrevid in todo:
+        oldparents = parent_map[oldrevid]
+        assert isinstance(oldparents, tuple), "not tuple: %r" % oldparents
+        parents = []
+        # Left parent:
+        if heads_cache.heads((oldparents[0], onto_revid)) == set((onto_revid,)):
+            parents.append(onto_revid)
+        elif oldparents[0] in replace_map:
+            parents.append(replace_map[oldparents[0]][0])
+        else:
+            parents.append(onto_revid)
+            parents.append(oldparents[0])
+        # Other parents:
+        if len(oldparents) > 1:
+            additional_parents = heads_cache.heads(oldparents[1:])
+            for oldparent in oldparents[1:]:
+                if oldparent in additional_parents:
+                    if heads_cache.heads((oldparent, onto_revid)) == set((onto_revid,)):
+                        pass
+                    elif oldparent in replace_map:
+                        newparent = replace_map[oldparent][0]
+                        if parents[0] == onto_revid:
+                            parents[0] = newparent
+                        else:
+                            parents.append(newparent)
+                    else:
+                        parents.append(oldparent)
+            if len(parents) == 1 and skip_full_merged:
+                continue
+        parents = tuple(parents)
+        newrevid = generate_revid(oldrevid, parents)
+        assert newrevid != oldrevid, "old and newrevid equal (%r)" % newrevid
+        assert isinstance(parents, tuple), "parents not tuple: %r" % parents
+        replace_map[oldrevid] = (newrevid, parents)
+    return replace_map
+
+
+def generate_transpose_plan(ancestry, renames, graph, generate_revid):
+    """Create a rebase plan that replaces a bunch of revisions
+    in a revision graph.
+
+    :param ancestry: Ancestry to consider
+    :param renames: Renames of revision
+    :param graph: Graph object
+    :param generate_revid: Function for creating new revision ids
+    """
+    replace_map = {}
+    todo = []
+    children = {}
+    parent_map = {}
+    for r, ps in ancestry:
+        if r not in children:
+            children[r] = []
+        if ps is None: # Ghost
+            continue
+        parent_map[r] = ps
+        if r not in children:
+            children[r] = []
+        for p in ps:
+            if p not in children:
+                children[p] = []
+            children[p].append(r)
+
+    parent_map.update(graph.get_parent_map(filter(lambda x: x not in parent_map, renames.values())))
+
+    # todo contains a list of revisions that need to
+    # be rewritten
+    for r, v in renames.items():
+        replace_map[r] = (v, parent_map[v])
+        todo.append(r)
+
+    total = len(todo)
+    processed = set()
+    i = 0
+    pb = ui.ui_factory.nested_progress_bar()
+    try:
+        while len(todo) > 0:
+            r = todo.pop()
+            processed.add(r)
+            i += 1
+            pb.update('determining dependencies', i, total)
+            # Add entry for them in replace_map
+            for c in children[r]:
+                if c in renames:
+                    continue
+                if c in replace_map:
+                    parents = replace_map[c][1]
+                else:
+                    parents = parent_map[c]
+                assert isinstance(parents, tuple), \
+                    "Expected tuple of parents, got: %r" % parents
+                # replace r in parents with replace_map[r][0]
+                if not replace_map[r][0] in parents:
+                    parents = list(parents)
+                    parents[parents.index(r)] = replace_map[r][0]
+                    parents = tuple(parents)
+                replace_map[c] = (generate_revid(c, tuple(parents)),
+                                  tuple(parents))
+                if replace_map[c][0] == c:
+                    del replace_map[c]
+                elif c not in processed:
+                    todo.append(c)
+    finally:
+        pb.finished()
+
+    # Remove items from the map that already exist
+    for revid in renames:
+        if revid in replace_map:
+            del replace_map[revid]
+
+    return replace_map
+
+
+def rebase_todo(repository, replace_map):
+    """Figure out what revisions still need to be rebased.
+
+    :param repository: Repository that contains the revisions
+    :param replace_map: Replace map
+    """
+    for revid, parent_ids in replace_map.items():
+        assert isinstance(parent_ids, tuple), "replace map parents not tuple"
+        if not repository.has_revision(parent_ids[0]):
+            yield revid
+
+
+def rebase(repository, replace_map, revision_rewriter):
+    """Rebase a working tree according to the specified map.
+
+    :param repository: Repository that contains the revisions
+    :param replace_map: Dictionary with revisions to (optionally) rewrite
+    :param merge_fn: Function for replaying a revision
+    """
+    # Figure out the dependencies
+    graph = repository.get_graph()
+    todo = list(graph.iter_topo_order(replace_map.keys()))
+    pb = ui.ui_factory.nested_progress_bar()
+    try:
+        for i, revid in enumerate(todo):
+            pb.update('rebase revisions', i, len(todo))
+            (newrevid, newparents) = replace_map[revid]
+            assert isinstance(newparents, tuple), "Expected tuple for %r" % newparents
+            if repository.has_revision(newrevid):
+                # Was already converted, no need to worry about it again
+                continue
+            revision_rewriter(revid, newrevid, newparents)
+    finally:
+        pb.finished()
+
+
+def wrap_iter_changes(old_iter_changes, map_tree):
+    for change in old_iter_changes:
+        if change.parent_id[0] is not None:
+            old_parent = map_tree.new_id(change.parent_id[0])
+        else:
+            old_parent = change.parent_id[0]
+        if change.parent_id[1] is not None:
+            new_parent = map_tree.new_id(change.parent_id[1])
+        else:
+            new_parent = change.parent_id[1]
+        yield TreeChange(
+            map_tree.new_id(change.file_id), change.path,
+            change.changed_content, change.versioned,
+            (old_parent, new_parent), change.name, change.kind,
+            change.executable)
+
+
+class CommitBuilderRevisionRewriter(object):
+    """Revision rewriter that use commit builder.
+
+    :ivar repository: Repository in which the revision is present.
+    """
+
+    def __init__(self, repository, map_ids=True):
+        self.repository = repository
+        self.map_ids = map_ids
+
+    def _get_present_revisions(self, revids):
+        return tuple([p for p in revids if self.repository.has_revision(p)])
+
+    def __call__(self, oldrevid, newrevid, new_parents):
+        """Replay a commit by simply commiting the same snapshot with different
+        parents.
+
+        :param oldrevid: Revision id of the revision to copy.
+        :param newrevid: Revision id of the revision to create.
+        :param new_parents: Revision ids of the new parent revisions.
+        """
+        assert isinstance(new_parents, tuple), "CommitBuilderRevisionRewriter: Expected tuple for %r" % new_parents
+        mutter('creating copy %r of %r with new parents %r',
+               newrevid, oldrevid, new_parents)
+        oldrev = self.repository.get_revision(oldrevid)
+
+        revprops = dict(oldrev.properties)
+        revprops[REVPROP_REBASE_OF] = oldrevid.decode('utf-8')
+
+        # Check what new_ie.file_id should be
+        # use old and new parent trees to generate new_id map
+        nonghost_oldparents = self._get_present_revisions(oldrev.parent_ids)
+        nonghost_newparents = self._get_present_revisions(new_parents)
+        oldtree = self.repository.revision_tree(oldrevid)
+        if self.map_ids:
+            fileid_map = map_file_ids(
+                self.repository, nonghost_oldparents,
+                nonghost_newparents)
+            mappedtree = MapTree(oldtree, fileid_map)
+        else:
+            mappedtree = oldtree
+
+        try:
+            old_base = nonghost_oldparents[0]
+        except IndexError:
+            old_base = NULL_REVISION
+        try:
+            new_base = new_parents[0]
+        except IndexError:
+            new_base = NULL_REVISION
+        old_base_tree = self.repository.revision_tree(old_base)
+        old_iter_changes = oldtree.iter_changes(old_base_tree)
+        iter_changes = wrap_iter_changes(old_iter_changes, mappedtree)
+        builder = self.repository.get_commit_builder(
+            branch=None, parents=new_parents, committer=oldrev.committer,
+            timestamp=oldrev.timestamp, timezone=oldrev.timezone,
+            revprops=revprops, revision_id=newrevid,
+            config_stack=_mod_config.GlobalStack())
+        try:
+            for (relpath, fs_hash) in builder.record_iter_changes(
+                    mappedtree, new_base, iter_changes):
+                pass
+            builder.finish_inventory()
+            return builder.commit(oldrev.message)
+        except:
+            builder.abort()
+            raise
+
+
+class WorkingTreeRevisionRewriter(object):
+
+    def __init__(self, wt, state, merge_type=None):
+        """
+        :param wt: Working tree in which to do the replays.
+        """
+        self.wt = wt
+        self.graph = self.wt.branch.repository.get_graph()
+        self.state = state
+        self.merge_type = merge_type
+
+    def __call__(self, oldrevid, newrevid, newparents):
+        """Replay a commit in a working tree, with a different base.
+
+        :param oldrevid: Old revision id
+        :param newrevid: New revision id
+        :param newparents: New parent revision ids
+        """
+        repository = self.wt.branch.repository
+        if self.merge_type is None:
+            from ...merge import Merge3Merger
+            merge_type = Merge3Merger
+        else:
+            merge_type = self.merge_type
+        oldrev = self.wt.branch.repository.get_revision(oldrevid)
+        # Make sure there are no conflicts or pending merges/changes
+        # in the working tree
+        complete_revert(self.wt, [newparents[0]])
+        assert not self.wt.changes_from(self.wt.basis_tree()).has_changed(), "Changes in rev"
+
+        oldtree = repository.revision_tree(oldrevid)
+        self.state.write_active_revid(oldrevid)
+        merger = Merger(self.wt.branch, this_tree=self.wt)
+        merger.set_other_revision(oldrevid, self.wt.branch)
+        base_revid = self.determine_base(
+            oldrevid, oldrev.parent_ids, newrevid, newparents)
+        mutter('replaying %r as %r with base %r and new parents %r' %
+               (oldrevid, newrevid, base_revid, newparents))
+        merger.set_base_revision(base_revid, self.wt.branch)
+        merger.merge_type = merge_type
+        merger.do_merge()
+        for newparent in newparents[1:]:
+            self.wt.add_pending_merge(newparent)
+        self.commit_rebase(oldrev, newrevid)
+        self.state.write_active_revid(None)
+
+    def determine_base(self, oldrevid, oldparents, newrevid, newparents):
+        """Determine the base for replaying a revision using merge.
+
+        :param oldrevid: Revid of old revision.
+        :param oldparents: List of old parents revids.
+        :param newrevid: Revid of new revision.
+        :param newparents: List of new parents revids.
+        :return: Revision id of the new new revision.
+        """
+        # If this was the first commit, no base is needed
+        if len(oldparents) == 0:
+            return NULL_REVISION
+
+        # In the case of a "simple" revision with just one parent,
+        # that parent should be the base
+        if len(oldparents) == 1:
+            return oldparents[0]
+
+        # In case the rhs parent(s) of the origin revision has already been
+        # merged in the new branch, use diff between rhs parent and diff from
+        # original revision
+        if len(newparents) == 1:
+            # FIXME: Find oldparents entry that matches newparents[0]
+            # and return it
+            return oldparents[1]
+
+        try:
+            return self.graph.find_unique_lca(*[oldparents[0], newparents[1]])
+        except NoCommonAncestor:
+            return oldparents[0]
+
+    def commit_rebase(self, oldrev, newrevid):
+        """Commit a rebase.
+
+        :param oldrev: Revision info of new revision to commit.
+        :param newrevid: New revision id."""
+        assert oldrev.revision_id != newrevid, "Invalid revid %r" % newrevid
+        revprops = dict(oldrev.properties)
+        revprops[REVPROP_REBASE_OF] = oldrev.revision_id.decode('utf-8')
+        committer = self.wt.branch.get_config().username()
+        authors = oldrev.get_apparent_authors()
+        if oldrev.committer == committer:
+            # No need to explicitly record the authors if the original
+            # committer is rebasing.
+            if [oldrev.committer] == authors:
+                authors = None
+        else:
+            if oldrev.committer not in authors:
+                authors.append(oldrev.committer)
+        if 'author' in revprops:
+            del revprops['author']
+        if 'authors' in revprops:
+            del revprops['authors']
+        self.wt.commit(
+            message=oldrev.message, timestamp=oldrev.timestamp,
+            timezone=oldrev.timezone, revprops=revprops, rev_id=newrevid,
+            committer=committer, authors=authors)
+
+
+def complete_revert(wt, newparents):
+    """Simple helper that reverts to specified new parents and makes sure none
+    of the extra files are left around.
+
+    :param wt: Working tree to use for rebase
+    :param newparents: New parents of the working tree
+    """
+    newtree = wt.branch.repository.revision_tree(newparents[0])
+    delta = wt.changes_from(newtree)
+    wt.branch.generate_revision_history(newparents[0])
+    wt.set_parent_ids([r for r in newparents[:1] if r != NULL_REVISION])
+    for change in delta.added:
+        abs_path = wt.abspath(change.path[1])
+        if osutils.lexists(abs_path):
+            if osutils.isdir(abs_path):
+                osutils.rmtree(abs_path)
+            else:
+                os.unlink(abs_path)
+    wt.revert(None, old_tree=newtree, backups=False)
+    assert not wt.changes_from(wt.basis_tree()).has_changed(), "Rev changed"
+    wt.set_parent_ids([r for r in newparents if r != NULL_REVISION])
+
+
+class ReplaySnapshotError(BzrError):
+    """Raised when replaying a snapshot failed."""
+    _fmt = """Replaying the snapshot failed: %(msg)s."""
+
+    def __init__(self, msg):
+        BzrError.__init__(self)
+        self.msg = msg

=== added directory 'breezy/plugins/rewrite/tests'
=== added file 'breezy/plugins/rewrite/tests/__init__.py'
--- breezy/plugins/rewrite/tests/__init__.py	1970-01-01 00:00:00 +0000
+++ breezy/plugins/rewrite/tests/__init__.py	2020-01-11 23:46:53 +0000
@@ -0,0 +1,29 @@
+# Copyright (C) 2007-2010 by 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
+
+"""Tests for brz-rewrite."""
+
+
+def load_tests(loader, basic_tests, pattern):
+    testmod_names = [
+        'test_blackbox',
+        'test_maptree',
+        'test_pseudonyms',
+        'test_rebase',
+        'test_upgrade']
+    basic_tests.addTest(loader.loadTestsFromModuleNames(
+        ["%s.%s" % (__name__, tmn) for tmn in testmod_names]))
+    return basic_tests

=== added file 'breezy/plugins/rewrite/tests/test_blackbox.py'
--- breezy/plugins/rewrite/tests/test_blackbox.py	1970-01-01 00:00:00 +0000
+++ breezy/plugins/rewrite/tests/test_blackbox.py	2020-01-11 23:46:53 +0000
@@ -0,0 +1,363 @@
+# Copyright (C) 2007 by 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
+
+"""Couple of blackbox tests for the rewrite plugin."""
+
+import os
+
+from ....branch import Branch
+from ....tests.blackbox import ExternalBase
+
+class TestRebaseSimple(ExternalBase):
+
+    def make_file(self, name, contents):
+        with open(name, 'w' + ('b' if isinstance(contents, bytes) else '')) as f:
+            f.write(contents)
+
+    def setUp(self):
+        super(TestRebaseSimple, self).setUp()
+        os.mkdir('main')
+        os.chdir('main')
+        self.run_bzr('init')
+        self.make_file('hello', b"hi world")
+        self.run_bzr('add')
+        self.run_bzr('commit -m bla')
+        self.run_bzr('branch . ../feature')
+
+    def test_no_upstream_branch(self):
+        self.run_bzr_error(['brz: ERROR: No upstream branch specified.\n'],
+                           'rebase')
+
+    def test_notneeded(self):
+        os.chdir('../feature')
+        self.assertEquals(
+            'No revisions to rebase.\n',
+            self.run_bzr('rebase ../main')[0])
+
+    def test_custom_merge_type(self):
+        self.make_file('hello', '42')
+        self.run_bzr('commit -m that')
+        os.chdir('../feature')
+        self.make_file('hoi', "my data")
+        self.run_bzr('add')
+        self.run_bzr('commit -m this')
+        self.assertEquals('', self.run_bzr('rebase --lca ../main')[0])
+        self.assertEquals('3\n', self.run_bzr('revno')[0])
+
+    def test_notneeded_feature_ahead(self):
+        os.chdir('../feature')
+        self.make_file('barbla', "bloe")
+        self.run_bzr('add')
+        self.run_bzr('commit -m bloe')
+        self.assertEquals(
+            'No revisions to rebase.\n',
+            self.run_bzr('rebase ../main')[0])
+
+    def test_notneeded_main_ahead(self):
+        self.make_file('barbla', "bloe")
+        self.run_bzr('add')
+        self.run_bzr('commit -m bloe')
+        os.chdir('../feature')
+        self.assertEquals(
+            "Base branch is descendant of current branch. Pulling instead.\n",
+            self.run_bzr('rebase ../main')[0])
+        self.assertEquals(Branch.open("../feature").last_revision_info(),
+                          Branch.open("../main").last_revision_info())
+
+    def test_no_pending_merges(self):
+        self.run_bzr_error(['brz: ERROR: No pending merges present.\n'],
+                           ['rebase', '--pending-merges'])
+
+    def test_pending_merges(self):
+        os.chdir('..')
+        self.build_tree_contents([('main/hello', '42')])
+        self.run_bzr('add', working_dir='main')
+        self.run_bzr('commit -m that main')
+        self.build_tree_contents([('feature/hoi', 'my data')])
+        self.run_bzr('add', working_dir='feature')
+        self.run_bzr('commit -m this feature')
+        self.assertEqual(
+            ('', ' M  hello\nAll changes applied successfully.\n'),
+            self.run_bzr('merge ../main', working_dir='feature'))
+        out, err = self.run_bzr('rebase --pending-merges', working_dir='feature')
+        self.assertEqual('', out)
+        self.assertContainsRe(err, 'modified hello')
+        self.assertEqual(
+            ('3\n', ''),
+            self.run_bzr('revno', working_dir='feature'))
+
+    def test_simple_success(self):
+        self.make_file('hello', '42')
+        self.run_bzr('commit -m that')
+        os.chdir('../feature')
+        self.make_file('hoi', "my data")
+        self.run_bzr('add')
+        self.run_bzr('commit -m this')
+        self.assertEquals('', self.run_bzr('rebase ../main')[0])
+        self.assertEquals('3\n', self.run_bzr('revno')[0])
+
+    def test_range(self):
+        # commit mainline rev 2
+        self.make_file('hello', '42')
+        self.run_bzr('commit -m that')
+        # commit feature rev 2
+        os.chdir('../feature')
+        self.make_file('hoi', "my data")
+        self.run_bzr('add')
+        self.run_bzr('commit -m this')
+        # commit feature rev 3
+        self.make_file('hooi', "your data")
+        self.run_bzr('add')
+        self.run_bzr('commit -m that')
+        # commit feature rev 4
+        self.make_file('hoooi', "someone else's data")
+        self.run_bzr('add')
+        self.run_bzr('commit -m these')
+        # pick up just rev 2 and 3 and discard 4 from feature
+        self.assertEquals('', self.run_bzr('rebase -r2..3 ../main')[0])
+        # our rev 2 is now rev3 and 3 is now rev4:
+        self.assertEquals('4\n', self.run_bzr('revno')[0])
+        # content added from our old revisions 4 should be gone.
+        self.assertPathDoesNotExist('hoooi')
+
+    def test_range_open_end(self):
+        # commit mainline rev 2
+        self.make_file('hello', '42')
+        self.run_bzr('commit -m that')
+        # commit feature rev 2
+        os.chdir('../feature')
+        self.make_file('hoi', "my data")
+        self.run_bzr('add')
+        self.run_bzr('commit -m this')
+        # commit feature rev 3
+        self.make_file('hooi', "your data")
+        self.run_bzr('add')
+        self.run_bzr('commit -m that')
+        # commit feature rev 4
+        self.make_file('hoooi', "someone else's data")
+        self.run_bzr('add')
+        self.run_bzr('commit -m these')
+        # rebase only rev 4 onto main
+        self.assertEquals('', self.run_bzr('rebase -r4.. ../main')[0])
+        # should only get rev 3 (our old 2 and 3 are gone)
+        self.assertEquals('3\n', self.run_bzr('revno')[0])
+        self.assertPathDoesNotExist('hoi')
+        self.assertPathDoesNotExist('hooi')
+        branch = Branch.open(".")
+        self.assertEquals(
+            "these",
+            branch.repository.get_revision(branch.last_revision()).message)
+        self.assertPathExists('hoooi')
+
+    def test_conflicting(self):
+        # commit mainline rev 2
+        self.make_file('hello', '42')
+        self.run_bzr('commit -m that')
+        # commit feature rev 2 changing hello differently
+        os.chdir('../feature')
+        self.make_file('hello', "other data")
+        self.run_bzr('commit -m this')
+        self.run_bzr_error([
+            'Text conflict in hello\n1 conflicts encountered.\nbrz: ERROR: A conflict occurred replaying a commit. Resolve the conflict and run \'brz rebase-continue\' or run \'brz rebase-abort\'.',
+            ], ['rebase', '../main'])
+
+    def test_conflicting_abort(self):
+        self.make_file('hello', '42')
+        self.run_bzr('commit -m that')
+        os.chdir('../feature')
+        self.make_file('hello', "other data")
+        self.run_bzr('commit -m this')
+        old_log = self.run_bzr('log')[0]
+        self.run_bzr_error(['Text conflict in hello\n1 conflicts encountered.\nbrz: ERROR: A conflict occurred replaying a commit. Resolve the conflict and run \'brz rebase-continue\' or run \'brz rebase-abort\'.\n'], ['rebase', '../main'])
+        self.assertEquals('', self.run_bzr('rebase-abort')[0])
+        self.assertEquals(old_log, self.run_bzr('log')[0])
+
+    def test_conflicting_continue(self):
+        self.make_file('hello', '42')
+        self.run_bzr('commit -m that')
+        os.chdir('../feature')
+        self.make_file('hello', "other data")
+        self.run_bzr('commit -m this')
+        self.run_bzr_error(['Text conflict in hello\n1 conflicts encountered.\nbrz: ERROR: A conflict occurred replaying a commit. Resolve the conflict and run \'brz rebase-continue\' or run \'brz rebase-abort\'.\n'], ['rebase', '../main'])
+        self.run_bzr('resolved hello')
+        self.assertEquals('', self.run_bzr('rebase-continue')[0])
+        self.assertEquals('3\n', self.run_bzr('revno')[0])
+
+    def test_continue_nothing(self):
+        self.run_bzr_error(['brz: ERROR: No rebase to continue'],
+                           ['rebase-continue'])
+
+    def test_abort_nothing(self):
+        self.run_bzr_error(['brz: ERROR: No rebase to abort'],
+                           ['rebase-abort'])
+
+    def test_todo_nothing(self):
+        self.run_bzr_error(['brz: ERROR: No rebase in progress'],
+                           ['rebase-todo'])
+
+    def test_onto(self):
+        self.make_file('hello', '42')
+        self.run_bzr('add')
+        self.run_bzr('commit -m that')
+        self.make_file('other', '43')
+        self.run_bzr('add')
+        self.run_bzr('commit -m that_other')
+        os.chdir('../feature')
+        self.make_file('hoi', "my data")
+        self.run_bzr('add')
+        self.run_bzr('commit -m this')
+        self.assertEquals(
+            '', self.run_bzr('rebase --onto -2 ../main')[0])
+        self.assertEquals(
+            '3\n', self.run_bzr('revno')[0])
+
+    def test_unrelated(self):
+        os.chdir('..')
+        os.mkdir('unrelated')
+        os.chdir('unrelated')
+        self.run_bzr('init')
+        self.make_file('hello', "hi world")
+        self.run_bzr('add')
+        self.run_bzr('commit -m x')
+        self.run_bzr_error(['brz: ERROR: Branches have no common ancestor, and no merge base.*'],
+                           ['rebase', '../main'])
+
+    def test_verbose(self):
+        self.make_file('hello', '42')
+        self.run_bzr('commit -m that')
+        os.chdir('../feature')
+        self.make_file('hoi', "my data")
+        self.run_bzr('add')
+        self.run_bzr('commit -m this')
+        out, err = self.run_bzr('rebase -v ../main')
+        self.assertContainsRe(err, '1 revisions will be rebased:')
+        self.assertEqual('', out)
+        self.assertEqual('3\n', self.run_bzr('revno')[0])
+
+    def test_useless_merge(self):
+        self.make_file('bar', '42')
+        self.run_bzr('add')
+        self.run_bzr('commit -m that')
+        os.chdir('../feature')
+        self.make_file('hello', "my data")
+        self.run_bzr('commit -m this')
+        self.run_bzr('merge')
+        self.run_bzr('commit -m merge')
+        self.run_bzr('rebase')
+
+    def strip_last_revid_part(self, revid):
+        """Assume revid is a revid in the default form, and strip the part
+        which would be random.
+        """
+        return revid[:revid.rindex(b'-')]
+
+    def test_always_rebase_merges(self):
+        trunk = self.make_branch_and_tree('trunk')
+        trunk.commit('base')
+        feature2 = trunk.controldir.sprout('feature2').open_workingtree()
+        revid2 = feature2.commit('change')
+        feature = trunk.controldir.sprout('feature').open_workingtree()
+        feature.commit('change')
+        feature.merge_from_branch(feature2.branch)
+        feature.commit('merge')
+        feature.commit('change2')
+        trunk.commit('additional upstream change')
+        self.run_bzr('rebase --always-rebase-merges ../trunk', working_dir='feature')
+        # second revision back should be a merge of feature2
+        repo = feature.branch.repository
+        repo.lock_read()
+        self.addCleanup(repo.unlock)
+        tip = feature.last_revision()
+        merge_id = repo.get_graph().get_parent_map([tip])[tip][0]
+        merge_parents = repo.get_graph().get_parent_map([merge_id])[merge_id]
+        self.assertEqual(self.strip_last_revid_part(revid2),
+                         self.strip_last_revid_part(merge_parents[1]))
+
+    def test_rebase_merge(self):
+        trunk = self.make_branch_and_tree('trunk')
+        trunk.commit('base')
+        feature2 = trunk.controldir.sprout('feature2').open_workingtree()
+        revid2 = feature2.commit('change')
+        feature = trunk.controldir.sprout('feature').open_workingtree()
+        feature.commit('change')
+        feature.merge_from_branch(feature2.branch)
+        feature.commit('merge')
+        feature.commit('change2')
+        trunk.commit('additional upstream change')
+        self.run_bzr('rebase ../trunk', working_dir='feature')
+        # second revision back should be a merge of feature2
+        repo = feature.branch.repository
+        repo.lock_read()
+        self.addCleanup(repo.unlock)
+        tip = feature.last_revision()
+        merge_id = repo.get_graph().get_parent_map([tip])[tip][0]
+        merge_parents = repo.get_graph().get_parent_map([merge_id])[merge_id]
+        self.assertEqual(self.strip_last_revid_part(revid2),
+                         self.strip_last_revid_part(merge_parents[1]))
+
+    def test_directory(self):
+        self.make_file('test_directory1', "testing non-current directories")
+        self.run_bzr('add')
+        self.run_bzr('commit -m blah')
+        os.chdir('../feature')
+        self.make_file('test_directory2', "testing non-current directories")
+        self.run_bzr('add')
+        self.run_bzr('commit -m blah')
+        os.chdir('..')
+        self.assertEquals('', self.run_bzr('rebase -d feature main')[0])
+
+
+class ReplayTests(ExternalBase):
+
+    def test_replay(self):
+        os.mkdir('main')
+        os.chdir('main')
+        self.run_bzr('init')
+        open('bar', 'w').write('42')
+        self.run_bzr('add')
+        self.run_bzr('commit -m that')
+        os.mkdir('../feature')
+        os.chdir('../feature')
+        self.run_bzr('init')
+        branch = Branch.open('.')
+        open('hello', 'w').write("my data")
+        self.run_bzr('add')
+        self.run_bzr('commit -m this')
+        self.assertEquals(1, branch.revno())
+        self.run_bzr('replay -r1 ../main')
+        self.assertEquals(2, branch.revno())
+        self.assertTrue(os.path.exists('bar'))
+
+    def test_replay_open_range(self):
+        os.mkdir('main')
+        os.chdir('main')
+        self.run_bzr('init')
+        open('bar', 'w').write('42')
+        self.run_bzr('add')
+        self.run_bzr('commit -m that')
+        open('bar', 'w').write('84')
+        self.run_bzr('commit -m blathat')
+        os.mkdir('../feature')
+        os.chdir('../feature')
+        self.run_bzr('init')
+        branch = Branch.open('.')
+        open('hello', 'w').write("my data")
+        self.run_bzr('add')
+        self.run_bzr('commit -m this')
+        self.assertEquals(1, branch.revno())
+        self.run_bzr('replay -r1.. ../main')
+        self.assertEquals(3, branch.revno())
+        self.assertTrue(os.path.exists('bar'))

=== added file 'breezy/plugins/rewrite/tests/test_maptree.py'
--- breezy/plugins/rewrite/tests/test_maptree.py	1970-01-01 00:00:00 +0000
+++ breezy/plugins/rewrite/tests/test_maptree.py	2020-01-11 23:46:53 +0000
@@ -0,0 +1,81 @@
+# Copyright (C) 2006-2007 by Jelmer Vernooij
+#
+# 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
+"""Tests for the maptree code."""
+
+from ....tests import (
+    TestCase,
+    TestCaseWithTransport,
+    )
+from ....treebuilder import (
+    TreeBuilder,
+    )
+
+from ..maptree import (
+    MapTree,
+    map_file_ids,
+    )
+
+
+class EmptyMapTreeTests(TestCaseWithTransport):
+
+    def setUp(self):
+        super(EmptyMapTreeTests, self).setUp()
+        tree = self.make_branch_and_tree('branch')
+        self.oldtree = tree
+
+    def test_has_filename(self):
+        self.oldtree.lock_write()
+        builder = TreeBuilder()
+        builder.start_tree(self.oldtree)
+        builder.build(['foo'])
+        builder.finish_tree()
+        self.maptree = MapTree(self.oldtree, {})
+        self.oldtree.unlock()
+        self.assertTrue(self.maptree.has_filename('foo'))
+        self.assertTrue(self.oldtree.has_filename('foo'))
+        self.assertFalse(self.maptree.has_filename('bar'))
+
+    def test_path2id(self):
+        self.oldtree.lock_write()
+        self.addCleanup(self.oldtree.unlock)
+        builder = TreeBuilder()
+        builder.start_tree(self.oldtree)
+        builder.build(['foo'])
+        builder.build(['bar'])
+        builder.build(['bla'])
+        builder.finish_tree()
+        self.maptree = MapTree(self.oldtree, {})
+        self.assertEquals(self.oldtree.path2id("foo"),
+                          self.maptree.path2id("foo"))
+
+    def test_id2path(self):
+        self.oldtree.lock_write()
+        self.addCleanup(self.oldtree.unlock)
+        builder = TreeBuilder()
+        builder.start_tree(self.oldtree)
+        builder.build(['foo'])
+        builder.build(['bar'])
+        builder.build(['bla'])
+        builder.finish_tree()
+        self.maptree = MapTree(self.oldtree, {})
+        self.assertEquals(
+            "foo", self.maptree.id2path(self.maptree.path2id("foo")))
+
+
+class MapFileIdTests(TestCase):
+
+    def test_empty(self):
+        self.assertEquals({}, map_file_ids(None, [], []))

=== added file 'breezy/plugins/rewrite/tests/test_pseudonyms.py'
--- breezy/plugins/rewrite/tests/test_pseudonyms.py	1970-01-01 00:00:00 +0000
+++ breezy/plugins/rewrite/tests/test_pseudonyms.py	2020-01-11 23:46:53 +0000
@@ -0,0 +1,39 @@
+# Copyright (C) 2010 by 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
+
+"""Tests for pseudonym handling."""
+
+from ....revision import Revision
+from ....tests import TestCase
+
+from ..pseudonyms import extract_foreign_revids
+
+
+class ExtractForeignRevidTests(TestCase):
+
+    def test_no_foreign_revid(self):
+        x = Revision(b"myrevid")
+        self.assertEquals(set(), extract_foreign_revids(x))
+
+    def test_cscvs(self):
+        x = Revision(b"myrevid")
+        x.properties = {
+            "cscvs-svn-repository-uuid": "someuuid",
+            "cscvs-svn-revision-number": "4",
+            "cscvs-svn-branch-path": "/trunk"}
+        self.assertEquals(
+            set([("svn", "someuuid:4:trunk")]),
+            extract_foreign_revids(x))

=== added file 'breezy/plugins/rewrite/tests/test_rebase.py'
--- breezy/plugins/rewrite/tests/test_rebase.py	1970-01-01 00:00:00 +0000
+++ breezy/plugins/rewrite/tests/test_rebase.py	2020-01-11 23:46:53 +0000
@@ -0,0 +1,669 @@
+# Copyright (C) 2006-2007 by Jelmer Vernooij
+#
+# 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
+
+"""Tests for the rebase code."""
+
+from ....conflicts import ConflictList
+from ....errors import (
+    UnknownFormatError,
+    NoSuchFile,
+    ConflictsInTree,
+    )
+from ....graph import (
+    Graph,
+    DictParentsProvider,
+    )
+from ....revision import NULL_REVISION
+from ....tests import TestCase, TestCaseWithTransport
+from ....tests.matchers import RevisionHistoryMatches
+
+from ..rebase import (
+    marshall_rebase_plan,
+    unmarshall_rebase_plan,
+    CommitBuilderRevisionRewriter,
+    generate_simple_plan,
+    generate_transpose_plan,
+    rebase_todo,
+    REBASE_PLAN_FILENAME,
+    REBASE_CURRENT_REVID_FILENAME,
+    RebaseState1,
+    ReplaySnapshotError,
+    WorkingTreeRevisionRewriter,
+    )
+
+
+class RebasePlanReadWriterTests(TestCase):
+
+    def test_simple_marshall_rebase_plan(self):
+        self.assertEqualDiff(b"""\
+# Bazaar rebase plan 1
+1 bla
+oldrev newrev newparent1 newparent2
+""", marshall_rebase_plan((1, b"bla"),
+                          {b"oldrev": (b"newrev", (b"newparent1", b"newparent2"))}))
+
+    def test_simple_unmarshall_rebase_plan(self):
+        self.assertEquals(((1, b"bla"),
+                          {b"oldrev": (b"newrev", (b"newparent1", b"newparent2"))}),
+                          unmarshall_rebase_plan(b"""# Bazaar rebase plan 1
+1 bla
+oldrev newrev newparent1 newparent2
+"""))
+
+    def test_unmarshall_rebase_plan_formatunknown(self):
+        self.assertRaises(UnknownFormatError,
+                          unmarshall_rebase_plan, b"""# Bazaar rebase plan x
+1 bla
+oldrev newrev newparent1 newparent2
+""")
+
+
+class ConversionTests(TestCaseWithTransport):
+
+    def test_simple(self):
+        wt = self.make_branch_and_tree('.')
+        b = wt.branch
+        with open('hello', 'w') as f:
+            f.write('hello world')
+        wt.add('hello')
+        wt.commit(message='add hello', rev_id=b"bla")
+        with open('hello', 'w') as f:
+            f.write('world')
+        wt.commit(message='change hello', rev_id=b"bloe")
+        wt.set_last_revision(b"bla")
+        b.generate_revision_history(b"bla")
+        with open('hello', 'w') as f:
+            f.write('world')
+        wt.commit(message='change hello', rev_id=b"bla2")
+
+        wt.branch.repository.lock_write()
+        newrev = CommitBuilderRevisionRewriter(wt.branch.repository)(
+            b"bla2", b"bla4", (b"bloe",))
+        self.assertEqual(b"bla4", newrev)
+        self.assertTrue(wt.branch.repository.has_revision(newrev))
+        self.assertEqual(
+            (b"bloe",), wt.branch.repository.get_parent_map([newrev])[newrev])
+        self.assertEqual(
+            "bla2", wt.branch.repository.get_revision(newrev).properties["rebase-of"])
+        wt.branch.repository.unlock()
+
+
+class PlanCreatorTests(TestCaseWithTransport):
+
+    def test_simple_plan_creator(self):
+        wt = self.make_branch_and_tree('.')
+        b = wt.branch
+        with open('hello', 'w') as f:
+            f.write('hello world')
+        wt.add('hello')
+        wt.commit(message='add hello', rev_id=b"bla")
+        with open('hello', 'w') as f:
+            f.write('world')
+        wt.commit(message='change hello', rev_id=b"bloe")
+        wt.set_last_revision(b"bla")
+        b.generate_revision_history(b"bla")
+        with open('hello', 'w') as f:
+            f.write('world')
+        wt.commit(message='change hello', rev_id=b"bla2")
+
+        b.repository.lock_read()
+        graph = b.repository.get_graph()
+        self.assertEquals(
+            {b'bla2': (b'newbla2', (b"bloe",))},
+            generate_simple_plan(
+                graph.find_difference(b.last_revision(), b"bla")[0],
+                b"bla2", None, b"bloe", graph, lambda y, _: b"new" + y))
+        b.repository.unlock()
+
+    def test_simple_plan_creator_extra_history(self):
+        wt = self.make_branch_and_tree('.')
+        b = wt.branch
+        with open('hello', 'w') as f:
+            f.write('hello world')
+        wt.add('hello')
+        wt.commit(message='add hello', rev_id=b"bla")
+        with open('hello', 'w') as f:
+            f.write('world')
+        wt.commit(message='change hello', rev_id=b"bloe")
+        wt.set_last_revision(b"bla")
+        b.generate_revision_history(b"bla")
+        with open('hello', 'w') as f:
+            f.write('world')
+        wt.commit(message='change hello', rev_id=b"bla2")
+        with open('hello', 'w') as f:
+            f.write('universe')
+        wt.commit(message='change hello again', rev_id=b"bla3")
+
+        with b.repository.lock_read():
+            graph = b.repository.get_graph()
+            self.assertEquals(
+                {b'bla2': (b'newbla2', (b"bloe",)), b'bla3': (b'newbla3', (b'newbla2',))},
+                generate_simple_plan(
+                    graph.find_difference(b.last_revision(), b"bloe")[0],
+                    b"bla2", None, b"bloe",
+                    graph, lambda y, _: b"new" + y))
+
+    def test_generate_transpose_plan(self):
+        wt = self.make_branch_and_tree('.')
+        b = wt.branch
+        with open('hello', 'w') as f:
+            f.write('hello world')
+        wt.add('hello')
+        wt.commit(message='add hello', rev_id=b"bla")
+        with open('hello', 'w') as f:
+            f.write('world')
+        wt.commit(message='change hello', rev_id=b"bloe")
+        wt.set_last_revision(b"bla")
+        b.generate_revision_history(b"bla")
+        with open('hello', 'w') as f:
+            f.write('world')
+        wt.commit(message='change hello', rev_id=b"bla2")
+        with open('hello', 'w') as f:
+            f.write('universe')
+        wt.commit(message='change hello again', rev_id=b"bla3")
+        wt.set_last_revision(b"bla")
+        b.generate_revision_history(b"bla")
+        with open('hello', 'w') as f:
+            f.write('somebar')
+        wt.commit(message='change hello yet again', rev_id=b"blie")
+        wt.set_last_revision(NULL_REVISION)
+        b.generate_revision_history(NULL_REVISION)
+        wt.add('hello')
+        wt.commit(message='add hello', rev_id=b"lala")
+
+        b.repository.lock_read()
+        graph = b.repository.get_graph()
+        self.assertEquals({
+            b'blie': (b'newblie', (b'lala',))},
+            generate_transpose_plan(graph.iter_ancestry(
+                [b"blie"]),
+                {b"bla": b"lala"}, graph, lambda y, _: b"new" + y))
+        self.assertEquals({
+            b'bla2': (b'newbla2', (b'lala',)),
+            b'bla3': (b'newbla3', (b'newbla2',)),
+            b'blie': (b'newblie', (b'lala',)),
+            b'bloe': (b'newbloe', (b'lala',))},
+            generate_transpose_plan(graph.iter_ancestry(
+                b.repository._all_revision_ids()),
+                {b"bla": b"lala"}, graph, lambda y, _: b"new" + y))
+        b.repository.unlock()
+
+    def test_generate_transpose_plan_one(self):
+        graph = Graph(DictParentsProvider({"bla": ("bloe",), "bloe": (), "lala": ()}))
+        self.assertEquals(
+            {"bla": ("newbla", ("lala",))},
+            generate_transpose_plan(graph.iter_ancestry(
+                ["bla", "bloe"]), {"bloe": "lala"}, graph, lambda y, _: "new" + y))
+
+    def test_plan_with_already_merged(self):
+        """We need to use a merge base that makes sense.
+
+        A
+        | \
+        B  D
+        | \|
+        C  E
+
+        Rebasing E on C should result in:
+
+        A -> B -> C -> D -> E
+
+        with a plan of:
+
+        D -> (D', [C])
+        E -> (E', [D', C])
+        """
+        parents_map = {
+            "A": (),
+            "B": ("A",),
+            "C": ("B",),
+            "D": ("A",),
+            "E": ("D", "B")
+        }
+        graph = Graph(DictParentsProvider(parents_map))
+        self.assertEquals(
+            {"D": ("D'", ("C",)), "E": ("E'", ("D'",))},
+            generate_simple_plan(
+                ["D", "E"], "D", None, "C", graph, lambda y, _: y + "'"))
+
+    def test_plan_with_already_merged_skip_merges(self):
+        """We need to use a merge base that makes sense.
+
+        A
+        | \
+        B  D
+        | \|
+        C  E
+
+        Rebasing E on C should result in:
+
+        A -> B -> C -> D'
+
+        with a plan of:
+
+        D -> (D', [C])
+        """
+        parents_map = {
+            "A": (),
+            "B": ("A",),
+            "C": ("B",),
+            "D": ("A",),
+            "E": ("D", "B")
+        }
+        graph = Graph(DictParentsProvider(parents_map))
+        self.assertEquals(
+            {"D": ("D'", ("C",))},
+            generate_simple_plan(
+                ["D", "E"], "D", None, "C", graph, lambda y, _: y + "'", True))
+
+
+class RebaseStateTests(TestCaseWithTransport):
+
+    def setUp(self):
+        super(RebaseStateTests, self).setUp()
+        self.wt = self.make_branch_and_tree('.')
+        self.state = RebaseState1(self.wt)
+
+    def test_rebase_plan_exists_false(self):
+        self.assertFalse(self.state.has_plan())
+
+    def test_rebase_plan_exists_empty(self):
+        self.wt._transport.put_bytes(REBASE_PLAN_FILENAME, b"")
+        self.assertFalse(self.state.has_plan())
+
+    def test_rebase_plan_exists(self):
+        self.wt._transport.put_bytes(REBASE_PLAN_FILENAME, b"foo")
+        self.assertTrue(self.state.has_plan())
+
+    def test_remove_rebase_plan(self):
+        self.wt._transport.put_bytes(REBASE_PLAN_FILENAME, b"foo")
+        self.state.remove_plan()
+        self.assertFalse(self.state.has_plan())
+
+    def test_remove_rebase_plan_twice(self):
+        self.state.remove_plan()
+        self.assertFalse(self.state.has_plan())
+
+    def test_write_rebase_plan(self):
+        with open('hello', 'w') as f:
+            f.write('hello world')
+        self.wt.add('hello')
+        self.wt.commit(message='add hello', rev_id=b"bla")
+        self.state.write_plan(
+            {b"oldrev": (b"newrev", [b"newparent1", b"newparent2"])})
+        self.assertEqualDiff(b"""# Bazaar rebase plan 1
+1 bla
+oldrev newrev newparent1 newparent2
+""", self.wt._transport.get_bytes(REBASE_PLAN_FILENAME))
+
+    def test_read_rebase_plan_nonexistant(self):
+        self.assertRaises(NoSuchFile, self.state.read_plan)
+
+    def test_read_rebase_plan_empty(self):
+        self.wt._transport.put_bytes(REBASE_PLAN_FILENAME, b"")
+        self.assertRaises(NoSuchFile, self.state.read_plan)
+
+    def test_read_rebase_plan(self):
+        self.wt._transport.put_bytes(
+            REBASE_PLAN_FILENAME,
+            b"""# Bazaar rebase plan 1
+1 bla
+oldrev newrev newparent1 newparent2
+""")
+        self.assertEquals(
+            ((1, b"bla"), {b"oldrev": (b"newrev", (b"newparent1", b"newparent2"))}),
+            self.state.read_plan())
+
+    def test_read_nonexistant(self):
+        self.assertIs(None, self.state.read_active_revid())
+
+    def test_read_null(self):
+        self.wt._transport.put_bytes(REBASE_CURRENT_REVID_FILENAME, NULL_REVISION)
+        self.assertIs(None, self.state.read_active_revid())
+
+    def test_read(self):
+        self.wt._transport.put_bytes(REBASE_CURRENT_REVID_FILENAME, b"bla")
+        self.assertEquals(b"bla", self.state.read_active_revid())
+
+    def test_write(self):
+        self.state.write_active_revid(b"bloe")
+        self.assertEquals(b"bloe", self.state.read_active_revid())
+
+    def test_write_null(self):
+        self.state.write_active_revid(None)
+        self.assertIs(None, self.state.read_active_revid())
+
+
+class RebaseTodoTests(TestCase):
+
+    def test_done(self):
+        class Repository:
+            def has_revision(self, revid):
+                return revid == "bloe"
+        self.assertEquals(
+            [], list(rebase_todo(Repository(), {"bla": ("bloe", [])})))
+
+    def test_notstarted(self):
+        class Repository:
+            def has_revision(self, revid):
+                return False
+        self.assertEquals(["bla"], list(rebase_todo(Repository(), {"bla": ("bloe", [])})))
+
+    def test_halfway(self):
+        class Repository:
+            def has_revision(self, revid):
+                return revid == "bloe"
+        self.assertEquals(
+            ["ha"],
+            list(rebase_todo(Repository(), {"bla": ("bloe", []), "ha": ("hee", [])})))
+
+
+class ReplaySnapshotTests(TestCaseWithTransport):
+
+    def test_single_revision(self):
+        wt = self.make_branch_and_tree(".")
+        self.build_tree(['afile'])
+        wt.add(["afile"])
+        wt.commit("bla", rev_id=b"oldcommit")
+        wt.branch.repository.lock_write()
+        CommitBuilderRevisionRewriter(wt.branch.repository)(b"oldcommit", b"newcommit", ())
+        wt.branch.repository.unlock()
+        oldrev = wt.branch.repository.get_revision(b"oldcommit")
+        newrev = wt.branch.repository.get_revision(b"newcommit")
+        self.assertEquals([], newrev.parent_ids)
+        self.assertEquals(b"newcommit", newrev.revision_id)
+        self.assertEquals(oldrev.committer, newrev.committer)
+        self.assertEquals(oldrev.timestamp, newrev.timestamp)
+        self.assertEquals(oldrev.timezone, newrev.timezone)
+        tree = wt.branch.repository.revision_tree(b"newcommit")
+        self.assertEquals(b"newcommit", tree.get_file_revision("afile"))
+
+    def test_two_revisions(self):
+        wt = self.make_branch_and_tree("old")
+        self.build_tree_contents([('old/afile', 'afilecontents'), ('old/notherfile', 'notherfilecontents')])
+        wt.add(["afile"], [b"somefileid"])
+        wt.commit("bla", rev_id=b"oldparent")
+        wt.add(["notherfile"])
+        wt.commit("bla", rev_id=b"oldcommit")
+        oldrepos = wt.branch.repository
+        wt = self.make_branch_and_tree("new")
+        self.build_tree_contents([('new/afile', 'afilecontents'), ('new/notherfile', 'notherfilecontents')])
+        wt.add(["afile"], [b"afileid"])
+        wt.commit("bla", rev_id=b"newparent")
+        wt.branch.repository.fetch(oldrepos)
+        wt.branch.repository.lock_write()
+        CommitBuilderRevisionRewriter(wt.branch.repository)(
+            b"oldcommit", b"newcommit", (b"newparent",))
+        wt.branch.repository.unlock()
+        oldrev = wt.branch.repository.get_revision(b"oldcommit")
+        newrev = wt.branch.repository.get_revision(b"newcommit")
+        self.assertEquals([b"newparent"], newrev.parent_ids)
+        self.assertEquals(b"newcommit", newrev.revision_id)
+        self.assertEquals(oldrev.committer, newrev.committer)
+        self.assertEquals(oldrev.timestamp, newrev.timestamp)
+        self.assertEquals(oldrev.timezone, newrev.timezone)
+        tree = wt.branch.repository.revision_tree(b"newcommit")
+        self.assertEquals(b"afileid", tree.path2id("afile"))
+        self.assertEquals(b"newcommit", tree.get_file_revision("notherfile"))
+
+    def test_two_revisions_no_renames(self):
+        wt = self.make_branch_and_tree("old")
+        self.build_tree(['old/afile', 'old/notherfile'])
+        wt.add(["afile"], [b"somefileid"])
+        wt.commit("bla", rev_id=b"oldparent")
+        wt.add(["notherfile"])
+        wt.commit("bla", rev_id=b"oldcommit")
+        oldrepos = wt.branch.repository
+        wt = self.make_branch_and_tree("new")
+        self.build_tree(['new/afile', 'new/notherfile'])
+        wt.add(["afile"], [b"afileid"])
+        wt.commit("bla", rev_id=b"newparent")
+        wt.branch.repository.fetch(oldrepos)
+        wt.branch.repository.lock_write()
+        CommitBuilderRevisionRewriter(wt.branch.repository)(
+            b"oldcommit", b"newcommit", (b"newparent",))
+        wt.branch.repository.unlock()
+
+    def test_multi_revisions(self):
+        wt = self.make_branch_and_tree("old")
+        self.build_tree_contents(
+            [('old/afile', 'afilecontent'), ('old/sfile', 'sfilecontent'), ('old/notherfile', 'notherfilecontent')])
+        wt.add(['sfile'])
+        wt.add(["afile"], [b"somefileid"])
+        wt.commit("bla", rev_id=b"oldgrandparent")
+        open("old/afile", "w").write("data")
+        wt.commit("bla", rev_id=b"oldparent")
+        wt.add(["notherfile"])
+        wt.commit("bla", rev_id=b"oldcommit")
+        oldrepos = wt.branch.repository
+        wt = self.make_branch_and_tree("new")
+        self.build_tree_contents(
+            [('new/afile', 'afilecontent'), ('new/sfile', 'sfilecontent'), ('new/notherfile', 'notherfilecontent')])
+        wt.add(['sfile'])
+        wt.add(["afile"], [b"afileid"])
+        wt.commit("bla", rev_id=b"newgrandparent")
+        open("new/afile", "w").write("data")
+        wt.commit("bla", rev_id=b"newparent")
+        wt.branch.repository.fetch(oldrepos)
+        wt.branch.repository.lock_write()
+        CommitBuilderRevisionRewriter(wt.branch.repository)(
+            b"oldcommit", b"newcommit", (b"newparent",))
+        wt.branch.repository.unlock()
+        oldrev = wt.branch.repository.get_revision(b"oldcommit")
+        newrev = wt.branch.repository.get_revision(b"newcommit")
+        self.assertEquals([b"newparent"], newrev.parent_ids)
+        self.assertEquals(b"newcommit", newrev.revision_id)
+        self.assertEquals(oldrev.committer, newrev.committer)
+        self.assertEquals(oldrev.timestamp, newrev.timestamp)
+        self.assertEquals(oldrev.timezone, newrev.timezone)
+        tree = wt.branch.repository.revision_tree(b"newcommit")
+        self.assertEquals(b"afileid", tree.path2id("afile"))
+        self.assertEquals(b"newcommit", tree.get_file_revision("notherfile"))
+        self.assertEquals(b"newgrandparent", tree.get_file_revision("sfile"))
+
+    def test_maps_ids(self):
+        wt = self.make_branch_and_tree("old")
+        wt.commit("base", rev_id=b"base")
+        self.build_tree(['old/afile'])
+        wt.add(["afile"], ids=[b"originalid"])
+        wt.commit("bla", rev_id=b"oldparent")
+        with open("old/afile", "w") as f:
+            f.write("bloe")
+        wt.commit("bla", rev_id=b"oldcommit")
+        oldrepos = wt.branch.repository
+        wt = self.make_branch_and_tree("new")
+        self.build_tree(['new/afile'])
+        wt.add(["afile"], ids=[b"newid"])
+        wt.commit("bla", rev_id=b"newparent")
+        wt.branch.repository.fetch(oldrepos)
+        wt.branch.repository.lock_write()
+        CommitBuilderRevisionRewriter(wt.branch.repository)(
+            b"oldcommit", b"newcommit", (b"newparent",))
+        wt.branch.repository.unlock()
+        oldrev = wt.branch.repository.get_revision(b"oldcommit")
+        newrev = wt.branch.repository.get_revision(b"newcommit")
+        self.assertEquals([b"newparent"], newrev.parent_ids)
+        self.assertEquals(b"newcommit", newrev.revision_id)
+        self.assertEquals(oldrev.committer, newrev.committer)
+        self.assertEquals(oldrev.timestamp, newrev.timestamp)
+        self.assertEquals(oldrev.timezone, newrev.timezone)
+        tree = wt.branch.repository.revision_tree(b"newcommit")
+        self.assertEquals(b"newid", tree.path2id("afile"))
+        self.assertEquals(b"newcommit", tree.get_file_revision("afile"))
+
+
+class TestReplayWorkingtree(TestCaseWithTransport):
+    def test_conflicts(self):
+        wt = self.make_branch_and_tree("old")
+        wt.commit("base", rev_id=b"base")
+        self.build_tree(['old/afile'])
+        wt.add(["afile"], ids=[b"originalid"])
+        wt.commit("bla", rev_id=b"oldparent")
+        with open("old/afile", "w") as f:
+            f.write("bloe")
+        wt.commit("bla", rev_id=b"oldcommit")
+        oldrepos = wt.branch.repository
+        wt = self.make_branch_and_tree("new")
+        self.build_tree(['new/afile'])
+        wt.add(["afile"], ids=[b"newid"])
+        wt.commit("bla", rev_id=b"newparent")
+        wt.branch.repository.fetch(oldrepos)
+        with wt.lock_write():
+            replayer = WorkingTreeRevisionRewriter(wt, RebaseState1(wt))
+            self.assertRaises(
+                ConflictsInTree,
+                replayer, b"oldcommit", b"newcommit",
+                [b"newparent"], )
+
+    def test_simple(self):
+        wt = self.make_branch_and_tree("old")
+        wt.commit("base", rev_id=b"base")
+        self.build_tree(['old/afile'])
+        wt.add(["afile"], ids=[b"originalid"])
+        wt.commit("bla", rev_id=b"oldparent")
+        with open("old/afile", "w") as f:
+            f.write("bloe")
+        wt.commit("bla", rev_id=b"oldcommit")
+        wt = wt.controldir.sprout("new").open_workingtree()
+        self.build_tree(['new/bfile'])
+        wt.add(["bfile"], ids=[b"newid"])
+        wt.commit("bla", rev_id=b"newparent")
+        replayer = WorkingTreeRevisionRewriter(wt, RebaseState1(wt))
+        replayer(b"oldcommit", b"newcommit", [b"newparent"])
+        oldrev = wt.branch.repository.get_revision(b"oldcommit")
+        newrev = wt.branch.repository.get_revision(b"newcommit")
+        self.assertEquals([b"newparent"], newrev.parent_ids)
+        self.assertEquals(b"newcommit", newrev.revision_id)
+        self.assertEquals(oldrev.timestamp, newrev.timestamp)
+        self.assertEquals(oldrev.timezone, newrev.timezone)
+
+    def test_multiple(self):
+        # rebase from
+        # base: []
+        # oldparent: [base]
+        # newparent: [base]
+        # oldcommit: [oldparent, ghost]
+        # create newcommit by rebasing oldcommit from oldparent to newparent,
+        # keeping the merge of ghost.
+        # Common base:
+        wt = self.make_branch_and_tree("old")
+        wt.commit("base", rev_id=b"base")
+        # oldparent:
+        self.build_tree_contents([('old/afile', 'base content')])
+        wt.add(["afile"], ids=[b"originalid"])
+        wt.commit("bla", rev_id=b"oldparent")
+        # oldcommit (the delta getting rebased)
+        #  - change the content of afile to be 'bloe'
+        with open("old/afile", "w") as f:
+            f.write("bloe")
+        wt.add_pending_merge(b"ghost")
+        wt.commit("bla", rev_id=b"oldcommit")
+        # newparent (the new base for the rebased commit)
+        new_tree = wt.controldir.sprout(
+            "new", revision_id=b'base').open_workingtree()
+        new_tree.branch.repository.fetch(wt.branch.repository)
+        wt = new_tree
+        self.build_tree_contents([('new/afile', 'base content')])
+        wt.add(["afile"], ids=[b"originalid"])
+        wt.commit("bla", rev_id=b"newparent")
+        # And do it!
+        wt.lock_write()
+        replayer = WorkingTreeRevisionRewriter(wt, RebaseState1(wt))
+        replayer(b"oldcommit", b"newcommit", (b"newparent", b"ghost"))
+        wt.unlock()
+        oldrev = wt.branch.repository.get_revision(b"oldcommit")
+        newrev = wt.branch.repository.get_revision(b"newcommit")
+        self.assertEquals([b"oldparent", b"ghost"], oldrev.parent_ids)
+        self.assertEquals([b"newparent", b"ghost"], newrev.parent_ids)
+        self.assertEquals(b"newcommit", newrev.revision_id)
+        self.assertEquals(oldrev.timestamp, newrev.timestamp)
+        self.assertEquals(oldrev.timezone, newrev.timezone)
+
+    def test_already_merged(self):
+        """We need to use a merge base that makes sense.
+
+        A
+        | \
+        B  D
+        | \|
+        C  E
+
+        Rebasing E on C should result in:
+
+        A -> B -> C -> D' -> E'
+
+        Ancestry:
+        A:
+        B: A
+        C: A, B
+        D: A
+        E: A, B, D
+        D': A, B, C
+        E': A, B, C, D'
+
+        """
+        oldwt = self.make_branch_and_tree("old")
+        self.build_tree(['old/afile'])
+        with open("old/afile", "w") as f:
+            f.write("A\n" * 10)
+        oldwt.add(["afile"])
+        oldwt.commit("base", rev_id=b"A")
+        newwt = oldwt.controldir.sprout("new").open_workingtree()
+        with open("old/afile", "w") as f:
+            f.write("A\n" * 10 + "B\n")
+        oldwt.commit("bla", rev_id=b"B")
+        with open("old/afile", "w") as f:
+            f.write("A\n" * 10 + "C\n")
+        oldwt.commit("bla", rev_id=b"C")
+        self.build_tree(['new/bfile'])
+        newwt.add(["bfile"])
+        with open("new/bfile", "w") as f:
+            f.write("D\n")
+        newwt.commit("bla", rev_id=b"D")
+        with open("new/afile", "w") as f:
+            f.write("E\n" + "A\n" * 10 + "B\n")
+        with open("new/bfile", "w") as f:
+            f.write("D\nE\n")
+        newwt.add_pending_merge(b"B")
+        newwt.commit("bla", rev_id=b"E")
+        newwt.branch.repository.fetch(oldwt.branch.repository)
+        newwt.lock_write()
+        replayer = WorkingTreeRevisionRewriter(newwt, RebaseState1(newwt))
+        replayer(b"D", b"D'", [b"C"])
+        newwt.unlock()
+        oldrev = newwt.branch.repository.get_revision(b"D")
+        newrev = newwt.branch.repository.get_revision(b"D'")
+        self.assertEquals([b"C"], newrev.parent_ids)
+        newwt.lock_write()
+        replayer = WorkingTreeRevisionRewriter(newwt, RebaseState1(newwt))
+        self.assertRaises(ConflictsInTree, replayer, b"E", b"E'", [b"D'"])
+        newwt.unlock()
+        with open("new/afile", 'r') as f:
+            self.assertEquals("E\n" + "A\n" * 10 + "C\n", f.read())
+        newwt.set_conflicts(ConflictList())
+        oldrev = newwt.branch.repository.get_revision(b"E")
+        replayer.commit_rebase(oldrev, b"E'")
+        newrev = newwt.branch.repository.get_revision(b"E'")
+        self.assertEquals([b"D'"], newrev.parent_ids)
+        self.assertThat(
+            newwt.branch,
+            RevisionHistoryMatches([b"A", b"B", b"C", b"D'", b"E'"]))
+
+
+class TestReplaySnapshotError(TestCase):
+
+    def test_create(self):
+        ReplaySnapshotError("message")

=== added file 'breezy/plugins/rewrite/tests/test_upgrade.py'
--- breezy/plugins/rewrite/tests/test_upgrade.py	1970-01-01 00:00:00 +0000
+++ breezy/plugins/rewrite/tests/test_upgrade.py	2020-01-11 23:46:53 +0000
@@ -0,0 +1,32 @@
+# Copyright (C) 2007-2009 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
+
+"""Mapping upgrade tests."""
+
+from ....tests import (
+    TestCase,
+    )
+
+from ..upgrade import (
+    UpgradeChangesContent,
+    )
+
+
+class TestUpgradeChangesContent(TestCase):
+
+    def test_init(self):
+        x = UpgradeChangesContent("revisionx")
+        self.assertEqual("revisionx", x.revid)

=== added file 'breezy/plugins/rewrite/upgrade.py'
--- breezy/plugins/rewrite/upgrade.py	1970-01-01 00:00:00 +0000
+++ breezy/plugins/rewrite/upgrade.py	2020-01-11 23:46:53 +0000
@@ -0,0 +1,190 @@
+# Copyright (C) 2006-2009 by Jelmer Vernooij
+#
+# 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 3 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
+
+
+"""Upgrading revisions made with older versions of the mapping."""
+
+from __future__ import absolute_import
+
+from ... import (
+    osutils,
+    trace,
+    ui,
+    )
+from ...errors import (
+    BzrError,
+    )
+from .rebase import (
+    generate_transpose_plan,
+    CommitBuilderRevisionRewriter,
+    rebase,
+    rebase_todo,
+    )
+
+
+class UpgradeChangesContent(BzrError):
+    """Inconsistency was found upgrading the mapping of a revision."""
+    _fmt = """Upgrade will change contents in revision %(revid)s. Use --allow-changes to override."""
+
+    def __init__(self, revid):
+        self.revid = revid
+
+
+def create_deterministic_revid(revid, new_parents):
+    """Create a new deterministic revision id with specified new parents.
+
+    Prevents suffix to be appended needlessly.
+
+    :param revid: Original revision id.
+    :return: New revision id
+    """
+    if "-rebase-" in revid:
+        revid = revid[0:revid.rfind("-rebase-")]
+    return revid + "-rebase-" + osutils.sha_string(":".join(new_parents))[:8]
+
+
+def upgrade_tags(tags, repository, generate_rebase_map, determine_new_revid,
+                 allow_changes=False, verbose=False, branch_renames=None,
+                 branch_ancestry=None):
+    """Upgrade a tags dictionary."""
+    renames = {}
+    if branch_renames is not None:
+        renames.update(branch_renames)
+    pb = ui.ui_factory.nested_progress_bar()
+    try:
+        tags_dict = tags.get_tag_dict()
+        for i, (name, revid) in enumerate(tags_dict.iteritems()):
+            pb.update("upgrading tags", i, len(tags_dict))
+            if revid not in renames:
+                try:
+                    repository.lock_read()
+                    revid_exists = repository.has_revision(revid)
+                finally:
+                    repository.unlock()
+                if revid_exists:
+                    renames.update(upgrade_repository(
+                        repository,
+                        generate_rebase_map, determine_new_revid,
+                        revision_id=revid, allow_changes=allow_changes,
+                        verbose=verbose))
+            if (revid in renames and
+                    (branch_ancestry is None or revid not in branch_ancestry)):
+                tags.set_tag(name, renames[revid])
+    finally:
+        pb.finished()
+
+
+def upgrade_branch(branch, generate_rebase_map, determine_new_revid,
+                   allow_changes=False, verbose=False):
+    """Upgrade a branch to the current mapping version.
+
+    :param branch: Branch to upgrade.
+    :param foreign_repository: Repository to fetch new revisions from
+    :param allow_changes: Allow changes in mappings.
+    :param verbose: Whether to print verbose list of rewrites
+    """
+    revid = branch.last_revision()
+    renames = upgrade_repository(
+        branch.repository, generate_rebase_map,
+        determine_new_revid, revision_id=revid,
+        allow_changes=allow_changes, verbose=verbose)
+    if revid in renames:
+        branch.generate_revision_history(renames[revid])
+    ancestry = branch.repository.get_ancestry(
+        branch.last_revision(), topo_sorted=False)
+    upgrade_tags(
+        branch.tags, branch.repository, generate_rebase_map,
+        determine_new_revid, allow_changes=allow_changes, verbose=verbose,
+        branch_renames=renames, branch_ancestry=ancestry)
+    return renames
+
+
+def check_revision_changed(oldrev, newrev):
+    """Check if two revisions are different. This is exactly the same
+    as Revision.equals() except that it does not check the revision_id."""
+    if (newrev.inventory_sha1 != oldrev.inventory_sha1 or
+            newrev.timestamp != oldrev.timestamp or
+            newrev.message != oldrev.message or
+            newrev.timezone != oldrev.timezone or
+            newrev.committer != oldrev.committer or
+            newrev.properties != oldrev.properties):
+        raise UpgradeChangesContent(oldrev.revision_id)
+
+
+def create_upgrade_plan(repository, generate_rebase_map, determine_new_revid,
+                        revision_id=None, allow_changes=False):
+    """Generate a rebase plan for upgrading revisions.
+
+    :param repository: Repository to do upgrade in
+    :param foreign_repository: Subversion repository to fetch new revisions
+        from.
+    :param new_mapping: New mapping to use.
+    :param revision_id: Revision to upgrade (None for all revisions in
+        repository.)
+    :param allow_changes: Whether an upgrade is allowed to change the contents
+        of revisions.
+    :return: Tuple with a rebase plan and map of renamed revisions.
+    """
+
+    graph = repository.get_graph()
+    upgrade_map = generate_rebase_map(revision_id)
+
+    if not allow_changes:
+        for oldrevid, newrevid in upgrade_map.iteritems():
+            oldrev = repository.get_revision(oldrevid)
+            newrev = repository.get_revision(newrevid)
+            check_revision_changed(oldrev, newrev)
+
+    if revision_id is None:
+        heads = repository.all_revision_ids()
+    else:
+        heads = [revision_id]
+
+    plan = generate_transpose_plan(
+        graph.iter_ancestry(heads), upgrade_map, graph, determine_new_revid)
+    def remove_parents(entry):
+        (oldrevid, (newrevid, parents)) = entry
+        return (oldrevid, newrevid)
+    upgrade_map.update(dict(map(remove_parents, plan.iteritems())))
+
+    return (plan, upgrade_map)
+
+
+def upgrade_repository(repository, generate_rebase_map,
+                       determine_new_revid, revision_id=None,
+                       allow_changes=False, verbose=False):
+    """Upgrade the revisions in repository until the specified stop revision.
+
+    :param repository: Repository in which to upgrade.
+    :param foreign_repository: Repository to fetch new revisions from.
+    :param new_mapping: New mapping.
+    :param revision_id: Revision id up until which to upgrade, or None for
+                        all revisions.
+    :param allow_changes: Allow changes to mappings.
+    :param verbose: Whether to print list of rewrites
+    :return: Dictionary of mapped revisions
+    """
+    # Find revisions that need to be upgraded, create
+    # dictionary with revision ids in key, new parents in value
+    with repository.lock_write():
+        (plan, revid_renames) = create_upgrade_plan(
+            repository, generate_rebase_map, determine_new_revid,
+            revision_id=revision_id, allow_changes=allow_changes)
+        if verbose:
+            for revid in rebase_todo(repository, plan):
+                trace.note("%s -> %s" % (revid, plan[revid][0]))
+        rebase(repository, plan, CommitBuilderRevisionRewriter(repository))
+        return revid_renames