Merge lp:~jelmer/brz/is-versioned into lp:brz

[Jelmer Vernooij]

Add Tree.is_versioned().

Another step twoards removing file_ids from the public API.

[Martin Packman (gz)]

Looks sensible. Probably work an assert helper for all versioned or similar at some point?

review: Approve

=== modified file 'breezy/builtins.py'
--- breezy/builtins.py	2017-12-23 10:48:42 +0000
+++ breezy/builtins.py	2018-02-15 22:17:55 +0000
@@ -875,7 +875,7 @@
 
     @classmethod
     def add_file_with_parents(cls, wt, relpath):
-        if wt.path2id(relpath) is not None:
+        if wt.is_versioned(relpath):
             return
         cls.add_file_with_parents(wt, osutils.dirname(relpath))
         wt.add([relpath])
 
=== modified file 'breezy/bzr/bzrdir.py'
--- breezy/bzr/bzrdir.py	2017-11-23 20:02:55 +0000
+++ breezy/bzr/bzrdir.py	2018-02-15 22:17:55 +0000
@@ -451,7 +451,7 @@
                 hardlink=hardlink, from_branch=result_branch)
             wt.lock_write()
             try:
-                if wt.path2id('') is None:
+                if not wt.is_versioned(''):
                     try:
                         wt.set_root_id(self.open_workingtree.get_root_id())
                     except errors.NoWorkingTree:
 
=== modified file 'breezy/bzr/workingtree.py'
--- breezy/bzr/workingtree.py	2017-12-22 16:24:08 +0000
+++ breezy/bzr/workingtree.py	2018-02-15 22:17:55 +0000
@@ -943,7 +943,7 @@
                     self.add_parent_tree_id(parent_id)
             other_tree.controldir.retire_bzrdir()
 
-    def extract(self, file_id, format=None):
+    def extract(self, sub_path, file_id=None, format=None):
         """Extract a subtree from this tree.
 
         A new branch will be created, relative to the path for this tree.
@@ -958,7 +958,6 @@
 
         with self.lock_tree_write():
             self.flush()
-            sub_path = self.id2path(file_id)
             branch_transport = mkdirs(sub_path)
             if format is None:
                 format = self.controldir.cloning_metadir()
@@ -985,6 +984,8 @@
             # FIXME: Support nested trees
             my_inv = self.root_inventory
             child_inv = inventory.Inventory(root_id=None)
+            if file_id is None:
+                file_id = self.path2id(sub_path)
             new_root = my_inv[file_id]
             my_inv.remove_recursive_id(file_id)
             new_root.parent_id = None
 
=== modified file 'breezy/ignores.py'
--- breezy/ignores.py	2017-11-12 13:31:49 +0000
+++ breezy/ignores.py	2018-02-15 22:17:55 +0000
@@ -225,5 +225,5 @@
     finally:
         f.close()
 
-    if not tree.path2id(breezy.IGNORE_FILENAME):
+    if not tree.is_versioned(breezy.IGNORE_FILENAME):
         tree.add([breezy.IGNORE_FILENAME])
 
=== modified file 'breezy/plugins/fastimport/tests/test_generic_processor.py'
--- breezy/plugins/fastimport/tests/test_generic_processor.py	2018-01-22 02:23:22 +0000
+++ breezy/plugins/fastimport/tests/test_generic_processor.py	2018-02-15 22:17:55 +0000
@@ -173,14 +173,12 @@
                     str(expected_kind_changed_entry), kind_changed_files))
 
     def assertContent(self, branch, tree, path, content):
-        file_id = tree.path2id(path)
         with branch.lock_read():
-            self.assertEqual(tree.get_file_text(path, file_id), content)
+            self.assertEqual(tree.get_file_text(path), content)
 
     def assertSymlinkTarget(self, branch, tree, path, target):
-        file_id = tree.path2id(path)
         with branch.lock_read():
-            self.assertEqual(tree.get_symlink_target(path, file_id), target)
+            self.assertEqual(tree.get_symlink_target(path), target)
 
     def assertExecutable(self, branch, tree, path, executable):
         with branch.lock_read():
 
=== modified file 'breezy/rename_map.py'
--- breezy/rename_map.py	2017-11-12 17:53:35 +0000
+++ breezy/rename_map.py	2018-02-15 22:17:55 +0000
@@ -146,7 +146,7 @@
             while True:
                 child = path
                 path = osutils.dirname(path)
-                if self.tree.path2id(path) is not None:
+                if self.tree.is_versioned(path):
                     break
                 required_parents.setdefault(path, []).append(child)
         require_ids = {}
 
=== modified file 'breezy/tests/__init__.py'
--- breezy/tests/__init__.py	2017-11-12 13:53:51 +0000
+++ breezy/tests/__init__.py	2018-02-15 22:17:55 +0000
@@ -2865,7 +2865,7 @@
             for p in path:
                 self.assertInWorkingTree(p, tree=tree)
         else:
-            self.assertIsNot(tree.path2id(path), None,
+            self.assertTrue(tree.is_versioned(path),
                 path+' not in working tree.')
 
     def assertNotInWorkingTree(self, path, root_path='.', tree=None):
@@ -2876,7 +2876,7 @@
             for p in path:
                 self.assertNotInWorkingTree(p, tree=tree)
         else:
-            self.assertIs(tree.path2id(path), None, path+' in working tree.')
+            self.assertFalse(tree.is_versioned(path), path+' in working tree.')
 
 
 class TestCaseWithTransport(TestCaseInTempDir):
 
=== modified file 'breezy/tests/blackbox/test_mv.py'
--- breezy/tests/blackbox/test_mv.py	2017-11-12 13:53:51 +0000
+++ breezy/tests/blackbox/test_mv.py	2018-02-15 22:17:55 +0000
@@ -453,8 +453,8 @@
         self.assertEqual(out, '')
         self.assertEqual(err, 'a => b\nc => d\n')
         tree = workingtree.WorkingTree.open('tree')
-        self.assertIsNot(None, tree.path2id('b'))
-        self.assertIsNot(None, tree.path2id('d'))
+        self.assertTrue(tree.is_versioned('b'))
+        self.assertTrue(tree.is_versioned('d'))
 
     def test_mv_auto_one_path(self):
         self.make_abcd_tree()
@@ -462,8 +462,8 @@
         self.assertEqual(out, '')
         self.assertEqual(err, 'a => b\nc => d\n')
         tree = workingtree.WorkingTree.open('tree')
-        self.assertIsNot(None, tree.path2id('b'))
-        self.assertIsNot(None, tree.path2id('d'))
+        self.assertTrue(tree.is_versioned('b'))
+        self.assertTrue(tree.is_versioned('d'))
 
     def test_mv_auto_two_paths(self):
         self.make_abcd_tree()
@@ -477,8 +477,8 @@
         self.assertEqual(out, '')
         self.assertEqual(err, 'a => b\nc => d\n')
         tree = workingtree.WorkingTree.open('tree')
-        self.assertIsNot(None, tree.path2id('a'))
-        self.assertIsNot(None, tree.path2id('c'))
+        self.assertTrue(tree.is_versioned('a'))
+        self.assertTrue(tree.is_versioned('c'))
 
     def test_mv_no_auto_dry_run(self):
         self.make_abcd_tree()
 
=== modified file 'breezy/tests/blackbox/test_remove.py'
--- breezy/tests/blackbox/test_remove.py	2017-11-12 13:53:51 +0000
+++ breezy/tests/blackbox/test_remove.py	2018-02-15 22:17:55 +0000
@@ -106,7 +106,7 @@
         tree.commit('save foo and bar')
         os.unlink('bar')
         self.run_bzr(['rm'])
-        self.assertEqual(None, tree.path2id('bar'))
+        self.assertFalse(tree.is_versioned('bar'))
         # Running rm with a deleted file does not error.
         out, err = self.run_bzr(['rm'])
         self.assertEqual('', out)
 
=== modified file 'breezy/tests/blackbox/test_repair_workingtree.py'
--- breezy/tests/blackbox/test_repair_workingtree.py	2017-08-26 13:58:53 +0000
+++ breezy/tests/blackbox/test_repair_workingtree.py	2018-02-15 22:17:55 +0000
@@ -65,10 +65,10 @@
     def test_repair_forced(self):
         tree = self.make_initial_tree()
         tree.rename_one('dir', 'alt_dir')
-        self.assertIsNot(None, tree.path2id('alt_dir'))
+        self.assertTrue(tree.is_versioned('alt_dir'))
         self.run_bzr('repair-workingtree -d tree --force')
         # This requires the tree has reloaded the working state
-        self.assertIs(None, tree.path2id('alt_dir'))
+        self.assertFalse(tree.is_versioned('alt_dir'))
         self.assertPathExists('tree/alt_dir')
 
     def test_repair_corrupted_dirstate(self):
 
=== modified file 'breezy/tests/per_intertree/__init__.py'
--- breezy/tests/per_intertree/__init__.py	2017-11-12 13:53:51 +0000
+++ breezy/tests/per_intertree/__init__.py	2018-02-15 22:17:55 +0000
@@ -62,7 +62,7 @@
             raise tests.TestNotApplicable('cannot represent unversioned files')
 
     def not_applicable_if_missing_in(self, relpath, tree):
-        if not tree.path2id(relpath):
+        if not tree.is_versioned(relpath):
             # The locked test trees conversion could not preserve the missing
             # file status. This is normal (e.g. InterDirstateTree falls back
             # to InterTree if the basis is not a DirstateRevisionTree, and
 
=== modified file 'breezy/tests/per_tree/test_test_trees.py'
--- breezy/tests/per_tree/test_test_trees.py	2018-02-03 13:39:29 +0000
+++ breezy/tests/per_tree/test_test_trees.py	2018-02-15 22:17:55 +0000
@@ -49,6 +49,9 @@
         self.assertEqual(
             {'', 'a', 'b', 'b/c'},
             set(tree.all_versioned_paths()))
+        self.assertTrue(tree.is_versioned('a'))
+        self.assertTrue(tree.is_versioned('b'))
+        self.assertTrue(tree.is_versioned('b/c'))
         self.assertEqual(
             [(p, tree.path2id(p)) for p in ['', 'a', 'b', 'b/c']],
             [(path, node.file_id) for path, node in tree.iter_entries_by_dir()])
 
=== modified file 'breezy/tests/per_tree/test_tree.py'
--- breezy/tests/per_tree/test_tree.py	2018-01-12 08:52:43 +0000
+++ breezy/tests/per_tree/test_tree.py	2018-02-15 22:17:55 +0000
@@ -116,6 +116,10 @@
         if root_id is not None:
             self.assertIsInstance(root_id, str)
 
+    def test_is_versioned(self):
+        self.assertTrue(tree.is_versioned(''))
+        self.assertFalse(tree.is_versioned('blah'))
+
 
 class TestFileIds(TestCaseWithTree):
 
@@ -124,13 +128,10 @@
         work_tree = self.make_branch_and_tree('wt')
         tree = self.get_tree_no_parents_abc_content(work_tree)
         a_id = tree.path2id('a')
-        tree.lock_read()
-        try:
+        with tree.lock_read():
             self.assertEqual(u'a', tree.id2path(a_id))
             # other ids give an error- don't return None for this case
             self.assertRaises(errors.NoSuchId, tree.id2path, 'a')
-        finally:
-            tree.unlock()
 
     def test_all_file_ids(self):
         work_tree = self.make_branch_and_tree('wt')
 
=== modified file 'breezy/tests/per_workingtree/test_get_file_mtime.py'
--- breezy/tests/per_workingtree/test_get_file_mtime.py	2018-01-12 08:52:43 +0000
+++ breezy/tests/per_workingtree/test_get_file_mtime.py	2018-02-15 22:17:55 +0000
@@ -111,9 +111,6 @@
         one_id = tree.path2id('one')
 
         os.remove('tree/one')
-        tree.lock_read()
-        try:
+        with tree.lock_read():
             self.assertRaises(errors.NoSuchFile, tree.get_file_mtime, 'one')
-        finally:
-            tree.unlock()
 
 
=== modified file 'breezy/tests/per_workingtree/test_inv.py'
--- breezy/tests/per_workingtree/test_inv.py	2017-11-24 09:25:13 +0000
+++ breezy/tests/per_workingtree/test_inv.py	2018-02-15 22:17:55 +0000
@@ -68,7 +68,7 @@
         wt.add(['foo', 'foo/bar'], ['foo-id', 'bar-id'])
         wt.apply_inventory_delta([('foo', None, 'foo-id', None),
                                   ('foo/bar', None, 'bar-id', None)])
-        self.assertIs(None, wt.path2id('foo'))
+        self.assertFalse(wt.is_versioned('foo'))
 
     def test_rename_dir_with_children(self):
         wt = self.make_branch_and_tree('.')
 
=== modified file 'breezy/tests/per_workingtree/test_read_working_inventory.py'
--- breezy/tests/per_workingtree/test_read_working_inventory.py	2017-06-10 01:39:46 +0000
+++ breezy/tests/per_workingtree/test_read_working_inventory.py	2018-02-15 22:17:55 +0000
@@ -41,8 +41,7 @@
                 "non-inventory working trees")
         # prepare for a series of changes that will modify the
         # inventory
-        tree.lock_write()
-        try:
+        with tree.lock_write():
             tree.set_root_id('new-root')
             # having dirtied the inventory, we can now expect an
             # InventoryModified exception when doing a read_working_inventory()
@@ -53,5 +52,3 @@
                 pass
             else:
                 self.assertEqual('new-root', tree.path2id(''))
-        finally:
-            tree.unlock()
 
=== modified file 'breezy/tests/per_workingtree/test_smart_add.py'
--- breezy/tests/per_workingtree/test_smart_add.py	2018-02-03 13:39:29 +0000
+++ breezy/tests/per_workingtree/test_smart_add.py	2018-02-15 22:17:55 +0000
@@ -84,7 +84,7 @@
             wt.unlock()
         # and the disk state should be the same - reopen to check.
         wt = wt.controldir.open_workingtree()
-        self.assertEqual(wt.path2id('file'), None)
+        self.assertFalse(wt.is_versioned('file'))
 
     def test_add_dot_from_root(self):
         """Test adding . from the root of the tree."""
@@ -93,7 +93,7 @@
         wt = self.make_branch_and_tree('.')
         wt.smart_add((u".",))
         for path in paths:
-            self.assertNotEqual(wt.path2id(path), None)
+            self.assertTrue(wt.is_versioned(path))
 
     def test_skip_nested_trees(self):
         """Test smart-adding a nested tree ignors it and warns."""
@@ -104,7 +104,7 @@
             warnings.append(args[0] % args[1:])
         self.overrideAttr(trace, 'warning', warning)
         wt.smart_add((u".",))
-        self.assertIs(wt.path2id("nested"), None)
+        self.assertFalse(wt.is_versioned("nested"))
         self.assertEqual(
             ['skipping nested tree %r' % nested_wt.basedir], warnings)
 
@@ -115,7 +115,7 @@
         wt = self.make_branch_and_tree('.')
         wt.smart_add((u".",))
         for path in paths:
-            self.assertNotEqual(wt.path2id(path), None)
+            self.assertTrue(wt.is_versioned(path))
 
     def test_add_tree_from_above_tree(self):
         """Test adding a tree from above the tree."""
@@ -126,7 +126,7 @@
         wt = self.make_branch_and_tree('branch')
         wt.smart_add(("branch",))
         for path in paths:
-            self.assertNotEqual(wt.path2id(path), None)
+            self.assertTrue(wt.is_versioned(path))
 
     def test_add_above_tree_preserves_tree(self):
         """Test nested trees are not affect by an add above them."""
@@ -144,13 +144,13 @@
         child_tree = self.make_branch_and_tree('original/child')
         wt.smart_add((".",))
         for path in paths:
-            self.assertNotEqual((path, wt.path2id(path)),
-                                (path, None))
+            self.assertNotEqual((path, wt.is_versioned(path)),
+                                (path, False))
         for path in full_child_paths:
-            self.assertEqual((path, wt.path2id(path)),
-                             (path, None))
+            self.assertEqual((path, wt.is_versioned(path)),
+                             (path, False))
         for path in child_paths:
-            self.assertEqual(child_tree.path2id(path), None)
+            self.assertFalse(child_tree.is_versioned(path))
 
     def test_add_paths(self):
         """Test smart-adding a list of paths."""
@@ -159,7 +159,7 @@
         wt = self.make_branch_and_tree('.')
         wt.smart_add(paths)
         for path in paths:
-            self.assertNotEqual(wt.path2id(path), None)
+            self.assertTrue(wt.is_versioned(path))
 
     def test_add_ignored_nested_paths(self):
         """Test smart-adding a list of paths which includes ignored ones."""
@@ -170,8 +170,7 @@
         self.build_tree(tree_shape)
         wt.smart_add(add_paths)
         for path in expected_paths:
-            self.assertNotEqual(wt.path2id(path), None,
-                "No id added for %s" % path)
+            self.assertTrue(wt.is_versioned(path), "No id added for %s" % path)
 
     def test_add_non_existant(self):
         """Test smart-adding a file that does not exist."""
@@ -206,10 +205,10 @@
         wt.smart_add(['file1', 'file2', 'dir1', 'dir2'])
 
         for path in added_paths:
-            self.assertNotEqual(None, wt.path2id(path.rstrip('/')),
+            self.assertTrue(wt.is_versioned(path.rstrip('/')),
                     'Failed to add path: %s' % (path,))
         for path in not_added:
-            self.assertEqual(None, wt.path2id(path.rstrip('/')),
+            self.assertFalse(wt.is_versioned(path.rstrip('/')),
                     'Accidentally added path: %s' % (path,))
 
     def test_add_file_in_unknown_dir(self):
 
=== modified file 'breezy/tests/per_workingtree/test_symlinks.py'
--- breezy/tests/per_workingtree/test_symlinks.py	2017-11-12 20:07:32 +0000
+++ breezy/tests/per_workingtree/test_symlinks.py	2018-02-15 22:17:55 +0000
@@ -42,8 +42,8 @@
             ('tree/link@', 'target'),
             ])
         tree.smart_add(['tree/link'])
-        self.assertIsNot(None, tree.path2id('link'))
-        self.assertIs(None, tree.path2id('target'))
+        self.assertTrue(tree.is_versioned('link'))
+        self.assertFalse(tree.is_versioned('target'))
         self.assertEqual('symlink', tree.kind('link'))
 
     def test_smart_add_symlink_pointing_outside(self):
@@ -52,8 +52,8 @@
             ('tree/link@', '../../../../target'),
             ])
         tree.smart_add(['tree/link'])
-        self.assertIsNot(None, tree.path2id('link'))
-        self.assertIs(None, tree.path2id('target'))
+        self.assertTrue(tree.is_versioned('link'))
+        self.assertFalse(tree.is_versioned('target'))
         self.assertEqual('symlink', tree.kind('link'))
 
     def test_add_file_under_symlink(self):
@@ -70,10 +70,10 @@
             ([u'dir', u'dir/file'], {}))
         # should add the actual parent directory, not the apparent parent
         # (which is actually a symlink)
-        self.assertTrue(tree.path2id('dir/file'))
-        self.assertTrue(tree.path2id('dir'))
-        self.assertIs(None, tree.path2id('link'))
-        self.assertIs(None, tree.path2id('link/file'))
+        self.assertTrue(tree.is_versioned('dir/file'))
+        self.assertTrue(tree.is_versioned('dir'))
+        self.assertFalse(tree.is_versioned('link'))
+        self.assertFalse(tree.is_versioned('link/file'))
 
 
 class TestKindChanges(TestCaseWithWorkingTree):
 
=== modified file 'breezy/tests/per_workingtree/test_unversion.py'
--- breezy/tests/per_workingtree/test_unversion.py	2017-12-22 16:24:08 +0000
+++ breezy/tests/per_workingtree/test_unversion.py	2018-02-15 22:17:55 +0000
@@ -61,7 +61,9 @@
         c_id = tree.path2id('c')
         # within a lock unversion should take effect
         tree.lock_write()
+        self.assertTrue(tree.is_versioned('a'))
         tree.unversion(['a', 'b'])
+        self.assertFalse(tree.is_versioned('a'))
         self.assertFalse(tree.has_id(a_id))
         self.assertFalse(tree.has_id(b_id))
         self.assertTrue(tree.has_id(c_id))
@@ -111,8 +113,7 @@
         b_id = tree.path2id('a/b')
         c_id = tree.path2id('a/c')
         d_id = tree.path2id('d')
-        tree.lock_write()
-        try:
+        with tree.lock_write():
             tree.unversion(['a/b', 'a'])
             self.assertFalse(tree.has_id(a_id))
             self.assertFalse(tree.has_id(b_id))
@@ -123,8 +124,6 @@
             self.assertTrue(tree.has_filename('a/b'))
             self.assertTrue(tree.has_filename('a/c'))
             self.assertTrue(tree.has_filename('d'))
-        finally:
-            tree.unlock()
 
     def test_unversion_renamed(self):
         tree = self.make_branch_and_tree('a')
 
=== modified file 'breezy/tests/per_workingtree/test_workingtree.py'
--- breezy/tests/per_workingtree/test_workingtree.py	2018-01-15 06:07:39 +0000
+++ breezy/tests/per_workingtree/test_workingtree.py	2018-02-15 22:17:55 +0000
@@ -420,9 +420,9 @@
         self.assertFalse(cloned_transport.has('deleted'))
         self.assertTrue(cloned_transport.has('added'))
         self.assertFalse(cloned_transport.has('notadded'))
-        self.assertIsNot(None, cloned.path2id('added'))
-        self.assertEqual(None, cloned.path2id('deleted'))
-        self.assertEqual(None, cloned.path2id('notadded'))
+        self.assertTrue(cloned.is_versioned('added'))
+        self.assertFalse(cloned.is_versioned('deleted'))
+        self.assertFalse(cloned.is_versioned('notadded'))
 
     def test_basis_tree_returns_last_revision(self):
         wt = self.make_branch_and_tree('.')
@@ -687,15 +687,12 @@
         # merge_modified stores a map from file id to hash
         tree = self.make_branch_and_tree('tree')
         self.build_tree_contents([('tree/somefile', 'hello')])
-        tree.lock_write()
-        try:
+        with tree.lock_write():
             tree.add(['somefile'])
             d = {tree.path2id('somefile'): osutils.sha_string('hello')}
             tree.set_merge_modified(d)
             mm = tree.merge_modified()
             self.assertEqual(mm, d)
-        finally:
-            tree.unlock()
         mm = tree.merge_modified()
         self.assertEqual(mm, d)
 
@@ -971,7 +968,6 @@
                           'nonexistant')
         self.build_tree(['file'])
         tree.add('file')
-        file_id = tree.path2id('file')
         tree.commit('foo')
         tree.remove('file')
         self.assertRaises(errors.NoSuchFile, tree.get_file_sha1,
 
=== modified file 'breezy/tests/test_bundle.py'
--- breezy/tests/test_bundle.py	2017-11-24 09:25:13 +0000
+++ breezy/tests/test_bundle.py	2018-02-15 22:17:55 +0000
@@ -219,14 +219,14 @@
         self.assertEqual(btree.path2id("grandparent/parent"), "b")
         self.assertEqual(btree.path2id("grandparent/parent/file"), "c")
 
-        self.assertTrue(btree.path2id("grandparent2") is None)
-        self.assertTrue(btree.path2id("grandparent2/parent") is None)
-        self.assertTrue(btree.path2id("grandparent2/parent/file") is None)
+        self.assertIs(btree.path2id("grandparent2"), None)
+        self.assertIs(btree.path2id("grandparent2/parent"), None)
+        self.assertIs(btree.path2id("grandparent2/parent/file"), None)
 
         btree.note_rename("grandparent", "grandparent2")
-        self.assertTrue(btree.old_path("grandparent") is None)
-        self.assertTrue(btree.old_path("grandparent/parent") is None)
-        self.assertTrue(btree.old_path("grandparent/parent/file") is None)
+        self.assertIs(btree.old_path("grandparent"), None)
+        self.assertIs(btree.old_path("grandparent/parent"), None)
+        self.assertIs(btree.old_path("grandparent/parent/file"), None)
 
         self.assertEqual(btree.id2path("a"), "grandparent2")
         self.assertEqual(btree.id2path("b"), "grandparent2/parent")
@@ -351,7 +351,7 @@
         self.assertEqual(btree.get_file(btree.id2path("c")).read(), "Hello\n")
         btree.note_deletion("grandparent/parent/file")
         self.assertTrue(btree.id2path("c") is None)
-        self.assertTrue(btree.path2id("grandparent/parent/file") is None)
+        self.assertFalse(btree.is_versioned("grandparent/parent/file"))
 
     def sorted_ids(self, tree):
         ids = sorted(tree.all_file_ids())
 
=== modified file 'breezy/tests/test_commit.py'
--- breezy/tests/test_commit.py	2017-11-13 22:52:33 +0000
+++ breezy/tests/test_commit.py	2018-02-15 22:17:55 +0000
@@ -89,7 +89,6 @@
         with open('hello', 'w') as f: f.write('hello world')
         wt.add('hello')
         rev1 = wt.commit(message='add hello')
-        file_id = wt.path2id('hello')
 
         with open('hello', 'w') as f: f.write('version 2')
         rev2 = wt.commit(message='commit 2')
@@ -616,12 +615,9 @@
         tree.remove(['a', 'b'])
         tree.commit('removed a', specific_files='a')
         basis = tree.basis_tree()
-        tree.lock_read()
-        try:
-            self.assertIs(None, basis.path2id('a'))
-            self.assertFalse(basis.path2id('b') is None)
-        finally:
-            tree.unlock()
+        with tree.lock_read():
+            self.assertFalse(basis.is_versioned('a'))
+            self.assertTrue(basis.is_versioned('b'))
 
     def test_commit_saves_1ms_timestamp(self):
         """Passing in a timestamp is saved with 1ms resolution"""
 
=== modified file 'breezy/tests/test_inv.py'
--- breezy/tests/test_inv.py	2018-01-14 05:14:06 +0000
+++ breezy/tests/test_inv.py	2018-02-15 22:17:55 +0000
@@ -622,7 +622,7 @@
         inv.add(file1)
         delta = [(u'path', None, 'file-id', None)]
         res_inv = self.apply_delta(self, inv, delta, invalid_delta=False)
-        self.assertEqual(None, res_inv.path2id('path'))
+        self.assertFalse(res_inv.is_versioned('path'))
         self.assertRaises(errors.NoSuchId, res_inv.id2path, 'file-id')
 
     def test_rename_file(self):
@@ -632,7 +632,7 @@
         file2 = self.make_file_ie(name='path2', parent_id=inv.root.file_id)
         delta = [(u'path', 'path2', 'file-id', file2)]
         res_inv = self.apply_delta(self, inv, delta, invalid_delta=False)
-        self.assertEqual(None, res_inv.path2id('path'))
+        self.assertFalse(res_inv.is_versioned('path'))
         self.assertEqual('file-id', res_inv.path2id('path2'))
 
     def test_replaced_at_new_path(self):
@@ -676,7 +676,7 @@
         res_inv = self.apply_delta(self, inv, delta, invalid_delta=False)
         # The file should be accessible under the new path
         self.assertEqual('file-id-1', res_inv.path2id('dir2/name1'))
-        self.assertEqual(None, res_inv.path2id('dir2/name2'))
+        self.assertFalse(res_inv.is_versioned('dir2/name2'))
         self.assertEqual('file-id-2', res_inv.path2id('name2'))
 
     def test_is_root(self):
 
=== modified file 'breezy/tests/test_merge.py'
--- breezy/tests/test_merge.py	2017-11-24 09:25:13 +0000
+++ breezy/tests/test_merge.py	2018-02-15 22:17:55 +0000
@@ -2300,7 +2300,7 @@
         wt.set_parent_ids(['D-id'])
         wt.branch.set_last_revision_info(3, 'D-id')
         wt.revert()
-        self.assertIs(None, wt.path2id('foo'))
+        self.assertFalse(wt.is_versioned('foo'))
         conflicts = wt.merge_from_branch(wt.branch, to_revision='F-id')
         self.assertEqual(0, conflicts)
         self.assertEqual('foo-id', wt.path2id('foo'))
 
=== modified file 'breezy/tests/test_transform.py'
--- breezy/tests/test_transform.py	2017-11-12 20:07:32 +0000
+++ breezy/tests/test_transform.py	2018-02-15 22:17:55 +0000
@@ -920,7 +920,7 @@
         self.assertEqual([NonDirectoryParent('Created directory', 'parent.new',
         'parent-id')], cooked_conflicts)
         tt.apply()
-        self.assertEqual(None, self.wt.path2id('parent'))
+        self.assertFalse(self.wt.is_versioned('parent'))
         self.assertEqual('parent-id', self.wt.path2id('parent.new'))
 
     def test_resolve_conflicts_wrong_new_parent_kind(self):
@@ -936,7 +936,7 @@
         self.assertEqual({('non-directory parent', 'Created directory',
                          'new-3')}, raw_conflicts)
         tt.apply()
-        self.assertEqual(None, self.wt.path2id('parent'))
+        self.assertFalse(self.wt.is_versioned('parent'))
         self.assertEqual('parent-id', self.wt.path2id('parent.new'))
 
     def test_resolve_conflicts_wrong_parent_kind_unversioned(self):
@@ -950,8 +950,8 @@
         tt.create_file('contents', parent_id)
         resolve_conflicts(tt)
         tt.apply()
-        self.assertIs(None, self.wt.path2id('parent'))
-        self.assertIs(None, self.wt.path2id('parent.new'))
+        self.assertFalse(self.wt.is_versioned('parent'))
+        self.assertFalse(self.wt.is_versioned('parent.new'))
 
     def test_resolve_conflicts_missing_parent(self):
         wt = self.make_branch_and_tree('.')
@@ -2896,7 +2896,7 @@
         preview.unversion_file(preview.trans_id_file_id('deleted-id'))
         preview_tree = preview.get_preview_tree()
         self.assertEqual('unchanged-id', preview_tree.path2id('unchanged'))
-        self.assertIs(None, preview_tree.path2id('deleted'))
+        self.assertFalse(preview_tree.is_versioned('deleted'))
 
     def test_path2id_created(self):
         tree = self.make_branch_and_tree('tree')
@@ -2921,7 +2921,7 @@
         preview.adjust_path('child', new_parent,
                             preview.trans_id_file_id('child-id'))
         preview_tree = preview.get_preview_tree()
-        self.assertIs(None, preview_tree.path2id('old_parent/child'))
+        self.assertFalse(preview_tree.is_versioned('old_parent/child'))
         self.assertEqual('child-id', preview_tree.path2id('new_parent/child'))
 
     def test_path2id_renamed_parent(self):
@@ -2934,7 +2934,7 @@
         preview.adjust_path('new_name', preview.root,
                             preview.trans_id_file_id('parent-id'))
         preview_tree = preview.get_preview_tree()
-        self.assertIs(None, preview_tree.path2id('old_name/child'))
+        self.assertFalse(preview_tree.is_versioned('old_name/child'))
         self.assertEqual('child-id', preview_tree.path2id('new_name/child'))
 
     def assertMatchingIterEntries(self, tt, specific_file_ids=None):
 
=== modified file 'breezy/tests/test_uncommit.py'
--- breezy/tests/test_uncommit.py	2017-06-10 00:17:06 +0000
+++ breezy/tests/test_uncommit.py	2018-02-15 22:17:55 +0000
@@ -51,7 +51,7 @@
         # The file should not be removed
         self.assertPathExists('tree/two')
         # And it should still be listed as added
-        self.assertIsNot(None, tree.path2id('two'))
+        self.assertTrue(tree.is_versioned('two'))
 
     def test_uncommit_bound(self):
         tree, history = self.make_linear_tree()
 
=== modified file 'breezy/tests/test_upstream_import.py'
--- breezy/tests/test_upstream_import.py	2017-11-12 20:07:32 +0000
+++ breezy/tests/test_upstream_import.py	2018-02-15 22:17:55 +0000
@@ -233,8 +233,8 @@
         tree.lock_write()
         try:
             importer(tree, archive_file)
-            self.assertTrue(tree.path2id('README') is not None)
-            self.assertTrue(tree.path2id('FEEDME') is not None)
+            self.assertTrue(tree.is_versioned('README'))
+            self.assertTrue(tree.is_versioned('FEEDME'))
             self.assertTrue(os.path.isfile(tree.abspath('README')))
             self.assertEqual(tree.stored_kind('README'), 'file')
             self.assertEqual(tree.stored_kind('FEEDME'), 'file')
@@ -246,7 +246,7 @@
                 warnings.simplefilter('ignore')
                 archive_file = self.make_archive2(builder, subdir)
                 importer(tree, archive_file)
-            self.assertTrue(tree.path2id('README') is not None)
+            self.assertTrue(tree.is_versioned('README'))
             # Ensure the second version of the file is used.
             self.assertEqual(tree.get_file_text('README'), 'Wow?')
             self.assertTrue(not os.path.exists(tree.abspath('FEEDME')))
@@ -258,13 +258,13 @@
         tar_file = self.make_messed_tar()
         tree = BzrDir.create_standalone_workingtree('tree')
         import_tar(tree, tar_file)
-        self.assertTrue(tree.path2id('project-0.1/README') is not None)
+        self.assertTrue(tree.is_versioned('project-0.1/README'))
 
     def test_untar_gzip(self):
         tar_file = self.make_tar(mode='w:gz')
         tree = BzrDir.create_standalone_workingtree('tree')
         import_tar(tree, tar_file)
-        self.assertTrue(tree.path2id('README') is not None)
+        self.assertTrue(tree.is_versioned('README'))
 
     def test_no_crash_with_bzrdir(self):
         tar_file = self.make_tar_with_bzrdir()
 
=== modified file 'breezy/tests/test_workingtree_4.py'
--- breezy/tests/test_workingtree_4.py	2017-11-19 18:35:20 +0000
+++ breezy/tests/test_workingtree_4.py	2018-02-15 22:17:55 +0000
@@ -303,7 +303,7 @@
         state.update_basis_by_delta = log_update_basis_by_delta
         basis = tree.basis_tree()
         self.assertEqual('a-id', basis.path2id('a'))
-        self.assertEqual(None, basis.path2id('b'))
+        self.assertFalse(basis.is_versioned('b'))
         def fail_set_parent_trees(trees, ghosts):
             raise AssertionError('dirstate.set_parent_trees() was called')
         state.set_parent_trees = fail_set_parent_trees
@@ -341,7 +341,7 @@
         # Re-open with the new reference
         wt = wt.controldir.open_workingtree()
         wt.set_parent_trees([('C', b_c.repository.revision_tree('C'))])
-        self.assertEqual(None, wt.basis_tree().path2id('b'))
+        self.assertFalse(wt.basis_tree().is_versioned('b'))
 
     def test_new_dirstate_on_new_lock(self):
         # until we have detection for when a dirstate can be reused, we
 
=== modified file 'breezy/tree.py'
--- breezy/tree.py	2018-01-12 08:52:43 +0000
+++ breezy/tree.py	2018-02-15 22:17:55 +0000
@@ -533,6 +533,14 @@
         """Return the id for path in this tree."""
         raise NotImplementedError(self.path2id)
 
+    def is_versioned(self, path):
+        """Check whether path is versioned.
+
+        :param path: Path to check
+        :return: boolean
+        """
+        return (self.path2id(path) is not None)
+
     def paths2ids(self, paths, trees=[], require_versioned=True):
         """Return all the ids that can be reached by walking from paths.
 
 
=== modified file 'breezy/upstream_import.py'
--- breezy/upstream_import.py	2017-09-26 00:55:04 +0000
+++ breezy/upstream_import.py	2018-02-15 22:17:55 +0000
@@ -182,7 +182,7 @@
 
 
 def do_directory(tt, trans_id, tree, relative_path, path):
-    if isdir(path) and tree.path2id(relative_path) is not None:
+    if isdir(path) and tree.is_versioned(relative_path):
         tt.cancel_deletion(trans_id)
     else:
         tt.create_directory(trans_id)
 
=== modified file 'breezy/workingtree.py'
--- breezy/workingtree.py	2018-01-15 06:07:39 +0000
+++ breezy/workingtree.py	2018-02-15 22:17:55 +0000
@@ -813,7 +813,7 @@
         # checkout in a subdirectory.  This can be avoided by not adding
         # it.  mbp 20070306
 
-    def extract(self, file_id, format=None):
+    def extract(self, path, file_id=None, format=None):
         """Extract a subtree from this tree.
 
         A new branch will be created, relative to the path for this tree.