[repository #190] first shot at ancestor iteration…

…which surprisingly enough works with our kind of caching system.
Amazing.
Does it really work though?

Author: Byron

Cargo.toml

@@ -80,16 +80,17 @@ env_logger = { version = "0.9.0", optional = true, default-features = false, fea
 crosstermion = { version = "0.8.0", optional = true, default-features = false }
 futures-lite = { version = "1.12.0", optional = true, default-features = false, features = ["std"] }
 
-[profile.dev.package]
-git-object.opt-level = 3
-git-ref.opt-level = 3
-git-pack.opt-level = 3
-git-hash.opt-level = 3
-git-actor.opt-level = 3
-git-config.opt-level = 3
-miniz_oxide.opt-level = 3
-sha-1.opt-level = 3
-sha1.opt-level = 3
+# toml_edit can't parse this :(
+#[profile.dev.package]
+#git-object.opt-level = 3
+#git-ref.opt-level = 3
+#git-pack.opt-level = 3
+#git-hash.opt-level = 3
+#git-actor.opt-level = 3
+#git-config.opt-level = 3
+#miniz_oxide.opt-level = 3
+#sha-1.opt-level = 3
+#sha1.opt-level = 3
 
 [profile.release]
 overflow-checks = false

experiments/diffing/src/main.rs

@@ -255,7 +255,7 @@ where
     where
         L: for<'a> FnMut(&oid, &'a mut Vec<u8>) -> Option<odb::data::Object<'a>>,
     {
-        find(id, buf).and_then(|o| o.into_tree_iter())
+        find(id, buf).and_then(|o| o.try_into_tree_iter())
     }
 
     fn tree_iter_by_commit<'b, L>(id: &oid, buf: &'b mut Vec<u8>, mut find: L) -> TreeRefIter<'b>
@@ -264,7 +264,7 @@ where
     {
         let tid = find(id, buf)
             .expect("commit present")
-            .into_commit_iter()
+            .try_into_commit_iter()
             .expect("a commit")
             .tree_id()
             .expect("tree id present and decodable");

experiments/traversal/src/main.rs

@@ -209,13 +209,13 @@ where
             for commit in commits {
                 let tree_id = db
                     .try_find(commit, &mut buf, &mut cache)?
-                    .and_then(|o| o.into_commit_iter().and_then(|mut c| c.tree_id()))
+                    .and_then(|o| o.try_into_commit_iter().and_then(|mut c| c.tree_id()))
                     .expect("commit as starting point");
 
                 let mut count = Count { entries: 0, seen };
                 db.find_tree_iter(tree_id, &mut buf2, &mut cache)?.traverse(
                     &mut state,
-                    |oid, buf| db.find(oid, buf, &mut cache).ok().and_then(|o| o.into_tree_iter()),
+                    |oid, buf| db.find(oid, buf, &mut cache).ok().and_then(|o| o.try_into_tree_iter()),
                     &mut count,
                 )?;
                 entries += count.entries as u64;

git-diff/tests/visit/mod.rs

@@ -34,7 +34,7 @@ mod changes {
             Ok(db
                 .try_find(tree_id, buf, &mut pack::cache::Never)?
                 .expect("main tree present")
-                .into_tree_iter()
+                .try_into_tree_iter()
                 .expect("id to be a tree"))
         }
 
@@ -53,7 +53,7 @@ mod changes {
                     db.try_find(oid, buf, &mut pack::cache::Never)
                         .ok()
                         .flatten()
-                        .and_then(|obj| obj.into_tree_iter())
+                        .and_then(|obj| obj.try_into_tree_iter())
                 },
                 &mut recorder,
             )?;
@@ -78,7 +78,7 @@ mod changes {
             let current_tree = db
                 .try_find(main_tree_id, &mut buf, &mut pack::cache::Never)?
                 .expect("main tree present")
-                .into_tree_iter()
+                .try_into_tree_iter()
                 .expect("id to be a tree");
             let mut buf2 = Vec::new();
             let previous_tree: Option<_> = {
@@ -88,7 +88,7 @@ mod changes {
                     .and_then(|c| c.into_commit())
                     .map(|c| c.tree())
                     .and_then(|tree| db.try_find(tree, &mut buf2, &mut pack::cache::Never).ok().flatten())
-                    .and_then(|tree| tree.into_tree_iter())
+                    .and_then(|tree| tree.try_into_tree_iter())
             };
 
             let mut recorder = git_diff::tree::Recorder::default();
@@ -99,7 +99,7 @@ mod changes {
                     db.try_find(oid, buf, &mut pack::cache::Never)
                         .ok()
                         .flatten()
-                        .and_then(|obj| obj.into_tree_iter())
+                        .and_then(|obj| obj.try_into_tree_iter())
                 },
                 &mut recorder,
             )?;
@@ -133,7 +133,7 @@ mod changes {
                 db.try_find(oid, buf, &mut pack::cache::Never)
                     .ok()
                     .flatten()
-                    .and_then(|o| o.into_commit_iter())
+                    .and_then(|o| o.try_into_commit_iter())
             })
             .collect::<Vec<_>>()
             .into_iter()

git-pack/CHANGELOG.md

@@ -1,3 +1,10 @@
+### 0.10.0 (2021-08-??)
+
+- **renames**
+   - `data::Object::into_commit_iter()` -> `data::Object::try_into_commit_iter()`
+   - `data::Object::into_tree_iter()` -> `data::Object::try_into_tree_iter()`
+   - `data::Object::into_tag_iter()` -> `data::Object::try_into_tag_iter()`
+
 ### 0.9.0 (2021-08-27)
 
 - **renames / moves / visibility**

git-pack/src/data/object.rs

@@ -29,7 +29,7 @@ impl<'a> Object<'a> {
 
     /// Returns this object as tree iterator to parse entries one at a time to avoid allocations, or
     /// `None` if this is not a tree object.
-    pub fn into_tree_iter(self) -> Option<TreeRefIter<'a>> {
+    pub fn try_into_tree_iter(self) -> Option<TreeRefIter<'a>> {
         match self.kind {
             git_object::Kind::Tree => Some(TreeRefIter::from_bytes(self.data)),
             _ => None,
@@ -38,7 +38,7 @@ impl<'a> Object<'a> {
 
     /// Returns this object as commit iterator to parse tokens one at a time to avoid allocations, or
     /// `None` if this is not a commit object.
-    pub fn into_commit_iter(self) -> Option<CommitRefIter<'a>> {
+    pub fn try_into_commit_iter(self) -> Option<CommitRefIter<'a>> {
         match self.kind {
             git_object::Kind::Commit => Some(CommitRefIter::from_bytes(self.data)),
             _ => None,
@@ -47,7 +47,7 @@ impl<'a> Object<'a> {
 
     /// Returns this object as tag iterator to parse tokens one at a time to avoid allocations, or
     /// `None` if this is not a tag object.
-    pub fn into_tag_iter(self) -> Option<TagRefIter<'a>> {
+    pub fn try_into_tag_iter(self) -> Option<TagRefIter<'a>> {
         match self.kind {
             git_object::Kind::Tag => Some(TagRefIter::from_bytes(self.data)),
             _ => None,

git-pack/src/data/output/count/objects.rs

@@ -217,7 +217,7 @@ where
                                                 progress.inc();
                                                 stats.expanded_objects += 1;
                                                 out.push(output::Count::from_data(oid, &obj));
-                                                obj.into_tree_iter()
+                                                obj.try_into_tree_iter()
                                             }
                                             None => None,
                                         }
@@ -300,7 +300,7 @@ where
                                             progress.inc();
                                             stats.expanded_objects += 1;
                                             out.push(output::Count::from_data(oid, &obj));
-                                            obj.into_tree_iter()
+                                            obj.try_into_tree_iter()
                                         }
                                         None => None,
                                     }

git-pack/src/find_traits.rs

@@ -127,9 +127,9 @@ mod ext {
         make_obj_lookup!(find_tree, ObjectRef::Tree, Kind::Tree, TreeRef<'a>);
         make_obj_lookup!(find_tag, ObjectRef::Tag, Kind::Tag, TagRef<'a>);
         make_obj_lookup!(find_blob, ObjectRef::Blob, Kind::Blob, BlobRef<'a>);
-        make_iter_lookup!(find_commit_iter, Kind::Blob, CommitRefIter<'a>, into_commit_iter);
-        make_iter_lookup!(find_tree_iter, Kind::Tree, TreeRefIter<'a>, into_tree_iter);
-        make_iter_lookup!(find_tag_iter, Kind::Tag, TagRefIter<'a>, into_tag_iter);
+        make_iter_lookup!(find_commit_iter, Kind::Blob, CommitRefIter<'a>, try_into_commit_iter);
+        make_iter_lookup!(find_tree_iter, Kind::Tree, TreeRefIter<'a>, try_into_tree_iter);
+        make_iter_lookup!(find_tag_iter, Kind::Tag, TagRefIter<'a>, try_into_tag_iter);
     }
 
     impl<T: super::Find> FindExt for T {}

git-repository/src/easy/mod.rs

@@ -29,7 +29,7 @@ pub mod commit;
 pub mod head;
 pub mod iter;
 pub mod object;
-mod oid;
+pub mod oid;
 pub mod reference;
 pub mod state;
 

git-repository/src/easy/object/mod.rs

@@ -131,16 +131,16 @@ where
     /// As [`to_commit_iter()`][ObjectRef::to_commit_iter()] but panics if this is not a commit
     pub fn commit_iter(&self) -> CommitRefIter<'_> {
         git_odb::data::Object::new(self.kind, &self.data)
-            .into_commit_iter()
+            .try_into_commit_iter()
             .expect("BUG: This object must be a commit")
     }
 
     pub fn to_commit_iter(&self) -> Option<CommitRefIter<'_>> {
-        git_odb::data::Object::new(self.kind, &self.data).into_commit_iter()
+        git_odb::data::Object::new(self.kind, &self.data).try_into_commit_iter()
     }
 
     pub fn to_tag_iter(&self) -> Option<TagRefIter<'_>> {
-        git_odb::data::Object::new(self.kind, &self.data).into_tag_iter()
+        git_odb::data::Object::new(self.kind, &self.data).try_into_tag_iter()
     }
 }
 

git-repository/src/easy/oid.rs

@@ -1,3 +1,4 @@
+#![allow(missing_docs)]
 use std::ops::Deref;
 
 use git_hash::{oid, ObjectId};
@@ -6,6 +7,7 @@ use crate::{
     easy,
     easy::{ext::ObjectAccessExt, object::find, ObjectRef, Oid},
 };
+use std::cell::RefMut;
 
 impl<'repo, A> Oid<'repo, A>
 where
@@ -49,6 +51,98 @@ where
     }
 }
 
+pub struct Ancestors<'repo, A>
+where
+    A: easy::Access + Sized,
+{
+    repo: A::RepoRef,
+    pack_cache: RefMut<'repo, easy::PackCache>,
+    access: &'repo A,
+    tip: ObjectId,
+}
+
+pub mod ancestors {
+    use crate::easy;
+    use crate::easy::oid::Ancestors;
+    use crate::easy::Oid;
+    use git_odb::Find;
+    use std::ops::{Deref, DerefMut};
+
+    impl<'repo, A> Oid<'repo, A>
+    where
+        A: easy::Access + Sized,
+    {
+        pub fn ancestors(&self) -> Result<Ancestors<'repo, A>, Error> {
+            let pack_cache = self.access.state().try_borrow_mut_pack_cache()?;
+            let repo = self.access.repo()?;
+            Ok(Ancestors {
+                pack_cache,
+                repo,
+                access: self.access,
+                tip: self.inner,
+            })
+        }
+    }
+
+    pub struct Iter<'a, 'repo, A>
+    where
+        A: easy::Access + Sized,
+    {
+        access: &'repo A,
+        inner: Box<dyn Iterator<Item = Result<git_hash::ObjectId, git_traverse::commit::ancestors::Error>> + 'a>,
+    }
+
+    impl<'repo, A> Ancestors<'repo, A>
+    where
+        A: easy::Access + Sized,
+    {
+        // TODO: tests
+        pub fn all(&mut self) -> Iter<'_, 'repo, A> {
+            Iter {
+                access: self.access,
+                inner: Box::new(git_traverse::commit::Ancestors::new(
+                    Some(self.tip),
+                    git_traverse::commit::ancestors::State::default(),
+                    move |oid, buf| {
+                        self.repo
+                            .deref()
+                            .odb
+                            .try_find(oid, buf, self.pack_cache.deref_mut())
+                            .ok()
+                            .flatten()
+                            .and_then(|obj| obj.try_into_commit_iter())
+                    },
+                )),
+            }
+        }
+    }
+
+    impl<'a, 'repo, A> Iterator for Iter<'a, 'repo, A>
+    where
+        A: easy::Access + Sized,
+    {
+        type Item = Result<Oid<'repo, A>, git_traverse::commit::ancestors::Error>;
+
+        fn next(&mut self) -> Option<Self::Item> {
+            self.inner.next().map(|res| res.map(|oid| oid.attach(self.access)))
+        }
+    }
+
+    mod error {
+        use crate::easy;
+
+        #[derive(Debug, thiserror::Error)]
+        pub enum Error {
+            #[error(transparent)]
+            BorrowRepo(#[from] easy::borrow::repo::Error),
+            #[error(transparent)]
+            BorrowBufMut(#[from] easy::borrow::state::Error),
+        }
+    }
+    use crate::ext::ObjectIdExt;
+    use error::Error;
+}
+
 mod impls {
     use git_hash::{oid, ObjectId};