Merge lp:~jelmer/brz/workspace into lp:brz/3.2

[Jelmer Vernooij]

Import updates to workspace helper functions from lintian-brush.

Import updates to Workspace helper functions from lintian-brush.

[Jelmer Vernooij (jelmer)]

review: Approve

=== modified file 'breezy/tests/test_workspace.py'
--- breezy/tests/test_workspace.py	2020-08-06 21:52:51 +0000
+++ breezy/tests/test_workspace.py	2022-01-17 02:08:04 +0000
@@ -96,6 +96,29 @@
                 WorkspaceDirty, check_clean_tree,
                 tree)
 
+    def test_subpath(self):
+        tree = self.make_test_tree()
+        self.build_tree_contents([("debian/foo", "blah"), ("foo/",)])
+        tree.add("foo")
+        tree.commit("add foo")
+        with tree.lock_write():
+            check_clean_tree(tree, tree.basis_tree(), subpath="foo")
+            self.assertRaises(
+                WorkspaceDirty, check_clean_tree, tree, tree.basis_tree(), subpath=""
+            )
+
+    def test_subpath_changed(self):
+        tree = self.make_test_tree()
+        self.build_tree_contents([("foo/",)])
+        tree.add("foo")
+        tree.commit("add foo")
+        self.build_tree_contents([("debian/control", "blah")])
+        with tree.lock_write():
+            check_clean_tree(tree, tree.basis_tree(), subpath="foo")
+            self.assertRaises(
+                WorkspaceDirty, check_clean_tree, tree, tree.basis_tree(), subpath=""
+            )
+
 
 def vary_by_inotify():
     return [
 
=== modified file 'breezy/workspace.py'
--- breezy/workspace.py	2021-07-04 16:44:42 +0000
+++ breezy/workspace.py	2022-01-17 02:08:04 +0000
@@ -22,15 +22,18 @@
 
 from __future__ import absolute_import
 
+from contextlib import ExitStack
 import errno
 import os
 import shutil
-
-
-from .clean_tree import iter_deletables
-from .errors import BzrError, DependencyNotPresent
+from typing import Optional, List
+
+
+from .errors import BzrError, DependencyNotPresent, NoSuchFile
+from .osutils import is_inside
 from .trace import warning
 from .transform import revert
+from .tree import Tree
 from .workingtree import WorkingTree
 
 
@@ -42,49 +45,48 @@
 
 
 # TODO(jelmer): Move to .clean_tree?
-def reset_tree(local_tree, subpath=''):
+def reset_tree(
+    local_tree: WorkingTree,
+    basis_tree: Optional[Tree] = None,
+    subpath: str = "",
+    dirty_tracker: "DirtyTracker" = None,
+) -> None:
     """Reset a tree back to its basis tree.
 
     This will leave ignored and detritus files alone.
 
     Args:
       local_tree: tree to work on
+      dirty_tracker: Optional dirty tracker
       subpath: Subpath to operate on
     """
-    revert(local_tree, local_tree.branch.basis_tree(),
-           [subpath] if subpath else None)
-    deletables = list(iter_deletables(
-        local_tree, unknown=True, ignored=False, detritus=False))
+    if dirty_tracker and not dirty_tracker.is_dirty():
+        return
+    if basis_tree is None:
+        basis_tree = local_tree.branch.basis_tree()
+    revert(local_tree, basis_tree, [subpath] if subpath else None)
+    deletables: List[str] = []
+    # TODO(jelmer): Use basis tree
+    for p in local_tree.extras():
+        if not is_inside(subpath, p):
+            continue
+        if not local_tree.is_ignored(p):
+            deletables.append(local_tree.abspath(p))
     delete_items(deletables)
 
 
-# TODO(jelmer): Move to .clean_tree?
-def check_clean_tree(local_tree):
-    """Check that a tree is clean and has no pending changes or unknown files.
-
-    Args:
-      local_tree: The tree to check
-    Raises:
-      PendingChanges: When there are pending changes
-    """
-    # Just check there are no changes to begin with
-    if local_tree.has_changes():
-        raise WorkspaceDirty(local_tree.abspath('.'))
-    if list(local_tree.unknowns()):
-        raise WorkspaceDirty(local_tree.abspath('.'))
-
-
-def delete_items(deletables, dry_run=False):
+def delete_items(deletables, dry_run: bool = False):
     """Delete files in the deletables iterable"""
+
     def onerror(function, path, excinfo):
-        """Show warning for errors seen by rmtree.
-        """
+        """Show warning for errors seen by rmtree."""
         # Handle only permission error while removing files.
         # Other errors are re-raised.
         if function is not os.remove or excinfo[1].errno != errno.EACCES:
             raise
-        warning('unable to remove %s' % path)
-    for path, subp in deletables:
+        warning("unable to remove %s", path)
+
+    for path in deletables:
         if os.path.isdir(path):
             shutil.rmtree(path, onerror=onerror)
         else:
@@ -97,6 +99,55 @@
                 warning('unable to remove "%s": %s.', path, e.strerror)
 
 
+# TODO(jelmer): Move to .clean_tree?
+def check_clean_tree(
+    local_tree: WorkingTree, basis_tree: Optional[Tree] = None,
+    subpath: str = ""
+) -> None:
+    """Check that a tree is clean and has no pending changes or unknown files.
+
+    Args:
+      local_tree: The tree to check
+      basis_tree: Tree to check against
+      subpath: Subpath of the tree to check
+    Raises:
+      PendingChanges: When there are pending changes
+    """
+    with ExitStack() as es:
+        if basis_tree is None:
+            es.enter_context(local_tree.lock_read())
+            basis_tree = local_tree.basis_tree()
+        # Just check there are no changes to begin with
+        changes = local_tree.iter_changes(
+            basis_tree,
+            include_unchanged=False,
+            require_versioned=False,
+            want_unversioned=True,
+            specific_files=[subpath],
+        )
+
+        def relevant(p, t):
+            if not p:
+                return False
+            if not is_inside(subpath, p):
+                return False
+            if t.is_ignored(p):
+                return False
+            try:
+                if not t.has_versioned_directories() and t.kind(p) == "directory":
+                    return False
+            except NoSuchFile:
+                return True
+            return True
+
+        if any(
+            change
+            for change in changes
+            if relevant(change.path[0], basis_tree) or relevant(change.path[1], local_tree)
+        ):
+            raise WorkspaceDirty(local_tree.abspath(subpath))
+
+
 def get_dirty_tracker(local_tree, subpath='', use_inotify=None):
     """Create a dirty tracker object."""
     if use_inotify is True:
@@ -158,7 +209,7 @@
         """
         if self._dirty_tracker and not self._dirty_tracker.is_dirty():
             return
-        reset_tree(self.tree, self.subpath)
+        reset_tree(self.tree, subpath=self.subpath)
         if self._dirty_tracker is not None:
             self._dirty_tracker.mark_clean()