Move lookup_entry, lookup_entry_by_path to TreeRefIter

Adapt functions to new context. This mostly means copying the
implementation from `gix::types::Tree` and applying minor changes
related to `buffer` being passed as an argument.

Author: cruessler

gix-object/src/tree/ref_iter.rs

@@ -11,39 +11,6 @@ impl<'a> TreeRefIter<'a> {
     pub fn from_bytes(data: &'a [u8]) -> TreeRefIter<'a> {
         TreeRefIter { data }
     }
-}
-
-impl<'a> TreeRef<'a> {
-    /// Deserialize a Tree from `data`.
-    pub fn from_bytes(mut data: &'a [u8]) -> Result<TreeRef<'a>, crate::decode::Error> {
-        let input = &mut data;
-        match decode::tree.parse_next(input) {
-            Ok(tag) => Ok(tag),
-            Err(err) => Err(crate::decode::Error::with_err(err, input)),
-        }
-    }
-
-    /// Find an entry named `name` knowing if the entry is a directory or not, using a binary search.
-    ///
-    /// Note that it's impossible to binary search by name alone as the sort order is special.
-    pub fn bisect_entry(&self, name: &BStr, is_dir: bool) -> Option<EntryRef<'a>> {
-        static NULL_HASH: gix_hash::ObjectId = gix_hash::Kind::shortest().null();
-
-        let search = EntryRef {
-            mode: if is_dir {
-                tree::EntryKind::Tree
-            } else {
-                tree::EntryKind::Blob
-            }
-            .into(),
-            filename: name,
-            oid: &NULL_HASH,
-        };
-        self.entries
-            .binary_search_by(|e| e.cmp(&search))
-            .ok()
-            .map(|idx| self.entries[idx])
-    }
 
     /// Follow a sequence of `path` components starting from this instance, and look them up one by one until the last component
     /// is looked up and its tree entry is returned.
@@ -64,19 +31,24 @@ impl<'a> TreeRef<'a> {
         I: IntoIterator<Item = P>,
         P: PartialEq<BStr>,
     {
-        let mut path = path.into_iter().peekable();
-        let mut entries = self.entries.clone();
+        buffer.clear();
 
+        let mut path = path.into_iter().peekable();
+        buffer.extend_from_slice(&self.data);
         while let Some(component) = path.next() {
-            match entries.iter().find(|entry| component.eq(entry.filename)) {
+            match TreeRefIter::from_bytes(&buffer)
+                .filter_map(Result::ok)
+                .find(|entry| component.eq(entry.filename))
+            {
                 Some(entry) => {
                     if path.peek().is_none() {
-                        return Ok(Some((*entry).into()));
+                        return Ok(Some(entry.into()));
                     } else {
                         let next_id = entry.oid.to_owned();
-                        let obj = odb.find_tree(&next_id, buffer)?;
-
-                        entries = obj.entries;
+                        let obj = odb.find(&next_id, buffer)?;
+                        if !obj.kind.is_tree() {
+                            return Ok(None);
+                        }
                     }
                 }
                 None => return Ok(None),
@@ -108,6 +80,39 @@ impl<'a> TreeRef<'a> {
             }),
         )
     }
+}
+
+impl<'a> TreeRef<'a> {
+    /// Deserialize a Tree from `data`.
+    pub fn from_bytes(mut data: &'a [u8]) -> Result<TreeRef<'a>, crate::decode::Error> {
+        let input = &mut data;
+        match decode::tree.parse_next(input) {
+            Ok(tag) => Ok(tag),
+            Err(err) => Err(crate::decode::Error::with_err(err, input)),
+        }
+    }
+
+    /// Find an entry named `name` knowing if the entry is a directory or not, using a binary search.
+    ///
+    /// Note that it's impossible to binary search by name alone as the sort order is special.
+    pub fn bisect_entry(&self, name: &BStr, is_dir: bool) -> Option<EntryRef<'a>> {
+        static NULL_HASH: gix_hash::ObjectId = gix_hash::Kind::shortest().null();
+
+        let search = EntryRef {
+            mode: if is_dir {
+                tree::EntryKind::Tree
+            } else {
+                tree::EntryKind::Blob
+            }
+            .into(),
+            filename: name,
+            oid: &NULL_HASH,
+        };
+        self.entries
+            .binary_search_by(|e| e.cmp(&search))
+            .ok()
+            .map(|idx| self.entries[idx])
+    }
 
     /// Create an instance of the empty tree.
     ///

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

@@ -64,7 +64,7 @@ fn lookup_entry_toplevel() -> crate::Result {
     let root_tree_id = hex_to_id("ff7e7d2aecae1c3fb15054b289a4c58aa65b8646");
 
     let mut buf = Vec::new();
-    let root_tree = odb.find_tree(&root_tree_id, &mut buf)?;
+    let root_tree = odb.find_tree_iter(&root_tree_id, &mut buf)?;
 
     let mut buf = Vec::new();
     let entry = root_tree.lookup_entry_by_path(&odb, &mut buf, "bin").unwrap().unwrap();
@@ -81,7 +81,7 @@ fn lookup_entry_nested_path() -> crate::Result {
     let root_tree_id = hex_to_id("ff7e7d2aecae1c3fb15054b289a4c58aa65b8646");
 
     let mut buf = Vec::new();
-    let root_tree = odb.find_tree(&root_tree_id, &mut buf)?;
+    let root_tree = odb.find_tree_iter(&root_tree_id, &mut buf)?;
 
     let mut buf = Vec::new();
     let entry = root_tree