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

[Jelmer Vernooij]

Support Git rename tracking.

Support Git rename tracking.

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

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

Merging failed
https://ci.breezy-vcs.org/job/brz/job/brz-land/729/

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

Voting criteria not met
https://ci.breezy-vcs.org/job/brz-3.1/job/brz-3.1-land/37/

[Jelmer Vernooij (jelmer)]

review: Approve

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

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

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

Merging failed
https://ci.breezy-vcs.org/job/brz-3.1/job/brz-3.1-land/92/

=== modified file 'breezy/builtins.py'
--- breezy/builtins.py	2020-04-02 01:37:43 +0000
+++ breezy/builtins.py	2020-06-16 23:49:21 +0000
@@ -4233,7 +4233,7 @@
 
         try:
             from . import tests
-        except ImportError:
+        except ImportError as e:
             raise errors.BzrCommandError("tests not available. Install the "
                                          "breezy tests to run the breezy testsuite.")
 
 
=== modified file 'breezy/commit.py'
--- breezy/commit.py	2019-09-21 17:08:09 +0000
+++ breezy/commit.py	2020-06-16 23:49:21 +0000
@@ -440,8 +440,8 @@
             # as updating its basis and unversioning paths that were missing.
             self.work_tree.unversion(self.deleted_paths)
             self._set_progress_stage("Updating the working tree")
-            self.work_tree.update_basis_by_delta(self.rev_id,
-                                                 self.builder.get_basis_delta())
+            self.work_tree.update_basis_by_delta(
+                self.rev_id, self.builder.get_basis_delta())
             self.reporter.completed(new_revno, self.rev_id)
             self._process_post_hooks(old_revno, new_revno)
             return self.rev_id
 
=== modified file 'breezy/git/commit.py'
--- breezy/git/commit.py	2020-01-30 15:48:47 +0000
+++ breezy/git/commit.py	2020-06-16 23:49:21 +0000
@@ -69,6 +69,7 @@
         self.store = self.repository._git.object_store
         self._blobs = {}
         self._inv_delta = []
+        self._deleted_paths = set()
         self._any_changes = False
         self._mapping = self.repository.get_mapping()
 
@@ -92,7 +93,7 @@
             self._any_changes = True
             if change.path[1] is None:
                 self._inv_delta.append((change.path[0], change.path[1], change.file_id, None))
-                self._blobs[change.path[0].encode("utf-8")] = None
+                self._deleted_paths.add(change.path[0].encode("utf-8"))
                 continue
             try:
                 entry_kls = entry_factory[change.kind[1]]
@@ -128,8 +129,9 @@
                 raise AssertionError("Unknown kind %r" % change.kind[1])
             mode = object_mode(change.kind[1], change.executable[1])
             self._inv_delta.append((change.path[0], change.path[1], change.file_id, entry))
-            encoded_new_path = change.path[1].encode("utf-8")
-            self._blobs[encoded_new_path] = (mode, sha)
+            if change.path[0] is not None:
+                self._deleted_paths.add(change.path[0].encode("utf-8"))
+            self._blobs[change.path[1].encode("utf-8")] = (mode, sha)
             if st is not None:
                 yield change.path[1], (entry.text_sha1, st)
         if not seen_root and len(self.parents) == 0:
@@ -146,6 +148,8 @@
         for entry in basis_tree._iter_tree_contents(include_trees=False):
             if entry.path in self._blobs:
                 continue
+            if entry.path in self._deleted_paths:
+                continue
             self._blobs[entry.path] = (entry.mode, entry.sha)
         self.new_inventory = None
 
@@ -155,8 +159,7 @@
 
     def finish_inventory(self):
         # eliminate blobs that were removed
-        self._blobs = {k: v for (k, v) in viewitems(
-            self._blobs) if v is not None}
+        self._blobs = {k: v for (k, v) in viewitems(self._blobs)}
 
     def _iterblobs(self):
         return ((path, sha, mode) for (path, (mode, sha))
 
=== modified file 'breezy/git/tests/test_workingtree.py'
--- breezy/git/tests/test_workingtree.py	2020-01-19 15:14:16 +0000
+++ breezy/git/tests/test_workingtree.py	2020-06-16 23:49:21 +0000
@@ -22,6 +22,8 @@
 import os
 import stat
 
+from dulwich import __version__ as dulwich_version
+from dulwich.diff_tree import RenameDetector
 from dulwich.index import IndexEntry
 from dulwich.objects import (
     S_IFGITLINK,
@@ -141,9 +143,15 @@
 
     def test_missing(self):
         delta = TreeDelta()
-        delta.removed.append(TreeChange(b'git:a', ('a', 'a'), False, (True, True), (b'TREE_ROOT', b'TREE_ROOT'), ('a', 'a'), ('file', None), (True, False)))
-        changes = [((b'a', b'a'), (stat.S_IFREG | 0o755, 0),
-                    (b'a' * 40, b'a' * 40))]
+        delta.removed.append(
+            TreeChange(
+                b'git:a', ('a', 'a'), False, (True, True),
+                (b'TREE_ROOT', b'TREE_ROOT'), ('a', 'a'), ('file', None),
+                (True, False)))
+        changes = [
+            ('remove',
+                (b'a', stat.S_IFREG | 0o755, b'a' * 40),
+                (b'a', 0, b'a' * 40))]
         self.assertEqual(
             delta,
             tree_delta_from_git_changes(changes, (default_mapping, default_mapping)))
@@ -158,7 +166,7 @@
 
     def expectDelta(self, expected_changes,
                     expected_extras=None, want_unversioned=False,
-                    tree_id=None):
+                    tree_id=None, rename_detector=None):
         if tree_id is None:
             try:
                 tree_id = self.store[self.wt.branch.repository._git.head()].tree
@@ -166,7 +174,8 @@
                 tree_id = None
         with self.wt.lock_read():
             changes, extras = changes_between_git_tree_and_working_copy(
-                self.store, tree_id, self.wt, want_unversioned=want_unversioned)
+                self.store, tree_id, self.wt, want_unversioned=want_unversioned,
+                rename_detector=rename_detector)
             self.assertEqual(expected_changes, list(changes))
         if expected_extras is None:
             expected_extras = set()
@@ -174,7 +183,7 @@
 
     def test_empty(self):
         self.expectDelta(
-            [((None, b''), (None, stat.S_IFDIR), (None, Tree().id))])
+            [('add', (None, None, None), (b'', stat.S_IFDIR, Tree().id))])
 
     def test_added_file(self):
         self.build_tree(['a'])
@@ -183,20 +192,74 @@
         t = Tree()
         t.add(b"a", stat.S_IFREG | 0o644, a.id)
         self.expectDelta(
-            [((None, b''), (None, stat.S_IFDIR), (None, t.id)),
-             ((None, b'a'), (None, stat.S_IFREG | 0o644), (None, a.id))])
+            [('add', (None, None, None), (b'', stat.S_IFDIR, t.id)),
+             ('add', (None, None, None), (b'a', stat.S_IFREG | 0o644, a.id))])
+
+    def test_renamed_file(self):
+        self.build_tree(['a'])
+        self.wt.add(['a'])
+        self.wt.rename_one('a', 'b')
+        a = Blob.from_string(b'contents of a\n')
+        self.store.add_object(a)
+        oldt = Tree()
+        oldt.add(b"a", stat.S_IFREG | 0o644, a.id)
+        self.store.add_object(oldt)
+        newt = Tree()
+        newt.add(b"b", stat.S_IFREG | 0o644, a.id)
+        self.store.add_object(newt)
+        self.expectDelta(
+            [('modify', (b'', stat.S_IFDIR, oldt.id), (b'', stat.S_IFDIR, newt.id)),
+             ('delete', (b'a', stat.S_IFREG | 0o644, a.id), (None, None, None)),
+             ('add', (None, None, None), (b'b', stat.S_IFREG | 0o644, a.id)),
+             ],
+            tree_id=oldt.id)
+        if dulwich_version >= (0, 19, 15):
+            self.expectDelta(
+                [('modify', (b'', stat.S_IFDIR, oldt.id), (b'', stat.S_IFDIR, newt.id)),
+                 ('rename', (b'a', stat.S_IFREG | 0o644, a.id), (b'b', stat.S_IFREG | 0o644, a.id))],
+                tree_id=oldt.id, rename_detector=RenameDetector(self.store))
+
+    def test_copied_file(self):
+        self.build_tree(['a'])
+        self.wt.add(['a'])
+        self.wt.copy_one('a', 'b')
+        a = Blob.from_string(b'contents of a\n')
+        self.store.add_object(a)
+        oldt = Tree()
+        oldt.add(b"a", stat.S_IFREG | 0o644, a.id)
+        self.store.add_object(oldt)
+        newt = Tree()
+        newt.add(b"a", stat.S_IFREG | 0o644, a.id)
+        newt.add(b"b", stat.S_IFREG | 0o644, a.id)
+        self.store.add_object(newt)
+        self.expectDelta(
+            [('modify', (b'', stat.S_IFDIR, oldt.id), (b'', stat.S_IFDIR, newt.id)),
+             ('add', (None, None, None), (b'b', stat.S_IFREG | 0o644, a.id)),
+             ],
+            tree_id=oldt.id)
+
+        if dulwich_version >= (0, 19, 15):
+            self.expectDelta(
+                [('modify', (b'', stat.S_IFDIR, oldt.id), (b'', stat.S_IFDIR, newt.id)),
+                 ('copy', (b'a', stat.S_IFREG | 0o644, a.id), (b'b', stat.S_IFREG | 0o644, a.id))],
+                tree_id=oldt.id, rename_detector=RenameDetector(self.store, find_copies_harder=True))
+            self.expectDelta(
+                [('modify', (b'', stat.S_IFDIR, oldt.id), (b'', stat.S_IFDIR, newt.id)),
+                 ('add', (None, None, None), (b'b', stat.S_IFREG | 0o644, a.id)),
+                 ],
+                tree_id=oldt.id, rename_detector=RenameDetector(self.store, find_copies_harder=False))
 
     def test_added_unknown_file(self):
         self.build_tree(['a'])
         t = Tree()
         self.expectDelta(
-            [((None, b''), (None, stat.S_IFDIR), (None, t.id))])
+            [('add', (None, None, None), (b'', stat.S_IFDIR, t.id))])
         a = Blob.from_string(b'contents of a\n')
         t = Tree()
         t.add(b"a", stat.S_IFREG | 0o644, a.id)
         self.expectDelta(
-            [((None, b''), (None, stat.S_IFDIR), (None, t.id)),
-             ((None, b'a'), (None, stat.S_IFREG | 0o644), (None, a.id))],
+            [('add', (None, None, None), (b'', stat.S_IFDIR, t.id)),
+             ('add', (None, None, None), (b'a', stat.S_IFREG | 0o644, a.id))],
             [b'a'],
             want_unversioned=True)
 
@@ -208,8 +271,8 @@
         t = Tree()
         t.add(b"a", 0, ZERO_SHA)
         self.expectDelta(
-            [((None, b''), (None, stat.S_IFDIR), (None, t.id)),
-             ((None, b'a'), (None, 0), (None, ZERO_SHA))],
+            [('add', (None, None, None), (b'', stat.S_IFDIR, t.id)),
+             ('add', (None, None, None), (b'a', 0, ZERO_SHA))],
             [])
 
     def test_missing_versioned_file(self):
@@ -223,8 +286,12 @@
         newt = Tree()
         newt.add(b"a", 0, ZERO_SHA)
         self.expectDelta(
-            [((b'', b''), (stat.S_IFDIR, stat.S_IFDIR), (oldt.id, newt.id)),
-             ((b'a', b'a'), (stat.S_IFREG | 0o644, 0), (a.id, ZERO_SHA))])
+            [('modify',
+                (b'', stat.S_IFDIR, oldt.id),
+                (b'', stat.S_IFDIR, newt.id)),
+             ('modify',
+                 (b'a', stat.S_IFREG | 0o644, a.id),
+                 (b'a', 0, ZERO_SHA))])
 
     def test_versioned_replace_by_dir(self):
         self.build_tree(['a'])
@@ -239,16 +306,20 @@
         newa = Tree()
         newt.add(b"a", stat.S_IFDIR, newa.id)
         self.expectDelta([
-            ((b'', b''),
-             (stat.S_IFDIR, stat.S_IFDIR),
-             (oldt.id, newt.id)),
-            ((b'a', b'a'), (stat.S_IFREG | 0o644, stat.S_IFDIR), (olda.id, newa.id))
+            ('modify',
+                (b'', stat.S_IFDIR, oldt.id),
+                (b'', stat.S_IFDIR, newt.id)),
+            ('modify',
+                (b'a', stat.S_IFREG | 0o644, olda.id),
+                (b'a', stat.S_IFDIR, newa.id))
             ], want_unversioned=False)
         self.expectDelta([
-            ((b'', b''),
-             (stat.S_IFDIR, stat.S_IFDIR),
-             (oldt.id, newt.id)),
-            ((b'a', b'a'), (stat.S_IFREG | 0o644, stat.S_IFDIR), (olda.id, newa.id))
+            ('modify',
+                (b'', stat.S_IFDIR, oldt.id),
+                (b'', stat.S_IFDIR, newt.id)),
+            ('modify',
+                (b'a', stat.S_IFREG | 0o644, olda.id),
+                (b'a', stat.S_IFDIR, newa.id)),
             ], want_unversioned=True)
 
     def test_extra(self):
@@ -257,10 +328,12 @@
         newt = Tree()
         newt.add(b"a", stat.S_IFREG | 0o644, newa.id)
         self.expectDelta([
-            ((None, b''),
-             (None, stat.S_IFDIR),
-             (None, newt.id)),
-            ((None, b'a'), (None, stat.S_IFREG | 0o644), (None, newa.id))
+            ('add',
+                (None, None, None),
+                (b'', stat.S_IFDIR, newt.id)),
+            ('add',
+                (None, None, None),
+                (b'a', stat.S_IFREG | 0o644, newa.id)),
             ], [b'a'], want_unversioned=True)
 
     def test_submodule(self):
 
=== modified file 'breezy/git/tree.py'
--- breezy/git/tree.py	2020-04-27 02:29:59 +0000
+++ breezy/git/tree.py	2020-06-16 23:49:21 +0000
@@ -28,7 +28,7 @@
     parse_submodules,
     ConfigFile as GitConfigFile,
     )
-from dulwich.diff_tree import tree_changes
+from dulwich.diff_tree import tree_changes, RenameDetector
 from dulwich.errors import NotTreeError
 from dulwich.index import (
     blob_from_path_and_stat,
@@ -737,7 +737,9 @@
         target_extras = set()
     ret = delta.TreeDelta()
     added = []
-    for (oldpath, newpath), (oldmode, newmode), (oldsha, newsha) in changes:
+    for (change_type, old, new) in changes:
+        (oldpath, oldmode, oldsha) = old
+        (newpath, newmode, newsha) = new
         if newpath == b'' and not include_root:
             continue
         if oldpath is not None:
@@ -809,13 +811,17 @@
             fileid, (oldpath_decoded, newpath_decoded), (oldsha != newsha),
             (oldversioned, newversioned),
             (oldparent, newparent), (oldname, newname),
-            (oldkind, newkind), (oldexe, newexe))
+            (oldkind, newkind), (oldexe, newexe),
+            copied=(change_type == 'copy'))
         if oldpath is None:
             added.append((newpath, newkind))
         elif newpath is None or newmode == 0:
             ret.removed.append(change)
         elif oldpath != newpath:
-            ret.renamed.append(change)
+            if change_type == 'copy':
+                ret.copied.append(change)
+            else:
+                ret.renamed.append(change)
         elif mode_kind(oldmode) != mode_kind(newmode):
             ret.kind_changed.append(change)
         elif oldsha != newsha or oldmode != newmode:
@@ -863,7 +869,9 @@
     """
     if target_extras is None:
         target_extras = set()
-    for (oldpath, newpath), (oldmode, newmode), (oldsha, newsha) in changes:
+    for (change_type, old, new) in changes:
+        (oldpath, oldmode, oldsha) = old
+        (newpath, newmode, newsha) = new
         if oldpath is not None:
             oldpath_decoded = oldpath.decode('utf-8')
         else:
@@ -934,7 +942,8 @@
             fileid, (oldpath_decoded, newpath_decoded), (oldsha != newsha),
             (oldversioned, newversioned),
             (oldparent, newparent), (oldname, newname),
-            (oldkind, newkind), (oldexe, newexe))
+            (oldkind, newkind), (oldexe, newexe),
+            copied=(change_type == 'copy'))
 
 
 class InterGitTrees(_mod_tree.InterTree):
@@ -997,7 +1006,9 @@
         paths = set(paths)
         ret = {}
         changes = self._iter_git_changes(specific_files=paths)[0]
-        for (oldpath, newpath), (oldmode, newmode), (oldsha, newsha) in changes:
+        for (change_type, old, new) in changes:
+            oldpath = old[0]
+            newpath = new[0]
             if oldpath in paths:
                 ret[oldpath] = newpath
         for path in paths:
@@ -1015,7 +1026,9 @@
         paths = set(paths)
         ret = {}
         changes = self._iter_git_changes(specific_files=paths)[0]
-        for (oldpath, newpath), (oldmode, newmode), (oldsha, newsha) in changes:
+        for (change_type, old, new) in changes:
+            oldpath = old[0]
+            newpath = new[0]
             if newpath in paths:
                 ret[newpath] = oldpath
         for path in paths:
@@ -1060,9 +1073,10 @@
                     self.target._repository._git.object_store])
         else:
             store = self.source._repository._git.object_store
-        return store.tree_changes(
-            self.source.tree, self.target.tree, want_unchanged=want_unchanged,
-            include_trees=True, change_type_same=True), set()
+        rename_detector = RenameDetector(store)
+        return tree_changes(
+            store, self.source.tree, self.target.tree, want_unchanged=want_unchanged,
+            include_trees=True, change_type_same=True, rename_detector=rename_detector), set()
 
 
 _mod_tree.InterTree.register_optimiser(InterGitRevisionTrees)
@@ -1601,6 +1615,12 @@
     def __init__(self, source, target):
         super(InterIndexGitTree, self).__init__(source, target)
         self._index = target.index
+        if self.source.store == self.target.store:
+            self.store = self.source.store
+        else:
+            self.store = OverlayObjectStore(
+                [self.source.store, self.target.store])
+        self.rename_detector = RenameDetector(self.store)
 
     @classmethod
     def is_compatible(cls, source, target):
@@ -1622,15 +1642,17 @@
             return changes_between_git_tree_and_working_copy(
                 self.source.store, self.source.tree,
                 self.target, want_unchanged=want_unchanged,
-                want_unversioned=want_unversioned)
+                want_unversioned=want_unversioned,
+                rename_detector=self.rename_detector)
 
 
 _mod_tree.InterTree.register_optimiser(InterIndexGitTree)
 
 
-def changes_between_git_tree_and_working_copy(store, from_tree_sha, target,
+def changes_between_git_tree_and_working_copy(source_store, from_tree_sha, target,
                                               want_unchanged=False,
-                                              want_unversioned=False):
+                                              want_unversioned=False,
+                                              rename_detector=None):
     """Determine the changes between a git tree and a working tree with index.
 
     """
@@ -1657,7 +1679,7 @@
                     blobs[path] = (index_entry.sha, index_entry.mode)
                 else:
                     dirified.append((path, Tree().id, stat.S_IFDIR))
-                    store.add_object(Tree())
+                    target.store.add_object(Tree())
             else:
                 mode = live_entry.mode
                 if not trust_executable:
@@ -1665,6 +1687,19 @@
                         mode |= 0o111
                     else:
                         mode &= ~0o111
+                if live_entry.sha != index_entry.sha:
+                    rp = path.decode('utf-8')
+                    if stat.S_ISREG(live_entry.mode):
+                        blob = Blob()
+                        with target.get_file(rp) as f:
+                            blob.data = f.read()
+                    elif stat.S_ISLNK(live_entry.mode):
+                        blob = Blob()
+                        blob.data = target.get_symlink_target(rp).encode(osutils._fs_enc)
+                    else:
+                        blob = None
+                    if blob is not None:
+                        target.store.add_object(blob)
                 blobs[path] = (live_entry.sha, cleanup_mode(live_entry.mode))
     if want_unversioned:
         for e in target.extras():
@@ -1681,12 +1716,14 @@
                     target.abspath(e).encode(osutils._fs_enc), st)
             else:
                 continue
-            store.add_object(blob)
+            target.store.add_object(blob)
             np = np.encode('utf-8')
             blobs[np] = (blob.id, cleanup_mode(st.st_mode))
             extras.add(np)
     to_tree_sha = commit_tree(
-        store, dirified + [(p, s, m) for (p, (s, m)) in blobs.items()])
-    return store.tree_changes(
-        from_tree_sha, to_tree_sha, include_trees=True,
+        target.store, dirified + [(p, s, m) for (p, (s, m)) in blobs.items()])
+    store = OverlayObjectStore([source_store, target.store])
+    return tree_changes(
+        store, from_tree_sha, to_tree_sha, include_trees=True,
+        rename_detector=rename_detector,
         want_unchanged=want_unchanged, change_type_same=True), extras
 
=== modified file 'breezy/tests/per_repository/test_commit_builder.py'
--- breezy/tests/per_repository/test_commit_builder.py	2019-06-29 13:16:26 +0000
+++ breezy/tests/per_repository/test_commit_builder.py	2020-06-16 23:49:21 +0000
@@ -498,11 +498,11 @@
                 builder.abort()
                 raise
             delta = builder.get_basis_delta()
-            delta_dict = dict((change[2], change) for change in delta)
+            delta_dict = dict((change[1], change) for change in delta)
             if tree.branch.repository._format.records_per_file_revision:
-                version_recorded = (file_id in delta_dict
-                                    and delta_dict[file_id][3] is not None
-                                    and delta_dict[file_id][3].revision == rev2)
+                version_recorded = (new_name in delta_dict
+                                    and delta_dict[new_name][3] is not None
+                                    and delta_dict[new_name][3].revision == rev2)
                 if records_version:
                     self.assertTrue(version_recorded)
                 else:
@@ -513,11 +513,24 @@
                 specific_files=[new_name]))[1]
 
             if delta_against_basis:
-                if tree.supports_rename_tracking() or name == new_name:
-                    expected_delta = (name, new_name, file_id, new_entry)
+                (delta_old_name, delta_new_name,
+                 delta_file_id, delta_entry) = delta_dict[new_name]
+                self.assertEqual(delta_new_name, new_name)
+                if tree.supports_rename_tracking():
+                    self.assertEqual(name, delta_old_name)
                 else:
-                    expected_delta = (None, new_name, file_id, new_entry)
-                self.assertEqual(expected_delta, delta_dict[file_id])
+                    self.assertIn(delta_old_name, (name, None))
+                if tree.supports_setting_file_ids():
+                    self.assertEqual(delta_file_id, file_id)
+                    self.assertEqual(delta_entry.file_id, file_id)
+                self.assertEqual(delta_entry.kind, new_entry.kind)
+                self.assertEqual(delta_entry.name, new_entry.name)
+                self.assertEqual(delta_entry.parent_id, new_entry.parent_id)
+                if delta_entry.kind == 'file':
+                    self.assertEqual(delta_entry.text_size, new_entry.text_size)
+                    self.assertEqual(delta_entry.text_sha1, new_entry.text_sha1)
+                elif delta_entry.kind == 'symlink':
+                    self.assertEqual(delta_entry.symlink_target, new_entry.symlink_target)
             else:
                 expected_delta = None
                 if tree.branch.repository._format.records_per_file_revision:
 
=== modified file 'doc/en/release-notes/brz-3.1.txt'
--- doc/en/release-notes/brz-3.1.txt	2020-06-16 01:38:06 +0000
+++ doc/en/release-notes/brz-3.1.txt	2020-06-16 23:49:21 +0000
@@ -32,6 +32,9 @@
  * Permission denied errors from GitLab during push are now properly
    recognized. (Jelmer Vernooij)
 
+ * Support rename and copy tracking when accessing Git
+   repositories. (Jelmer Vernooij, #1760740)
+
 Bug Fixes
 *********
 
@@ -41,7 +44,6 @@
  * Don't require ``ctypes.pythonapi`` to exist, as it's missing on newer
    versions of Pypy3. (Jelmer Vernooij)
 
-
 Documentation
 *************
 
@@ -73,9 +75,6 @@
  * Tests for most bzr-specific functionality has been moved to the
    ``breezy.bzr.tests`` module. (Jelmer Vernooij)
 
-..
-   vim: tw=74 ft=rst ff=unix
-
 brz 3.1.0
 #########