change!: use gix-object::Find trait

Author: Byron

gitoxide-core/src/hours/mod.rs

@@ -175,7 +175,7 @@ where
                         }
                         commit_idx += 1;
                     }
-                    Err(gix::traverse::commit::ancestors::Error::FindExisting { .. }) => {
+                    Err(gix::traverse::commit::ancestors::Error::Find { .. }) => {
                         is_shallow = true;
                         break;
                     }

gitoxide-core/src/query/engine/update.rs

@@ -354,7 +354,7 @@ pub fn update(
                         break;
                     }
                 }
-                Err(gix::traverse::commit::ancestors::Error::FindExisting { .. }) => {
+                Err(gix::traverse::commit::ancestors::Error::Find { .. }) => {
                     writeln!(err, "shallow repository - commit history is truncated").ok();
                     break;
                 }

gix-index/src/init.rs

@@ -41,7 +41,7 @@ mod from_tree {
         {
             let _span = gix_features::trace::coarse!("gix_index::State::from_tree()");
             let mut buf = Vec::new();
-            let root = find(tree, &mut buf).ok_or(breadthfirst::Error::NotFound { oid: tree.into() })?;
+            let root = find(tree, &mut buf).ok_or(breadthfirst::Error::Find { oid: tree.into() })?;
 
             let mut delegate = CollectEntries::new();
             breadthfirst(root, breadthfirst::State::default(), &mut find, &mut delegate)?;

gix-traverse/src/commit.rs

@@ -1,8 +1,9 @@
+use gix_object::FindExt;
 use smallvec::SmallVec;
 
 /// An iterator over the ancestors one or more starting commits
 pub struct Ancestors<Find, Predicate, StateMut> {
-    find: Find,
+    objects: Find,
     cache: Option<gix_commitgraph::Graph>,
     predicate: Predicate,
     state: StateMut,
@@ -95,7 +96,7 @@ pub mod ancestors {
     use gix_date::SecondsSinceUnixEpoch;
     use gix_hash::{oid, ObjectId};
     use gix_hashtable::HashSet;
-    use gix_object::CommitRefIter;
+    use gix_object::{CommitRefIter, FindExt};
     use smallvec::SmallVec;
 
     use crate::commit::{collect_parents, Ancestors, Either, Info, ParentIds, Parents, Sorting};
@@ -104,11 +105,8 @@ pub mod ancestors {
     #[derive(Debug, thiserror::Error)]
     #[allow(missing_docs)]
     pub enum Error {
-        #[error("The commit {oid} could not be found")]
-        FindExisting {
-            oid: ObjectId,
-            source: Box<dyn std::error::Error + Send + Sync + 'static>,
-        },
+        #[error(transparent)]
+        Find(#[from] gix_object::find::existing_iter::Error),
         #[error(transparent)]
         ObjectDecode(#[from] gix_object::decode::Error),
     }
@@ -147,11 +145,10 @@ pub mod ancestors {
     }
 
     /// Builder
-    impl<Find, Predicate, StateMut, E> Ancestors<Find, Predicate, StateMut>
+    impl<Find, Predicate, StateMut> Ancestors<Find, Predicate, StateMut>
     where
-        Find: for<'a> FnMut(&oid, &'a mut Vec<u8>) -> Result<CommitRefIter<'a>, E>,
+        Find: gix_object::Find,
         StateMut: BorrowMut<State>,
-        E: std::error::Error + Send + Sync + 'static,
     {
         /// Set the sorting method, either topological or by author date
         pub fn sorting(mut self, sorting: Sorting) -> Result<Self, Error> {
@@ -164,11 +161,7 @@ pub mod ancestors {
                     let cutoff_time = self.sorting.cutoff_time();
                     let state = self.state.borrow_mut();
                     for commit_id in state.next.drain(..) {
-                        let commit_iter =
-                            (self.find)(&commit_id, &mut state.buf).map_err(|err| Error::FindExisting {
-                                oid: commit_id,
-                                source: err.into(),
-                            })?;
+                        let commit_iter = self.objects.find_commit_iter(&commit_id, &mut state.buf)?;
                         let time = commit_iter.committer()?.time.seconds;
                         match cutoff_time {
                             Some(cutoff_time) if time >= cutoff_time => {
@@ -214,11 +207,10 @@ pub mod ancestors {
     }
 
     /// Initialization
-    impl<Find, StateMut, E> Ancestors<Find, fn(&oid) -> bool, StateMut>
+    impl<Find, StateMut> Ancestors<Find, fn(&oid) -> bool, StateMut>
     where
-        Find: for<'a> FnMut(&oid, &'a mut Vec<u8>) -> Result<CommitRefIter<'a>, E>,
+        Find: gix_object::Find,
         StateMut: BorrowMut<State>,
-        E: std::error::Error + Send + Sync + 'static,
     {
         /// Create a new instance.
         ///
@@ -236,12 +228,11 @@ pub mod ancestors {
     }
 
     /// Initialization
-    impl<Find, Predicate, StateMut, E> Ancestors<Find, Predicate, StateMut>
+    impl<Find, Predicate, StateMut> Ancestors<Find, Predicate, StateMut>
     where
-        Find: for<'a> FnMut(&oid, &'a mut Vec<u8>) -> Result<CommitRefIter<'a>, E>,
+        Find: gix_object::Find,
         Predicate: FnMut(&oid) -> bool,
         StateMut: BorrowMut<State>,
-        E: std::error::Error + Send + Sync + 'static,
     {
         /// Create a new instance with commit filtering enabled.
         ///
@@ -274,7 +265,7 @@ pub mod ancestors {
                 }
             }
             Self {
-                find,
+                objects: find,
                 cache: None,
                 predicate,
                 state,
@@ -299,12 +290,11 @@ pub mod ancestors {
         }
     }
 
-    impl<Find, Predicate, StateMut, E> Iterator for Ancestors<Find, Predicate, StateMut>
+    impl<Find, Predicate, StateMut> Iterator for Ancestors<Find, Predicate, StateMut>
     where
-        Find: for<'a> FnMut(&oid, &'a mut Vec<u8>) -> Result<CommitRefIter<'a>, E>,
+        Find: gix_object::Find,
         Predicate: FnMut(&oid) -> bool,
         StateMut: BorrowMut<State>,
-        E: std::error::Error + Send + Sync + 'static,
     {
         type Item = Result<Info, Error>;
 
@@ -334,12 +324,11 @@ pub mod ancestors {
     }
 
     /// Utilities
-    impl<Find, Predicate, StateMut, E> Ancestors<Find, Predicate, StateMut>
+    impl<Find, Predicate, StateMut> Ancestors<Find, Predicate, StateMut>
     where
-        Find: for<'a> FnMut(&oid, &'a mut Vec<u8>) -> Result<CommitRefIter<'a>, E>,
+        Find: gix_object::Find,
         Predicate: FnMut(&oid) -> bool,
         StateMut: BorrowMut<State>,
-        E: std::error::Error + Send + Sync + 'static,
     {
         fn next_by_commit_date(
             &mut self,
@@ -349,7 +338,7 @@ pub mod ancestors {
 
             let (commit_time, oid) = state.queue.pop()?;
             let mut parents: ParentIds = Default::default();
-            match super::find(self.cache.as_ref(), &mut self.find, &oid, &mut state.buf) {
+            match super::find(self.cache.as_ref(), &self.objects, &oid, &mut state.buf) {
                 Ok(Either::CachedCommit(commit)) => {
                     if !collect_parents(&mut state.parent_ids, self.cache.as_ref(), commit.iter_parents()) {
                         // drop corrupt caches and try again with ODB
@@ -380,7 +369,7 @@ pub mod ancestors {
                                     continue;
                                 }
 
-                                let parent = (self.find)(id.as_ref(), &mut state.parents_buf).ok();
+                                let parent = self.objects.find_commit_iter(id.as_ref(), &mut state.parents_buf).ok();
                                 let parent_commit_time = parent
                                     .and_then(|parent| parent.committer().ok().map(|committer| committer.time.seconds))
                                     .unwrap_or_default();
@@ -395,12 +384,7 @@ pub mod ancestors {
                         }
                     }
                 }
-                Err(err) => {
-                    return Some(Err(Error::FindExisting {
-                        oid,
-                        source: err.into(),
-                    }))
-                }
+                Err(err) => return Some(Err(err.into())),
             }
             Some(Ok(Info {
                 id: oid,
@@ -411,18 +395,17 @@ pub mod ancestors {
     }
 
     /// Utilities
-    impl<Find, Predicate, StateMut, E> Ancestors<Find, Predicate, StateMut>
+    impl<Find, Predicate, StateMut> Ancestors<Find, Predicate, StateMut>
     where
-        Find: for<'a> FnMut(&oid, &'a mut Vec<u8>) -> Result<CommitRefIter<'a>, E>,
+        Find: gix_object::Find,
         Predicate: FnMut(&oid) -> bool,
         StateMut: BorrowMut<State>,
-        E: std::error::Error + Send + Sync + 'static,
     {
         fn next_by_topology(&mut self) -> Option<Result<Info, Error>> {
             let state = self.state.borrow_mut();
             let oid = state.next.pop_front()?;
             let mut parents: ParentIds = Default::default();
-            match super::find(self.cache.as_ref(), &mut self.find, &oid, &mut state.buf) {
+            match super::find(self.cache.as_ref(), &self.objects, &oid, &mut state.buf) {
                 Ok(Either::CachedCommit(commit)) => {
                     if !collect_parents(&mut state.parent_ids, self.cache.as_ref(), commit.iter_parents()) {
                         // drop corrupt caches and try again with ODB
@@ -460,12 +443,7 @@ pub mod ancestors {
                         }
                     }
                 }
-                Err(err) => {
-                    return Some(Err(Error::FindExisting {
-                        oid,
-                        source: err.into(),
-                    }))
-                }
+                Err(err) => return Some(Err(err.into())),
             }
             Some(Ok(Info {
                 id: oid,
@@ -503,18 +481,17 @@ fn collect_parents(
     true
 }
 
-fn find<'cache, 'buf, Find, E>(
+fn find<'cache, 'buf, Find>(
     cache: Option<&'cache gix_commitgraph::Graph>,
-    mut find: Find,
+    objects: Find,
     id: &gix_hash::oid,
     buf: &'buf mut Vec<u8>,
-) -> Result<Either<'buf, 'cache>, E>
+) -> Result<Either<'buf, 'cache>, gix_object::find::existing_iter::Error>
 where
-    Find: for<'a> FnMut(&gix_hash::oid, &'a mut Vec<u8>) -> Result<gix_object::CommitRefIter<'a>, E>,
-    E: std::error::Error + Send + Sync + 'static,
+    Find: gix_object::Find,
 {
     match cache.and_then(|cache| cache.commit_by_id(id).map(Either::CachedCommit)) {
         Some(c) => Ok(c),
-        None => find(id, buf).map(Either::CommitRefIter),
+        None => objects.find_commit_iter(id, buf).map(Either::CommitRefIter),
     }
 }

gix-traverse/src/tree/breadthfirst.rs

@@ -6,8 +6,8 @@ use gix_hash::ObjectId;
 #[derive(Debug, thiserror::Error)]
 #[allow(missing_docs)]
 pub enum Error {
-    #[error("The tree {oid} could not be found")]
-    NotFound { oid: ObjectId },
+    #[error(transparent)]
+    Find(#[from] gix_object::find::existing_iter::Error),
     #[error("The delegate cancelled the operation")]
     Cancelled,
     #[error(transparent)]
@@ -31,8 +31,7 @@ impl State {
 pub(crate) mod impl_ {
     use std::borrow::BorrowMut;
 
-    use gix_hash::oid;
-    use gix_object::{tree::EntryMode, TreeRefIter};
+    use gix_object::{tree::EntryMode, FindExt, TreeRefIter};
 
     use super::{Error, State};
     use crate::tree::Visit;
@@ -46,17 +45,17 @@ pub(crate) mod impl_ {
     /// * `find` - a way to lookup new object data during traversal by their `ObjectId`, writing their data into buffer and returning
     ///    an iterator over entries if the object is present and is a tree. Caching should be implemented within this function
     ///    as needed. The return value is `Option<TreeIter>` which degenerates all error information. Not finding a commit should also
-    ///    be considered an errors as all objects in the tree DAG should be present in the database. Hence [`Error::NotFound`] should
+    ///    be considered an errors as all objects in the tree DAG should be present in the database. Hence [`Error::Find`] should
     ///    be escalated into a more specific error if its encountered by the caller.
     /// * `delegate` - A way to observe entries and control the iteration while allowing the optimizer to let you pay only for what you use.
     pub fn traverse<StateMut, Find, V>(
         root: TreeRefIter<'_>,
         mut state: StateMut,
-        mut find: Find,
+        objects: Find,
         delegate: &mut V,
     ) -> Result<(), Error>
     where
-        Find: for<'a> FnMut(&oid, &'a mut Vec<u8>) -> Option<TreeRefIter<'a>>,
+        Find: gix_object::Find,
         StateMut: BorrowMut<State>,
         V: Visit,
     {
@@ -95,10 +94,7 @@ pub(crate) mod impl_ {
             match state.next.pop_front() {
                 Some(oid) => {
                     delegate.pop_front_tracked_path_and_set_current();
-                    match find(&oid, &mut state.buf) {
-                        Some(tree_iter) => tree = tree_iter,
-                        None => return Err(Error::NotFound { oid: oid.to_owned() }),
-                    }
+                    tree = objects.find_tree_iter(&oid, &mut state.buf)?;
                 }
                 None => break Ok(()),
             }

gix-traverse/tests/commit/mod.rs

@@ -1,6 +1,5 @@
 mod ancestor {
     use gix_hash::{oid, ObjectId};
-    use gix_odb::pack::FindExt;
     use gix_traverse::commit;
 
     use crate::hex_to_id;
@@ -68,7 +67,7 @@ mod ancestor {
                 let oids = commit::Ancestors::filtered(
                     tips.clone(),
                     commit::ancestors::State::default(),
-                    |oid, buf| store.find_commit_iter(oid, buf).map(|t| t.0),
+                    &store,
                     predicate.clone(),
                 )
                 .sorting(self.sorting)?
@@ -86,14 +85,12 @@ mod ancestor {
             let (store, tips, expected) = self.setup()?;
 
             for use_commitgraph in [false, true] {
-                let oids = commit::Ancestors::new(tips.clone(), commit::ancestors::State::default(), |oid, buf| {
-                    store.find_commit_iter(oid, buf).map(|t| t.0)
-                })
-                .sorting(self.sorting)?
-                .parents(self.mode)
-                .commit_graph(self.setup_commitgraph(store.store_ref(), use_commitgraph))
-                .map(|res| res.map(|info| info.id))
-                .collect::<Result<Vec<_>, _>>()?;
+                let oids = commit::Ancestors::new(tips.clone(), commit::ancestors::State::default(), &store)
+                    .sorting(self.sorting)?
+                    .parents(self.mode)
+                    .commit_graph(self.setup_commitgraph(store.store_ref(), use_commitgraph))
+                    .map(|res| res.map(|info| info.id))
+                    .collect::<Result<Vec<_>, _>>()?;
                 assert_eq!(oids, expected);
             }
             Ok(())
@@ -346,7 +343,6 @@ mod ancestor {
 
     /// Some dates adjusted to be a year apart, but still 'c1' and 'c2' with the same date.
     mod adjusted_dates {
-        use gix_object::FindExt;
         use gix_traverse::commit::{ancestors, Ancestors, Parents, Sorting};
 
         use crate::{commit::ancestor::TraversalAssertion, hex_to_id};
@@ -403,7 +399,7 @@ mod ancestor {
             let iter = Ancestors::new(
                 Some(hex_to_id("9902e3c3e8f0c569b4ab295ddf473e6de763e1e7" /* c2 */)),
                 ancestors::State::default(),
-                move |oid, buf| store.find_commit_iter(oid, buf),
+                &store,
             )
             .sorting(Sorting::ByCommitTimeNewestFirstCutoffOlderThan {
                 seconds: 978393600, // =2001-01-02 00:00:00 +0000

gix-traverse/tests/tree/mod.rs

@@ -24,7 +24,7 @@ fn breadth_first_full_path() -> crate::Result<()> {
         db.find_tree_iter(&commit.tree_id().expect("a tree is available in a commit"), &mut buf2)?
             .0,
         tree::breadthfirst::State::default(),
-        |oid, buf| db.find_tree_iter(oid, buf).ok().map(|t| t.0),
+        &db,
         &mut recorder,
     )?;
 
@@ -111,7 +111,7 @@ fn breadth_first_filename_only() -> crate::Result<()> {
         db.find_tree_iter(&commit.tree_id().expect("a tree is available in a commit"), &mut buf2)?
             .0,
         tree::breadthfirst::State::default(),
-        |oid, buf| db.find_tree_iter(oid, buf).ok().map(|t| t.0),
+        &db,
         &mut recorder,
     )?;
 
@@ -138,7 +138,7 @@ fn breadth_first_no_location() -> crate::Result<()> {
         db.find_tree_iter(&commit.tree_id().expect("a tree is available in a commit"), &mut buf2)?
             .0,
         tree::breadthfirst::State::default(),
-        |oid, buf| db.find_tree_iter(oid, buf).ok().map(|t| t.0),
+        &db,
         &mut recorder,
     )?;