Merge lp:~jelmer/brz/bundle-quilt into lp:brz

[Jelmer Vernooij]

Add a quilt plugin that can do smart things with quilt patches.

Add a quilt plugin that can do smart things with quilt patches.

[Martin Packman (gz)]

Inclusion seems reasonable. Just see inline note about mix of license headers referencing Breezy or bzr-builddeb as the project.

review: Approve

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

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

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

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

=== modified file '.travis.yml'
--- .travis.yml	2019-05-28 23:22:25 +0000
+++ .travis.yml	2019-06-15 13:39:59 +0000
@@ -21,7 +21,7 @@
   - BRZ_PLUGIN_PATH=-site:-user python -Werror -Wignore::ImportWarning -Wignore::PendingDeprecationWarning -Wignore::DeprecationWarning -Wignore::ResourceWarning -Wignore::UserWarning ./brz selftest --parallel=fork $SELFTEST_OPTIONS
 
 install:
-  - sudo apt install python-all-dev python3-all-dev subunit
+  - sudo apt install python-all-dev python3-all-dev subunit quilt
   - travis_retry pip install -U setuptools
   - travis_retry pip install -U pip coverage codecov flake8 testtools paramiko fastimport configobj cython testscenarios six docutils python-subunit $TEST_REQUIRE sphinx sphinx_epytext launchpadlib patiencediff git+https://github.com/dulwich/dulwich
 

=== added directory 'breezy/plugins/quilt'
=== added file 'breezy/plugins/quilt/__init__.py'
--- breezy/plugins/quilt/__init__.py	1970-01-01 00:00:00 +0000
+++ breezy/plugins/quilt/__init__.py	2019-06-15 13:39:59 +0000
@@ -0,0 +1,172 @@
+#    __init__.py -- Quilt support for breezy
+#
+#    Breezy 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.
+#
+#    Breezy 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 Breezy; if not, write to the Free Software
+#    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+#
+
+from __future__ import absolute_import
+
+"""Quilt patch integration.
+
+This plugin adds support for three configuration options:
+
+ * quilt.commit_policy
+ * quilt.smart_merge
+ * quilt.tree_policy
+
+"""
+
+from ...errors import BzrError
+from ... import trace
+
+
+class QuiltUnapplyError(BzrError):
+
+    _fmt = ("Unable to unapply quilt patches for %(kind)r tree: %(msg)s")
+
+    def __init__(self, kind, msg):
+        BzrError.__init__(self)
+        self.kind = kind
+        if msg is not None and msg.count("\n") == 1:
+            msg = msg.strip()
+        self.msg = msg
+
+
+def pre_merge_quilt(merger):
+    if getattr(merger, "_no_quilt_unapplying", False):
+        return
+
+    config = merger.working_tree.get_config_stack()
+    merger.debuild_config = config
+    if not config.get('quilt.smart_merge'):
+        trace.mutter("skipping smart quilt merge, not enabled.")
+        return
+
+    if (not merger.other_tree.is_versioned(".pc") and
+            not merger.this_tree.is_versioned(".pc") and
+            not merger.working_tree.is_versioned(".pc")):
+        return
+
+    from .quilt import QuiltPatches, QuiltError
+    quilt = QuiltPatches(merger.working_tree)
+    from .merge import tree_unapply_patches
+    trace.note("Unapplying quilt patches to prevent spurious conflicts")
+    merger._quilt_tempdirs = []
+    merger._old_quilt_series = quilt.series()
+    if merger._old_quilt_series:
+        quilt.pop_all()
+    try:
+        merger.this_tree, this_dir = tree_unapply_patches(
+            merger.this_tree, merger.this_branch, force=True)
+    except QuiltError as e:
+        raise QuiltUnapplyError("this", e.stderr)
+    else:
+        if this_dir is not None:
+            merger._quilt_tempdirs.append(this_dir)
+    try:
+        merger.base_tree, base_dir = tree_unapply_patches(
+            merger.base_tree, merger.this_branch, force=True)
+    except QuiltError as e:
+        raise QuiltUnapplyError("base", e.stderr)
+    else:
+        if base_dir is not None:
+            merger._quilt_tempdirs.append(base_dir)
+    other_branch = getattr(merger, "other_branch", None)
+    if other_branch is None:
+        other_branch = merger.this_branch
+    try:
+        merger.other_tree, other_dir = tree_unapply_patches(
+            merger.other_tree, other_branch, force=True)
+    except QuiltError as e:
+        raise QuiltUnapplyError("other", e.stderr)
+    else:
+        if other_dir is not None:
+            merger._quilt_tempdirs.append(other_dir)
+
+
+def post_merge_quilt_cleanup(merger):
+    import shutil
+    for dir in getattr(merger, "_quilt_tempdirs", []):
+        shutil.rmtree(dir)
+    config = merger.working_tree.get_config_stack()
+    policy = config.get('quilt.tree_policy')
+    if policy is None:
+        return
+    from .merge import post_process_quilt_patches
+    post_process_quilt_patches(
+        merger.working_tree,
+        getattr(merger, "_old_quilt_series", []), policy)
+
+
+def start_commit_check_quilt(tree):
+    """start_commit hook which checks the state of quilt patches.
+    """
+    config = tree.get_config_stack()
+    policy = config.get('quilt.commit_policy')
+    from .merge import start_commit_quilt_patches
+    start_commit_quilt_patches(tree, policy)
+
+
+def post_build_tree_quilt(tree):
+    config = tree.get_config_stack()
+    policy = config.get('quilt.tree_policy')
+    if policy is None:
+        return
+    from .merge import post_process_quilt_patches
+    post_process_quilt_patches(tree, [], policy)
+
+
+from ...hooks import install_lazy_named_hook
+install_lazy_named_hook(
+    "breezy.merge", "Merger.hooks",
+    'pre_merge_quilt', pre_merge_quilt,
+    'Quilt patch (un)applying')
+install_lazy_named_hook(
+    "breezy.mutabletree", "MutableTree.hooks",
+    "start_commit", start_commit_check_quilt,
+    "Check for (un)applied quilt patches")
+install_lazy_named_hook(
+    "breezy.merge", "Merger.hooks",
+    'post_merge', post_merge_quilt_cleanup,
+    'Cleaning up quilt temporary directories')
+install_lazy_named_hook(
+    "breezy.mutabletree", "MutableTree.hooks",
+    'post_build_tree', post_build_tree_quilt,
+    'Applying quilt patches.')
+
+
+from ...config import option_registry, Option, bool_from_store
+option_registry.register(
+    Option('quilt.smart_merge', default=True, from_unicode=bool_from_store,
+           help="Unapply quilt patches before merging."))
+
+
+def policy_from_store(s):
+    if s not in ('applied', 'unapplied'):
+        raise ValueError('Invalid quilt.commit_policy: %s' % s)
+    return s
+
+option_registry.register(
+    Option('quilt.commit_policy', default=None, from_unicode=policy_from_store,
+           help="Whether to apply or unapply all patches in commits."))
+
+option_registry.register(
+    Option('quilt.tree_policy', default=None, from_unicode=policy_from_store,
+           help="Whether to apply or unapply all patches after checkout/update."))
+
+
+def load_tests(loader, basic_tests, pattern):
+    basic_tests.addTest(
+        loader.loadTestsFromModuleNames([__name__ + '.tests']))
+    return basic_tests

=== added file 'breezy/plugins/quilt/merge.py'
--- breezy/plugins/quilt/merge.py	1970-01-01 00:00:00 +0000
+++ breezy/plugins/quilt/merge.py	2019-06-15 13:39:59 +0000
@@ -0,0 +1,146 @@
+#    quilt.py -- Quilt patch handling
+#    Copyright (C) 2011 Canonical Ltd.
+#    Copyright (C) 2019 Jelmer Verooij <[e-mail]>
+#
+#    Breezy 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.
+#
+#    Breezy 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 Breezy; if not, write to the Free Software
+#    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+#
+
+"""Quilt patch handling."""
+
+from __future__ import absolute_import
+
+import shutil
+import tempfile
+
+from ...i18n import gettext
+from ...mutabletree import MutableTree
+from ...revisiontree import RevisionTree
+from ... import (
+    errors,
+    merge as _mod_merge,
+    trace,
+    )
+
+from .quilt import (
+    QuiltPatches,
+)
+
+
+class NoUnapplyingMerger(_mod_merge.Merge3Merger):
+
+    _no_quilt_unapplying = True
+
+
+def tree_unapply_patches(orig_tree, orig_branch=None, force=False):
+    """Return a tree with patches unapplied.
+
+    :param orig_tree: Tree from which to unapply quilt patches
+    :param orig_branch: Related branch (optional)
+    :return: Tuple with tree and temp path.
+        The tree is a tree with unapplied patches; either a checkout of
+        tree or tree itself if there were no patches
+    """
+    if orig_branch is None:
+        orig_branch = orig_tree.branch
+    quilt = QuiltPatches.find(orig_tree)
+    if quilt is None:
+        return orig_tree, None
+    applied_patches = quilt.applied()
+    if not applied_patches:
+        # No quilt patches
+        return orig_tree, None
+
+    target_dir = tempfile.mkdtemp()
+    try:
+        if isinstance(orig_tree, MutableTree):
+            tree = orig_branch.create_checkout(
+                target_dir, lightweight=True,
+                revision_id=orig_tree.last_revision(),
+                accelerator_tree=orig_tree)
+            merger = _mod_merge.Merger.from_uncommitted(tree, orig_tree)
+            merger.merge_type = NoUnapplyingMerger
+            merger.do_merge()
+        elif isinstance(orig_tree, RevisionTree):
+            tree = orig_branch.create_checkout(
+                target_dir, lightweight=True,
+                accelerator_tree=orig_tree, revision_id=orig_tree.get_revision_id())
+        else:
+            trace.mutter("Not sure how to create copy of %r", orig_tree)
+            shutil.rmtree(target_dir)
+            return orig_tree, None
+        trace.mutter("Applying quilt patches for %r in %s", orig_tree, target_dir)
+        quilt = QuiltPatches.find(tree)
+        if quilt is not None:
+            quilt.pop_all(force=force)
+        return tree, target_dir
+    except BaseException:
+        shutil.rmtree(target_dir)
+        raise
+
+
+def post_process_quilt_patches(tree, old_patches, policy):
+    """(Un)apply patches after a merge.
+
+    :param tree: Working tree to work in
+    :param old_patches: List of patches applied before the operation (usually a merge)
+    """
+    quilt = QuiltPatches.find(tree)
+    if quilt is None:
+        return
+    new_patches = quilt.series()
+    applied_patches = quilt.applied()
+    if policy == "applied":
+        to_apply = []
+        for p in new_patches:
+            if p in old_patches:
+                continue
+            if p not in applied_patches:
+                to_apply.append(p)
+        if to_apply == []:
+            return
+        trace.note(gettext("Applying %d quilt patches."), len(to_apply))
+        for p in to_apply:
+            quilt.push(p)
+    elif policy == "unapplied":
+        to_unapply = []
+        for p in new_patches:
+            if p in old_patches:
+                continue
+            if p in applied_patches:
+                to_unapply.append(p)
+        if to_unapply == []:
+            return
+        trace.note(gettext("Unapplying %d quilt patches."), len(to_unapply))
+        for p in to_unapply:
+            quilt.pop(p)
+
+
+def start_commit_quilt_patches(tree, policy):
+    quilt = QuiltPatches.find(tree)
+    if quilt is None:
+        return
+    applied_patches = quilt.applied()
+    unapplied_patches = quilt.unapplied()
+    if policy is None:
+        # No policy set - just warn about having both applied and unapplied
+        # patches.
+        if applied_patches and unapplied_patches:
+            trace.warning(
+                gettext("Committing with %d patches applied and %d patches unapplied."),
+                len(applied_patches), len(unapplied_patches))
+    elif policy == "applied":
+        quilt.push_all()
+    elif policy == "unapplied":
+        quilt.pop_all()

=== added file 'breezy/plugins/quilt/quilt.py'
--- breezy/plugins/quilt/quilt.py	1970-01-01 00:00:00 +0000
+++ breezy/plugins/quilt/quilt.py	2019-06-15 13:39:59 +0000
@@ -0,0 +1,91 @@
+#    quilt.py -- Quilt patch handling
+#    Copyright (C) 2019 Jelmer Vernooij <[e-mail]>
+#
+#    Breezy 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.
+#
+#    Breezy 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 Breezy; if not, write to the Free Software
+#    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+#
+
+"""Quilt patch handling."""
+
+from __future__ import absolute_import
+
+import os
+
+from ... import osutils
+from . import wrapper
+
+QuiltError = wrapper.QuiltError
+
+DEFAULT_PATCHES_DIR = 'patches'
+
+
+class QuiltPatches(object):
+    """Management object for a stack of quilt patches."""
+
+    def __init__(self, tree, patches_dir=None, series_file=None):
+        self.tree = tree
+        if patches_dir is None:
+            if tree.has_filename('.pc/.quilt_patches'):
+                patches_dir = tree.get_file_text('.pc/.quilt_patches').decode(
+                    osutils._fs_enc)
+            else:
+                patches_dir = DEFAULT_PATCHES_DIR
+        self.patches_dir = patches_dir
+        if series_file is None:
+            series_file = os.path.join(patches_dir, 'series')
+        self.series_file = series_file
+
+    @classmethod
+    def find(cls, tree):
+        if tree.has_filename('.pc/.quilt_patches'):
+            return cls(tree)
+        for name in ['patches', 'debian/patches']:
+            if tree.has_filename(name):
+                return cls(tree, name)
+        return None
+
+    def upgrade(self):
+        return wrapper.quilt_upgrade(self.tree.basedir)
+
+    def series(self):
+        return wrapper.quilt_series(self.tree, self.series_file)
+
+    def applied(self):
+        return wrapper.quilt_applied(self.tree)
+
+    def unapplied(self):
+        return wrapper.quilt_unapplied(
+            self.tree.basedir, self.patches_dir, self.series_file)
+
+    def pop_all(self, quiet=None, force=False, refresh=False):
+        return wrapper.quilt_pop_all(
+            self.tree.basedir, patches_dir=self.patches_dir,
+            series_file=self.series_file, quiet=quiet, force=force,
+            refresh=refresh)
+
+    def push_all(self, quiet=None, force=None, refresh=None):
+        return wrapper.quilt_push_all(
+            self.tree.basedir, patches_dir=self.patches_dir,
+            series_file=self.series_file, quiet=quiet, force=force,
+            refresh=refresh)
+
+    def push(self, patch, quiet=None):
+        return wrapper.quilt_push(
+            self.tree.basedir, patch, patches_dir=self.patches_dir,
+            series_file=self.series_file, quiet=quiet)
+
+    def pop(self, patch, quiet=None):
+        return wrapper.quilt_pop(
+            self.tree.basedir, patch, patches_dir=self.patches_dir,
+            series_file=self.series_file, quiet=quiet)

=== added directory 'breezy/plugins/quilt/tests'
=== added file 'breezy/plugins/quilt/tests/__init__.py'
--- breezy/plugins/quilt/tests/__init__.py	1970-01-01 00:00:00 +0000
+++ breezy/plugins/quilt/tests/__init__.py	2019-06-15 13:39:59 +0000
@@ -0,0 +1,39 @@
+#    __init__.py -- Testsuite for quilt
+#    Copyright (C) 2019 Jelmer Vernooij <[e-mail]>
+#
+#    Breezy 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.
+#
+#    Breezy 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 Breezy; if not, write to the Free Software
+#    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+#
+
+from __future__ import absolute_import
+
+from .... import tests
+
+from ....tests import (
+    TestUtil,
+    multiply_tests,
+    TestCaseWithTransport,
+    TestCaseInTempDir,
+    )
+
+
+def load_tests(loader, basic_tests, pattern):
+    testmod_names = [
+        'test_merge',
+        'test_wrapper',
+        ]
+    basic_tests.addTest(loader.loadTestsFromModuleNames(
+        ["%s.%s" % (__name__, i) for i in testmod_names]))
+
+    return basic_tests

=== added file 'breezy/plugins/quilt/tests/test_merge.py'
--- breezy/plugins/quilt/tests/test_merge.py	1970-01-01 00:00:00 +0000
+++ breezy/plugins/quilt/tests/test_merge.py	2019-06-15 13:39:59 +0000
@@ -0,0 +1,379 @@
+#    Copyright (C) 2011 Canonical Ltd
+#    Copyright (C) 2019 Jelmer Vernooij <[e-mail]>
+#
+#    Breezy 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.
+#
+#    Breezy 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 Breezy; if not, write to the Free Software
+#    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+#
+
+"""Tests for the merge_quilt code."""
+
+from __future__ import absolute_import
+
+import os
+import shutil
+
+from .... import (
+    config,
+    errors,
+    trace,
+    )
+from ....merge import Merger
+from ....mutabletree import MutableTree
+
+from .. import (
+    pre_merge_quilt,
+    start_commit_check_quilt,
+    post_build_tree_quilt,
+    post_merge_quilt_cleanup,
+    )
+from ..quilt import QuiltPatches
+from ..merge import tree_unapply_patches
+
+from .test_wrapper import quilt_feature
+
+from ....tests import (
+    TestCaseWithTransport,
+    TestSkipped,
+    )
+
+TRIVIAL_PATCH = """--- /dev/null	2012-01-02 01:09:10.986490031 +0100
++++ base/a	2012-01-02 20:03:59.710666215 +0100
+@@ -0,0 +1 @@
++a
+"""
+
+
+def quilt_push_all(tree):
+    QuiltPatches(tree, 'debian/patches').push_all()
+
+
+class TestTreeUnapplyPatches(TestCaseWithTransport):
+
+    _test_needs_features = [quilt_feature]
+
+    def test_no_patches(self):
+        tree = self.make_branch_and_tree('.')
+        new_tree, target_dir = tree_unapply_patches(tree)
+        self.assertIs(tree, new_tree)
+        self.assertIs(None, target_dir)
+
+    def test_unapply(self):
+        orig_tree = self.make_branch_and_tree('source')
+        self.build_tree(["source/debian/", "source/debian/patches/"])
+        self.build_tree_contents([
+            ("source/debian/patches/series", "patch1.diff\n"),
+            ("source/debian/patches/patch1.diff", TRIVIAL_PATCH)])
+        quilt_push_all(orig_tree)
+        orig_tree.smart_add([orig_tree.basedir])
+        tree, target_dir = tree_unapply_patches(orig_tree)
+        self.addCleanup(shutil.rmtree, target_dir)
+        self.assertPathExists("source/a")
+        self.assertNotEqual(tree.basedir, orig_tree.basedir)
+        self.assertPathDoesNotExist(tree.abspath("a"))
+        self.assertPathExists(tree.abspath("debian/patches/series"))
+
+    def test_unapply_nothing_applied(self):
+        orig_tree = self.make_branch_and_tree('source')
+        self.build_tree(["source/debian/", "source/debian/patches/"])
+        self.build_tree_contents([
+            ("source/debian/patches/series", "patch1.diff\n"),
+            ("source/debian/patches/patch1.diff", TRIVIAL_PATCH)])
+        orig_tree.smart_add([orig_tree.basedir])
+        tree, target_dir = tree_unapply_patches(orig_tree)
+        self.assertIs(tree, orig_tree)
+        self.assertIs(None, target_dir)
+
+
+class TestMergeHook(TestCaseWithTransport):
+
+    _test_needs_features = [quilt_feature]
+
+    def enable_hooks(self):
+        Merger.hooks.install_named_hook(
+            'pre_merge', pre_merge_quilt,
+            'Debian quilt patch (un)applying and ancestry fixing')
+        Merger.hooks.install_named_hook(
+            'post_merge', post_merge_quilt_cleanup,
+            'Cleaning up quilt temporary directories')
+        MutableTree.hooks.install_named_hook(
+            "post_build_tree", post_build_tree_quilt,
+            "Apply quilt trees.")
+
+    def test_diverged_patches(self):
+        self.enable_hooks()
+
+        tree_a = self.make_branch_and_tree('a')
+        self.build_tree(
+            ['a/debian/', 'a/debian/patches/', 'a/debian/source/', 'a/.pc/'])
+        self.build_tree_contents([
+            ('a/.pc/.quilt_patches', 'debian/patches'),
+            ('a/.pc/.version', '2'),
+            ('a/debian/source/format', '3.0 (quilt)'),
+            ('a/debian/patches/series', 'patch1\n'),
+            ('a/debian/patches/patch1', TRIVIAL_PATCH)])
+        tree_a.smart_add([tree_a.basedir])
+        tree_a.commit('initial')
+
+        tree_b = tree_a.controldir.sprout('b').open_workingtree()
+        self.build_tree_contents([
+            ('a/debian/patches/patch1',
+                "\n".join(TRIVIAL_PATCH.splitlines()[:-1] + ["+d\n"]))])
+        quilt_push_all(tree_a)
+        tree_a.smart_add([tree_a.basedir])
+        tree_a.commit('apply patches')
+        self.build_tree_contents([
+            ('b/debian/patches/patch1',
+                "\n".join(TRIVIAL_PATCH.splitlines()[:-1] + ["+c\n"]))])
+        quilt_push_all(tree_b)
+        tree_b.commit('apply patches')
+        conflicts = tree_a.merge_from_branch(tree_b.branch)
+        self.assertFileEqual("""\
+--- /dev/null\t2012-01-02 01:09:10.986490031 +0100
++++ base/a\t2012-01-02 20:03:59.710666215 +0100
+@@ -0,0 +1 @@
+<<<<<<< TREE
++d
+=======
++c
+>>>>>>> MERGE-SOURCE
+""", "a/debian/patches/patch1")
+        # "a" should be unapplied again
+        self.assertPathDoesNotExist("a/a")
+        self.assertEquals(1, conflicts)
+
+    def test_auto_apply_patches_after_checkout(self):
+        self.enable_hooks()
+
+        tree_a = self.make_branch_and_tree('a')
+
+        self.build_tree(['a/debian/', 'a/debian/patches/'])
+        self.build_tree_contents([
+            ('a/debian/patches/series', 'patch1\n'),
+            ('a/debian/patches/patch1', TRIVIAL_PATCH)])
+        tree_a.smart_add([tree_a.basedir])
+        tree_a.commit('initial')
+
+        config.ensure_config_dir_exists()
+        config.GlobalStack().set('quilt.tree_policy', 'applied')
+
+        tree_a.branch.create_checkout("b")
+        self.assertFileEqual("a\n", "b/a")
+
+    def test_auto_apply_patches_after_update_format_1(self):
+        self.enable_hooks()
+
+        tree_a = self.make_branch_and_tree('a')
+        tree_b = tree_a.branch.create_checkout("b")
+
+        self.build_tree(['a/debian/', 'a/debian/patches/', 'a/.pc/'])
+        self.build_tree_contents([
+            ('a/.pc/.quilt_patches', 'debian/patches'),
+            ('a/.pc/.version', '2'),
+            ('a/debian/patches/series', 'patch1\n'),
+            ('a/debian/patches/patch1', TRIVIAL_PATCH)])
+        tree_a.smart_add([tree_a.basedir])
+        tree_a.commit('initial')
+
+        self.build_tree(["b/.bzr-builddeb/", "b/debian/", "b/debian/source/"])
+        tree_b.get_config_stack().set('quilt.tree_policy', 'applied')
+        self.build_tree_contents([
+            ("b/debian/source/format", "1.0")])
+
+        tree_b.update()
+        self.assertFileEqual("a\n", "b/a")
+
+    def test_auto_apply_patches_after_update(self):
+        self.enable_hooks()
+
+        tree_a = self.make_branch_and_tree('a')
+        tree_b = tree_a.branch.create_checkout("b")
+
+        self.build_tree(['a/debian/', 'a/debian/patches/', 'a/debian/source/', 'a/.pc/'])
+        self.build_tree_contents([
+            ('a/.pc/.quilt_patches', 'debian/patches'),
+            ('a/.pc/.version', '2'),
+            ('a/debian/source/format', '3.0 (quilt)'),
+            ('a/debian/patches/series', 'patch1\n'),
+            ('a/debian/patches/patch1', TRIVIAL_PATCH)])
+        tree_a.smart_add([tree_a.basedir])
+        tree_a.commit('initial')
+
+        self.build_tree(["b/.bzr-builddeb/", "b/debian/", "b/debian/source/"])
+        tree_b.get_config_stack().set('quilt.tree_policy', 'applied')
+        self.build_tree_contents([
+            ('b/debian/source/format', '3.0 (quilt)'),
+            ])
+
+        tree_b.update()
+        self.assertFileEqual("a\n", "b/a")
+
+    def test_auto_unapply_patches_after_update(self):
+        self.enable_hooks()
+
+        tree_a = self.make_branch_and_tree('a')
+        tree_b = tree_a.branch.create_checkout("b")
+
+        self.build_tree(['a/debian/', 'a/debian/patches/', 'a/debian/source/', 'a/.pc/'])
+        self.build_tree_contents([
+            ('a/.pc/.quilt_patches', 'debian/patches'),
+            ('a/.pc/.version', '2'),
+            ('a/debian/source/format', '3.0 (quilt)'),
+            ('a/debian/patches/series', 'patch1\n'),
+            ('a/debian/patches/patch1', TRIVIAL_PATCH)])
+        tree_a.smart_add([tree_a.basedir])
+        tree_a.commit('initial')
+
+        self.build_tree(["b/.bzr-builddeb/"])
+        tree_b.get_config_stack().set('quilt.tree_policy', 'unapplied')
+
+        tree_b.update()
+        self.assertPathDoesNotExist("b/a")
+
+    def test_disabled_hook(self):
+        self.enable_hooks()
+
+        tree_a = self.make_branch_and_tree('a')
+        tree_a.get_config_stack().set('quilt.smart_merge', False)
+        self.build_tree(['a/debian/', 'a/debian/patches/', 'a/.pc/'])
+        self.build_tree_contents([
+            ('a/.pc/.quilt_patches', 'debian/patches'),
+            ('a/.pc/.version', '2'),
+            ('a/debian/patches/series', 'patch1\n'),
+            ('a/debian/patches/patch1', TRIVIAL_PATCH),
+            ("a/a", "")])
+        tree_a.smart_add([tree_a.basedir])
+        tree_a.commit('initial')
+
+        tree_b = tree_a.controldir.sprout('b').open_workingtree()
+        self.build_tree_contents([
+            ('a/debian/patches/patch1',
+                "\n".join(TRIVIAL_PATCH.splitlines()[:-1] + ["+d\n"]))])
+        quilt_push_all(tree_a)
+        tree_a.smart_add([tree_a.basedir])
+        tree_a.commit('apply patches')
+        self.assertFileEqual("d\n", "a/a")
+        self.build_tree_contents([
+            ('b/debian/patches/patch1',
+                "\n".join(TRIVIAL_PATCH.splitlines()[:-1] + ["+c\n"]))])
+        quilt_push_all(tree_b)
+        tree_b.commit('apply patches')
+        self.assertFileEqual("c\n", "b/a")
+        conflicts = tree_a.merge_from_branch(tree_b.branch)
+        self.assertFileEqual("""\
+--- /dev/null\t2012-01-02 01:09:10.986490031 +0100
++++ base/a\t2012-01-02 20:03:59.710666215 +0100
+@@ -0,0 +1 @@
+<<<<<<< TREE
++d
+=======
++c
+>>>>>>> MERGE-SOURCE
+""", "a/debian/patches/patch1")
+        self.assertFileEqual("""\
+<<<<<<< TREE
+d
+=======
+c
+>>>>>>> MERGE-SOURCE
+""", "a/a")
+        self.assertEquals(2, conflicts)
+
+
+
+class StartCommitMergeHookTests(TestCaseWithTransport):
+
+    _test_needs_features = [quilt_feature]
+
+    def enable_hooks(self):
+        MutableTree.hooks.install_named_hook(
+            'start_commit', start_commit_check_quilt,
+            'Check for (un)applied quilt patches')
+
+    def test_applied(self):
+        self.enable_hooks()
+        tree = self.make_branch_and_tree('source')
+        tree.get_config_stack().set('quilt.commit_policy', 'applied')
+        self.build_tree(['source/debian/', 'source/debian/patches/',
+                         'source/debian/source/'])
+        self.build_tree_contents([
+            ('source/debian/source/format', '3.0 (quilt)'),
+            ('source/debian/patches/series', 'patch1\n'),
+            ('source/debian/patches/patch1', TRIVIAL_PATCH)])
+        self.assertPathDoesNotExist("source/.pc/applied-patches")
+        self.assertPathDoesNotExist("source/a")
+        tree.smart_add([tree.basedir])
+        tree.commit("foo")
+        self.assertPathExists("source/.pc/applied-patches")
+        self.assertPathExists("source/a")
+
+    def test_unapplied(self):
+        self.enable_hooks()
+        tree = self.make_branch_and_tree('source')
+        tree.get_config_stack().set('quilt.commit_policy', 'unapplied')
+        self.build_tree(
+            ['source/debian/', 'source/debian/patches/',
+             'source/debian/source/'])
+        self.build_tree_contents([
+            ('source/debian/patches/series', 'patch1\n'),
+            ('source/debian/patches/patch1', TRIVIAL_PATCH),
+            ('source/debian/source/format', '3.0 (quilt)')])
+        quilt_push_all(tree)
+        self.assertPathExists("source/.pc/applied-patches")
+        self.assertPathExists("source/a")
+        tree.smart_add([tree.basedir])
+        tree.commit("foo")
+        self.assertPathDoesNotExist("source/.pc/applied-patches")
+        self.assertPathDoesNotExist("source/a")
+
+    def test_warning(self):
+        self.enable_hooks()
+        warnings = []
+
+        def warning(*args):
+            if len(args) > 1:
+                warnings.append(args[0] % args[1:])
+            else:
+                warnings.append(args[0])
+        _warning = trace.warning
+        trace.warning = warning
+        self.addCleanup(setattr, trace, "warning", _warning)
+        tree = self.make_branch_and_tree('source')
+        self.build_tree(['source/debian/', 'source/debian/patches/',
+                         'source/debian/source/'])
+        self.build_tree_contents([
+            ('source/debian/patches/series', 'patch1\n'),
+            ('source/debian/patches/patch1', TRIVIAL_PATCH)])
+        quilt_push_all(tree)
+        tree.smart_add([tree.basedir])
+        tree.commit("initial")
+        self.assertEquals([], warnings)
+        self.assertPathExists("source/.pc/applied-patches")
+        self.assertPathExists("source/a")
+        self.build_tree_contents([
+            ('source/debian/source/format', '3.0 (quilt)'),
+            ('source/debian/patches/series', 'patch1\npatch2\n'),
+            ('source/debian/patches/patch2',
+                """--- /dev/null	2012-01-02 01:09:10.986490031 +0100
++++ base/b	2012-01-02 20:03:59.710666215 +0100
+@@ -0,0 +1 @@
++a
+""")])
+        tree.smart_add([tree.basedir])
+        tree.commit("foo")
+        self.assertEquals(
+            ['Committing with 1 patches applied and 1 patches unapplied.'],
+            warnings)
+        self.assertPathExists("source/.pc/applied-patches")
+        self.assertPathExists("source/a")
+        self.assertPathDoesNotExist("source/b")

=== added file 'breezy/plugins/quilt/tests/test_wrapper.py'
--- breezy/plugins/quilt/tests/test_wrapper.py	1970-01-01 00:00:00 +0000
+++ breezy/plugins/quilt/tests/test_wrapper.py	2019-06-15 13:39:59 +0000
@@ -0,0 +1,99 @@
+#    Copyright (C) 2011 Canonical Ltd
+#    Copyright (C) 2019 Jelmer Vernooij <[e-mail]>
+#
+#    Breezy 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.
+#
+#    Breezy 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 Breezy; if not, write to the Free Software
+#    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+#
+
+"""Tests for the quilt code."""
+
+from __future__ import absolute_import
+
+import os
+
+from ..wrapper import (
+    quilt_pop_all,
+    quilt_applied,
+    quilt_unapplied,
+    quilt_push_all,
+    quilt_series,
+    )
+
+from ....tests import TestCaseWithTransport
+from ....tests.features import ExecutableFeature
+
+quilt_feature = ExecutableFeature('quilt')
+
+TRIVIAL_PATCH = """--- /dev/null	2012-01-02 01:09:10.986490031 +0100
++++ base/a	2012-01-02 20:03:59.710666215 +0100
+@@ -0,0 +1 @@
++a
+"""
+
+class QuiltTests(TestCaseWithTransport):
+
+    _test_needs_features = [quilt_feature]
+
+    def make_empty_quilt_dir(self, path):
+        source = self.make_branch_and_tree(path)
+        self.build_tree(
+            [os.path.join(path, n) for n in ['patches/']])
+        self.build_tree_contents([
+            (os.path.join(path, "patches/series"), "\n")])
+        source.add(["patches", "patches/series"])
+        return source
+
+    def test_series_all_empty(self):
+        source = self.make_empty_quilt_dir("source")
+        self.assertEquals([], quilt_series(source, 'patches/series'))
+
+    def test_series_all(self):
+        source = self.make_empty_quilt_dir("source")
+        self.build_tree_contents([
+            ("source/patches/series", "patch1.diff\n"),
+            ("source/patches/patch1.diff", TRIVIAL_PATCH)])
+        source.smart_add(["source"])
+        self.assertEquals(
+            ["patch1.diff"], quilt_series(source, 'patches/series'))
+
+    def test_push_all_empty(self):
+        self.make_empty_quilt_dir("source")
+        quilt_push_all("source", quiet=True)
+
+    def test_poph_all_empty(self):
+        self.make_empty_quilt_dir("source")
+        quilt_pop_all("source", quiet=True)
+
+    def test_applied_empty(self):
+        source = self.make_empty_quilt_dir("source")
+        self.build_tree_contents([
+            ("source/patches/series", "patch1.diff\n"),
+            ("source/patches/patch1.diff", "foob ar")])
+        self.assertEquals([], quilt_applied(source))
+
+    def test_unapplied(self):
+        self.make_empty_quilt_dir("source")
+        self.build_tree_contents([
+            ("source/patches/series", "patch1.diff\n"),
+            ("source/patches/patch1.diff", "foob ar")])
+        self.assertEquals(["patch1.diff"], quilt_unapplied("source"))
+
+    def test_unapplied_multi(self):
+        self.make_empty_quilt_dir("source")
+        self.build_tree_contents([
+            ("source/patches/series", "patch1.diff\npatch2.diff"),
+            ("source/patches/patch1.diff", "foob ar"),
+            ("source/patches/patch2.diff", "bazb ar")])
+        self.assertEquals(["patch1.diff", "patch2.diff"],
+                          quilt_unapplied("source", "patches"))

=== added file 'breezy/plugins/quilt/wrapper.py'
--- breezy/plugins/quilt/wrapper.py	1970-01-01 00:00:00 +0000
+++ breezy/plugins/quilt/wrapper.py	2019-06-15 13:39:59 +0000
@@ -0,0 +1,230 @@
+#    quilt.py -- Quilt patch handling
+#    Copyright (C) 2011 Canonical Ltd.
+#    Copyright (C) 2019 Jelmer Verooij <[e-mail]>
+#
+#    Breezy 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.
+#
+#    Breezy 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 Breezy; if not, write to the Free Software
+#    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+#
+
+"""Quilt patch handling."""
+
+from __future__ import absolute_import
+
+import errno
+import os
+import signal
+import subprocess
+from ... import (
+    errors,
+    osutils,
+    trace,
+    )
+
+
+class QuiltError(errors.BzrError):
+
+    _fmt = "An error (%(retcode)d) occurred running quilt: %(stderr)s%(extra)s"
+
+    def __init__(self, retcode, stdout, stderr):
+        self.retcode = retcode
+        self.stderr = stderr
+        if stdout is not None:
+            self.extra = "\n\n%s" % stdout
+        else:
+            self.extra = ""
+        self.stdout = stdout
+
+
+class QuiltNotInstalled(errors.BzrError):
+
+    _fmt = "Quilt is not installed."
+
+
+def run_quilt(
+        args, working_dir, series_file=None, patches_dir=None, quiet=None):
+    """Run quilt.
+
+    :param args: Arguments to quilt
+    :param working_dir: Working dir
+    :param series_file: Optional path to the series file
+    :param patches_dir: Optional path to the patches
+    :param quilt: Whether to be quiet (quilt stderr not to terminal)
+    :raise QuiltError: When running quilt fails
+    """
+    def subprocess_setup():
+        signal.signal(signal.SIGPIPE, signal.SIG_DFL)
+    env = {}
+    if patches_dir is not None:
+        env["QUILT_PATCHES"] = patches_dir
+    else:
+        env["QUILT_PATCHES"] = os.path.join(working_dir, "patches")
+    if series_file is not None:
+        env["QUILT_SERIES"] = series_file
+    else:
+        env["QUILT_SERIES"] = os.path.join(env["QUILT_PATCHES"], "series")
+    # Hide output if -q is in use.
+    if quiet is None:
+        quiet = trace.is_quiet()
+    if not quiet:
+        stderr = subprocess.STDOUT
+    else:
+        stderr = subprocess.PIPE
+    command = ["quilt"] + args
+    trace.mutter("running: %r", command)
+    if not os.path.isdir(working_dir):
+        raise AssertionError("%s is not a valid directory" % working_dir)
+    try:
+        proc = subprocess.Popen(
+            command, cwd=working_dir, env=env,
+            stdin=subprocess.PIPE, preexec_fn=subprocess_setup,
+            stdout=subprocess.PIPE, stderr=stderr)
+    except OSError as e:
+        if e.errno != errno.ENOENT:
+            raise
+        raise QuiltNotInstalled()
+    (stdout, stderr) = proc.communicate()
+    if proc.returncode not in (0, 2):
+        if stdout is not None:
+            stdout = stdout.decode()
+        if stderr is not None:
+            stderr = stderr.decode()
+        raise QuiltError(proc.returncode, stdout, stderr)
+    if stdout is None:
+        return ""
+    return stdout
+
+
+def quilt_pop_all(
+        working_dir, patches_dir=None, series_file=None, quiet=None,
+        force=False, refresh=False):
+    """Pop all patches.
+
+    :param working_dir: Directory to work in
+    :param patches_dir: Optional patches directory
+    :param series_file: Optional series file
+    """
+    args = ["pop", "-a"]
+    if force:
+        args.append("-f")
+    if refresh:
+        args.append("--refresh")
+    return run_quilt(
+        args, working_dir=working_dir,
+        patches_dir=patches_dir, series_file=series_file, quiet=quiet)
+
+
+def quilt_pop(working_dir, patch, patches_dir=None, series_file=None, quiet=None):
+    """Pop a patch.
+
+    :param working_dir: Directory to work in
+    :param patch: Patch to apply
+    :param patches_dir: Optional patches directory
+    :param series_file: Optional series file
+    """
+    return run_quilt(
+        ["pop", patch], working_dir=working_dir,
+        patches_dir=patches_dir, series_file=series_file, quiet=quiet)
+
+
+def quilt_push_all(working_dir, patches_dir=None, series_file=None, quiet=None,
+                   force=False, refresh=False):
+    """Push all patches.
+
+    :param working_dir: Directory to work in
+    :param patches_dir: Optional patches directory
+    :param series_file: Optional series file
+    """
+    args = ["push", "-a"]
+    if force:
+        args.append("-f")
+    if refresh:
+        args.append("--refresh")
+    return run_quilt(
+        args, working_dir=working_dir,
+        patches_dir=patches_dir, series_file=series_file, quiet=quiet)
+
+
+def quilt_push(working_dir, patch, patches_dir=None, series_file=None, quiet=None):
+    """Push a patch.
+
+    :param working_dir: Directory to work in
+    :param patch: Patch to push
+    :param patches_dir: Optional patches directory
+    :param series_file: Optional series file
+    """
+    return run_quilt(
+        ["push", patch], working_dir=working_dir,
+        patches_dir=patches_dir, series_file=series_file, quiet=quiet)
+
+
+def quilt_upgrade(working_dir):
+    return run_quilt(["upgrade"], working_dir=working_dir)
+
+
+def quilt_applied(tree):
+    """Find the list of applied quilt patches.
+
+    """
+    try:
+        return [patch.rstrip(b"\n").decode(osutils._fs_enc)
+                for patch in tree.get_file_lines(".pc/applied-patches")
+                if patch.strip() != b""]
+    except errors.NoSuchFile:
+        return []
+    except (IOError, OSError) as e:
+        if e.errno == errno.ENOENT:
+            # File has already been removed
+            return []
+        raise
+
+
+def quilt_unapplied(working_dir, patches_dir=None, series_file=None):
+    """Find the list of unapplied quilt patches.
+
+    :param working_dir: Directory to work in
+    :param patches_dir: Optional patches directory
+    :param series_file: Optional series file
+    """
+    try:
+        unapplied_patches = run_quilt(
+            ["unapplied"],
+            working_dir=working_dir, patches_dir=patches_dir,
+            series_file=series_file).splitlines()
+        patch_basenames = []
+        for patch in unapplied_patches:
+            patch = os.path.basename(patch)
+            patch_basenames.append(patch.decode(osutils._fs_enc))
+        return patch_basenames
+    except QuiltError as e:
+        if e.retcode == 1:
+            return []
+        raise
+
+
+def quilt_series(tree, series_file):
+    """Find the list of patches.
+
+    :param tree: Tree to read from
+    """
+    try:
+        return [patch.rstrip(b"\n").decode(osutils._fs_enc) for patch in
+                tree.get_file_lines(series_file)
+                if patch.strip() != b""]
+    except (IOError, OSError) as e:
+        if e.errno == errno.ENOENT:
+            # File has already been removed
+            return []
+        raise
+    except errors.NoSuchFile:
+        return []

=== modified file 'byov.conf'
--- byov.conf	2019-06-02 05:13:10 +0000
+++ byov.conf	2019-06-15 13:39:59 +0000
@@ -30,7 +30,7 @@
 # FIXME: Arguably this should be vm.build_deps=brz but it requires either an
 # available package or at least a debian/ dir ? -- vila 2018-02-23
 brz.build_deps = gcc, debhelper, python, python-all-dev, python3-all-dev, python-configobj, python3-configobj, python-docutils, python3-docutils, python-paramiko, python3-paramiko, python-subunit, python3-subunit, python-testtools, python3-testtools, subunit, python-pip, python3-pip, python-setuptools, python3-setuptools, python-flake8, python3-flake8, python-sphinx, python3-sphinx, python-launchpadlib, python3-launchpadlib
-subunit.build_deps = python-testscenarios, python3-testscenarios, python-testtools, python3-testtools
+subunit.build_deps = python-testscenarios, python3-testscenarios, python-testtools, python3-testtools, quilt
 vm.packages = {brz.build_deps}, {subunit.build_deps}, bzr, git, python-junitxml
 [brz-xenial]
 vm.release = xenial

=== modified file 'doc/en/release-notes/brz-3.1.txt'
--- doc/en/release-notes/brz-3.1.txt	2019-06-14 23:34:47 +0000
+++ doc/en/release-notes/brz-3.1.txt	2019-06-15 13:39:59 +0000
@@ -27,6 +27,9 @@
  * The 'patch' command is now bundled with brz.
    Imported from bzrtools by Aaron Bentley. (Jelmer Vernooij)
 
+ * The 'quilt' plugin, extracted from brz-debian, is now
+   bundled. (Jelmer Vernooij)
+
 Improvements
 ************