feat: Add tree::Editor::get() to get entries directly from the editor.

This is useful if in the middle of an edit you'd like to lookup what's there
to choose a non-conflicting name, for example.

Author: Byron

gix-object/src/tree/editor.rs

@@ -46,15 +46,16 @@ impl<'a> Editor<'a> {
             find,
             object_hash,
             trees: HashMap::from_iter(Some((empty_path(), root))),
-            path_buf: Vec::with_capacity(256).into(),
+            path_buf: BString::from(Vec::with_capacity(256)).into(),
             tree_buf: Vec::with_capacity(512),
         }
     }
 }
 
 /// Operations
 impl Editor<'_> {
-    /// Write the entire in-memory state of all changed trees (and only changed trees) to `out`.
+    /// Write the entire in-memory state of all changed trees (and only changed trees) to `out`, and remove
+    /// written portions from our state except for the root tree, which affects [`get()`](Editor::get()).
     /// Note that the returned object id *can* be the empty tree if everything was removed or if nothing
     /// was added to the tree.
     ///
@@ -72,7 +73,7 @@ impl Editor<'_> {
     /// It is absolutely and intentionally possible to write out invalid trees with this method.
     /// Higher layers are expected to perform detailed validation.
     pub fn write<E>(&mut self, out: impl FnMut(&Tree) -> Result<ObjectId, E>) -> Result<ObjectId, E> {
-        self.path_buf.clear();
+        self.path_buf.borrow_mut().clear();
         self.write_at_pathbuf(out, WriteMode::Normal)
     }
 
@@ -85,10 +86,24 @@ impl Editor<'_> {
         I: IntoIterator<Item = C>,
         C: AsRef<BStr>,
     {
-        self.path_buf.clear();
+        self.path_buf.borrow_mut().clear();
         self.upsert_or_remove_at_pathbuf(rela_path, None)
     }
 
+    /// Obtain the entry at `rela_path` or return `None` if none was found, or the tree wasn't yet written
+    /// to that point.
+    /// Note that after [writing](Self::write) only the root path remains, all other intermediate trees are removed.
+    /// The entry can be anything that can be stored in a tree, but may have a null-id if it's a newly
+    /// inserted tree. Also, ids of trees might not be accurate as they may have been changed in memory.
+    pub fn get<I, C>(&self, rela_path: I) -> Option<&tree::Entry>
+    where
+        I: IntoIterator<Item = C>,
+        C: AsRef<BStr>,
+    {
+        self.path_buf.borrow_mut().clear();
+        self.get_inner(rela_path)
+    }
+
     /// Insert a new entry of `kind` with `id` at `rela_path`, an iterator over each path component in the tree,
     /// like `a/b/c`. Names are matched case-sensitively.
     ///
@@ -108,10 +123,41 @@ impl Editor<'_> {
         I: IntoIterator<Item = C>,
         C: AsRef<BStr>,
     {
-        self.path_buf.clear();
+        self.path_buf.borrow_mut().clear();
         self.upsert_or_remove_at_pathbuf(rela_path, Some((kind, id, UpsertMode::Normal)))
     }
 
+    fn get_inner<I, C>(&self, rela_path: I) -> Option<&tree::Entry>
+    where
+        I: IntoIterator<Item = C>,
+        C: AsRef<BStr>,
+    {
+        let mut path_buf = self.path_buf.borrow_mut();
+        let mut cursor = self.trees.get(path_buf.as_bstr()).expect("root is always present");
+        let mut rela_path = rela_path.into_iter().peekable();
+        while let Some(name) = rela_path.next() {
+            let name = name.as_ref();
+            let is_last = rela_path.peek().is_none();
+            match cursor
+                .entries
+                .binary_search_by(|e| cmp_entry_with_name(e, name, true))
+                .or_else(|_| cursor.entries.binary_search_by(|e| cmp_entry_with_name(e, name, false)))
+            {
+                Ok(idx) if is_last => return Some(&cursor.entries[idx]),
+                Ok(idx) => {
+                    if cursor.entries[idx].mode.is_tree() {
+                        push_path_component(&mut path_buf, name);
+                        cursor = self.trees.get(path_buf.as_bstr())?;
+                    } else {
+                        break;
+                    }
+                }
+                Err(_) => break,
+            };
+        }
+        None
+    }
+
     fn write_at_pathbuf<E>(
         &mut self,
         mut out: impl FnMut(&Tree) -> Result<ObjectId, E>,
@@ -120,11 +166,12 @@ impl Editor<'_> {
         assert_ne!(self.trees.len(), 0, "there is at least the root tree");
 
         // back is for children, front is for parents.
+        let path_buf = self.path_buf.borrow_mut();
         let mut parents = vec![(
             None::<usize>,
-            self.path_buf.clone(),
+            path_buf.clone(),
             self.trees
-                .remove(&path_hash(&self.path_buf))
+                .remove(path_buf.as_bstr())
                 .expect("root tree is always present"),
         )];
         let mut children = Vec::new();
@@ -133,7 +180,7 @@ impl Editor<'_> {
             for entry in &tree.entries {
                 if entry.mode.is_tree() {
                     let prev_len = push_path_component(&mut rela_path, &entry.filename);
-                    if let Some(sub_tree) = self.trees.remove(&path_hash(&rela_path)) {
+                    if let Some(sub_tree) = self.trees.remove(&rela_path) {
                         all_entries_unchanged_or_written = false;
                         let next_parent_idx = parents.len();
                         children.push((Some(next_parent_idx), rela_path.clone(), sub_tree));
@@ -167,7 +214,7 @@ impl Editor<'_> {
                     }
                 } else if parents.is_empty() {
                     debug_assert!(children.is_empty(), "we consume children before parents");
-                    debug_assert_eq!(rela_path, self.path_buf, "this should always be the root tree");
+                    debug_assert_eq!(rela_path, **path_buf, "this should always be the root tree");
 
                     // There may be left-over trees if they are replaced with blobs for example.
                     match out(&tree) {
@@ -207,10 +254,8 @@ impl Editor<'_> {
         I: IntoIterator<Item = C>,
         C: AsRef<BStr>,
     {
-        let mut cursor = self
-            .trees
-            .get_mut(&path_hash(&self.path_buf))
-            .expect("root is always present");
+        let mut path_buf = self.path_buf.borrow_mut();
+        let mut cursor = self.trees.get_mut(path_buf.as_bstr()).expect("root is always present");
         let mut rela_path = rela_path.into_iter().peekable();
         let new_kind_is_tree = kind_and_id.map_or(false, |(kind, _, _)| kind == EntryKind::Tree);
         while let Some(name) = rela_path.next() {
@@ -294,9 +339,8 @@ impl Editor<'_> {
             if is_last && kind_and_id.map_or(false, |(_, _, mode)| mode == UpsertMode::Normal) {
                 break;
             }
-            push_path_component(&mut self.path_buf, name);
-            let path_id = path_hash(&self.path_buf);
-            cursor = match self.trees.entry(path_id) {
+            push_path_component(&mut path_buf, name);
+            cursor = match self.trees.entry(path_buf.clone()) {
                 hash_map::Entry::Occupied(e) => e.into_mut(),
                 hash_map::Entry::Vacant(e) => e.insert(
                     if let Some(tree_id) = tree_to_lookup.filter(|tree_id| !tree_id.is_empty_tree()) {
@@ -307,6 +351,7 @@ impl Editor<'_> {
                 ),
             };
         }
+        drop(path_buf);
         Ok(self)
     }
 
@@ -325,7 +370,7 @@ impl Editor<'_> {
 mod cursor {
     use crate::tree::editor::{Cursor, UpsertMode, WriteMode};
     use crate::tree::{Editor, EntryKind};
-    use crate::Tree;
+    use crate::{tree, Tree};
     use bstr::{BStr, BString};
     use gix_hash::ObjectId;
 
@@ -350,26 +395,41 @@ mod cursor {
             I: IntoIterator<Item = C>,
             C: AsRef<BStr>,
         {
-            self.path_buf.clear();
+            self.path_buf.borrow_mut().clear();
             self.upsert_or_remove_at_pathbuf(
                 rela_path,
                 Some((EntryKind::Tree, self.object_hash.null(), UpsertMode::AssureTreeOnly)),
             )?;
+            let prefix = self.path_buf.borrow_mut().clone();
             Ok(Cursor {
-                prefix: self.path_buf.clone(), /* set during the upsert call */
+                prefix, /* set during the upsert call */
                 parent: self,
             })
         }
     }
 
     impl Cursor<'_, '_> {
+        /// Obtain the entry at `rela_path` or return `None` if none was found, or the tree wasn't yet written
+        /// to that point.
+        /// Note that after [writing](Self::write) only the root path remains, all other intermediate trees are removed.
+        /// The entry can be anything that can be stored in a tree, but may have a null-id if it's a newly
+        /// inserted tree. Also, ids of trees might not be accurate as they may have been changed in memory.
+        pub fn get<I, C>(&self, rela_path: I) -> Option<&tree::Entry>
+        where
+            I: IntoIterator<Item = C>,
+            C: AsRef<BStr>,
+        {
+            self.parent.path_buf.borrow_mut().clone_from(&self.prefix);
+            self.parent.get_inner(rela_path)
+        }
+
         /// Like [`Editor::upsert()`], but with the constraint of only editing in this cursor's tree.
         pub fn upsert<I, C>(&mut self, rela_path: I, kind: EntryKind, id: ObjectId) -> Result<&mut Self, super::Error>
         where
             I: IntoIterator<Item = C>,
             C: AsRef<BStr>,
         {
-            self.parent.path_buf.clone_from(&self.prefix);
+            self.parent.path_buf.borrow_mut().clone_from(&self.prefix);
             self.parent
                 .upsert_or_remove_at_pathbuf(rela_path, Some((kind, id, UpsertMode::Normal)))?;
             Ok(self)
@@ -381,14 +441,14 @@ mod cursor {
             I: IntoIterator<Item = C>,
             C: AsRef<BStr>,
         {
-            self.parent.path_buf.clone_from(&self.prefix);
+            self.parent.path_buf.borrow_mut().clone_from(&self.prefix);
             self.parent.upsert_or_remove_at_pathbuf(rela_path, None)?;
             Ok(self)
         }
 
         /// Like [`Editor::write()`], but will write only the subtree of the cursor.
         pub fn write<E>(&mut self, out: impl FnMut(&Tree) -> Result<ObjectId, E>) -> Result<ObjectId, E> {
-            self.parent.path_buf.clone_from(&self.prefix);
+            self.parent.path_buf.borrow_mut().clone_from(&self.prefix);
             self.parent.write_at_pathbuf(out, WriteMode::FromCursor)
         }
     }
@@ -424,10 +484,6 @@ fn empty_path() -> BString {
     BString::default()
 }
 
-fn path_hash(path: &[u8]) -> BString {
-    path.to_vec().into()
-}
-
 fn push_path_component(base: &mut BString, component: &[u8]) -> usize {
     let prev_len = base.len();
     debug_assert!(base.last() != Some(&b'/'));

gix-object/src/tree/mod.rs

@@ -2,6 +2,7 @@ use crate::{
     bstr::{BStr, BString},
     tree, Tree, TreeRef,
 };
+use std::cell::RefCell;
 use std::cmp::Ordering;
 
 ///
@@ -30,7 +31,7 @@ pub struct Editor<'a> {
     /// dropped when writing at the latest.
     trees: std::collections::HashMap<BString, Tree>,
     /// A buffer to build up paths when finding the tree to edit.
-    path_buf: BString,
+    path_buf: RefCell<BString>,
     /// Our buffer for storing tree-data in, right before decoding it.
     tree_buf: Vec<u8>,
 }

gix-object/tests/object/tree/editor.rs

@@ -1,4 +1,4 @@
-use gix_object::tree::EntryKind;
+use gix_object::tree::{Entry, EntryKind};
 use gix_object::Tree;
 
 #[test]
@@ -32,6 +32,19 @@ fn from_empty_cursor() -> crate::Result {
         "only one item is left in the tree, which also keeps it alive"
     );
     assert_eq!(num_writes_and_clear(), 1, "root tree");
+    assert_eq!(
+        cursor.get(None::<&str>),
+        None,
+        "the 'root' can't be obtained, no entry exists for it, ever"
+    );
+    assert_eq!(
+        cursor.get(Some("empty-dir-via-cursor")),
+        Some(&Entry {
+            mode: EntryKind::Tree.into(),
+            filename: "empty-dir-via-cursor".into(),
+            oid: gix_hash::ObjectId::empty_tree(gix_hash::Kind::Sha1),
+        }),
+    );
 
     let actual = edit.write(&mut write)?;
     assert_eq!(
@@ -52,6 +65,20 @@ fn from_empty_cursor() -> crate::Result {
     let mut cursor = edit.cursor_at(cursor_path)?;
     let actual = cursor.remove(Some("empty-dir-via-cursor"))?.write(&mut write)?;
     assert_eq!(actual, empty_tree(), "it keeps the empty tree like the editor would");
+    assert_eq!(
+        edit.get(["some", "deeply", "nested", "path"]),
+        Some(&Entry {
+            mode: EntryKind::Tree.into(),
+            filename: "path".into(),
+            oid: gix_hash::Kind::Sha1.null(),
+        }),
+        "the directory leading to the removed one is still present"
+    );
+    assert_eq!(
+        edit.get(["some", "deeply", "nested", "path", "empty-dir-via-cursor"]),
+        None,
+        "but the removed entry is indee removed"
+    );
 
     let actual = edit.write(&mut write)?;
     assert_eq!(
@@ -400,6 +427,11 @@ fn from_empty_add() -> crate::Result {
         "4b825dc642cb6eb9a060e54bf8d69288fbee4904\n"
     );
     assert_eq!(odb.access_count_and_clear(), 0);
+    assert_eq!(
+        edit.get(None::<&str>),
+        None,
+        "the 'root' can't be obtained, no entry exists for it, ever"
+    );
 
     let actual = edit
         .upsert(Some("hi"), EntryKind::Blob, gix_hash::Kind::Sha1.null())?
@@ -431,12 +463,28 @@ fn from_empty_add() -> crate::Result {
     assert_eq!(storage.borrow().len(), 1, "still nothing but empty trees");
     assert_eq!(odb.access_count_and_clear(), 0);
 
-    let actual = edit
-        .upsert(["a", "b"], EntryKind::Tree, empty_tree())?
+    edit.upsert(["a", "b"], EntryKind::Tree, empty_tree())?
         .upsert(["a", "b", "c"], EntryKind::Tree, empty_tree())?
-        .upsert(["a", "b", "d", "e"], EntryKind::Tree, empty_tree())?
-        .write(&mut write)
-        .expect("it's OK to write empty trees");
+        .upsert(["a", "b", "d", "e"], EntryKind::Tree, empty_tree())?;
+    assert_eq!(
+        edit.get(["a", "b"]),
+        Some(&Entry {
+            mode: EntryKind::Tree.into(),
+            filename: "b".into(),
+            oid: hex_to_id("4b825dc642cb6eb9a060e54bf8d69288fbee4904"),
+        }),
+        "before writing, entries are still present, just like they were written"
+    );
+    assert_eq!(
+        edit.get(["a", "b", "c"]),
+        Some(&Entry {
+            mode: EntryKind::Tree.into(),
+            filename: "c".into(),
+            oid: gix_hash::ObjectId::empty_tree(gix_hash::Kind::Sha1),
+        }),
+    );
+
+    let actual = edit.write(&mut write).expect("it's OK to write empty trees");
     assert_eq!(
         display_tree(actual, &storage),
         "bf91a94ae659ac8a9da70d26acf42df1a36adb6e
@@ -450,6 +498,16 @@ fn from_empty_add() -> crate::Result {
     );
     assert_eq!(num_writes_and_clear(), 4, "it wrote the trees it needed to write");
     assert_eq!(odb.access_count_and_clear(), 0);
+    assert_eq!(edit.get(["a", "b"]), None, "nothing exists here");
+    assert_eq!(
+        edit.get(Some("a")),
+        Some(&Entry {
+            mode: EntryKind::Tree.into(),
+            filename: "a".into(),
+            oid: hex_to_id("850bf83c26003cb0541318718bc9217c4a5bde6d"),
+        }),
+        "but the top-level tree is still available and can yield its entries, as written with proper ids"
+    );
 
     let actual = edit
         .upsert(["a"], EntryKind::Blob, any_blob())?
@@ -532,6 +590,24 @@ fn from_empty_add() -> crate::Result {
         "still, only the root-tree changes effectively"
     );
     assert_eq!(odb.access_count_and_clear(), 0);
+
+    let actual = edit
+        .upsert(["a", "b"], EntryKind::Tree, empty_tree())?
+        .upsert(["a", "b", "c"], EntryKind::BlobExecutable, any_blob())?
+        // .upsert(["a", "b", "d"], EntryKind::Blob, any_blob())?
+        .write(&mut write)?;
+    assert_eq!(
+        display_tree(actual, &storage),
+        "d8d3f558776965f70452625b72363234f517b290
+└── a
+    └── b
+        └── c bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb.100755
+",
+        "the intermediate tree is rewritten to be suitable to hold the blob"
+    );
+    assert_eq!(num_writes_and_clear(), 3, "root, and two child-trees");
+    assert_eq!(odb.access_count_and_clear(), 0);
+
     Ok(())
 }