feat: add Graph::insert_parents_with_lookup()

It's another way to insert parents, and tuned for the needs of merge-base.

Author: Byron

gix-revwalk/src/graph/mod.rs

@@ -136,6 +136,44 @@ impl<'find, T> Graph<'find, T> {
         Ok(())
     }
 
+    /// Insert the parents of commit named `id` to the graph and associate new parents with data
+    /// as produced by `parent_data(parent_id, parent_info, maybe-existing-data &mut T) -> T`, which is always
+    /// provided the full parent commit information.
+    /// It will be provided either existing data, along with complete information about the parent,
+    /// and produces new data even though it's only used in case the parent isn't stored in the graph yet.
+    pub fn insert_parents_with_lookup<E>(
+        &mut self,
+        id: &gix_hash::oid,
+        parent_data: &mut dyn FnMut(gix_hash::ObjectId, LazyCommit<'_>, Option<&mut T>) -> Result<T, E>,
+    ) -> Result<(), E>
+    where
+        E: From<gix_object::find::existing_iter::Error>
+            + From<gix_object::decode::Error>
+            + From<commit::iter_parents::Error>,
+    {
+        let commit = self.lookup(id).map_err(E::from)?;
+        let parents: SmallVec<[_; 2]> = commit.iter_parents().collect();
+        for parent_id in parents {
+            let parent_id = parent_id.map_err(E::from)?;
+            let parent = match try_lookup(&parent_id, &*self.find, self.cache.as_ref(), &mut self.parent_buf)
+                .map_err(E::from)?
+            {
+                Some(p) => p,
+                None => continue, // skip missing objects, this is due to shallow clones for instance.
+            };
+
+            match self.map.entry(parent_id) {
+                gix_hashtable::hash_map::Entry::Vacant(entry) => {
+                    entry.insert(parent_data(parent_id, parent, None)?);
+                }
+                gix_hashtable::hash_map::Entry::Occupied(mut entry) => {
+                    parent_data(parent_id, parent, Some(entry.get_mut()))?;
+                }
+            }
+        }
+        Ok(())
+    }
+
     /// Turn ourselves into the underlying graph structure, which is a mere mapping between object ids and their data.
     pub fn detach(self) -> IdMap<T> {
         self.map