cleaner API for detaching objects, now for commits as well (#364)

Also: parent_ids() queryable directly on commit.

Author: Byron

git-repository/src/object/commit.rs

@@ -1,4 +1,4 @@
-use crate::{bstr::BStr, Commit, Tree};
+use crate::{bstr::BStr, Commit, DetachedObject, Tree};
 
 mod error {
     use crate::object;
@@ -18,8 +18,26 @@ mod error {
     }
 }
 
+use crate::id::Ancestors;
+
 pub use error::Error;
 
+impl<'repo> Commit<'repo> {
+    /// Create an owned instance of this object, copying our data in the process.
+    pub fn detached(&self) -> DetachedObject {
+        DetachedObject {
+            id: self.id,
+            kind: git_object::Kind::Commit,
+            data: self.data.clone(),
+        }
+    }
+
+    /// Sever the connection to the `Repository` and turn this instance into a standalone object.
+    pub fn detach(self) -> DetachedObject {
+        self.into()
+    }
+}
+
 impl<'repo> Commit<'repo> {
     /// Turn this objects id into a shortened id with a length in hex as configured by `core.abbrev`.
     pub fn short_id(&self) -> Result<git_hash::Prefix, crate::id::prefix::Error> {
@@ -51,6 +69,21 @@ impl<'repo> Commit<'repo> {
         git_object::CommitRef::from_bytes(&self.data)
     }
 
+    /// Return an iterator over tokens, representing this commit piece by piece.
+    pub fn iter(&self) -> git_object::CommitRefIter<'_> {
+        git_object::CommitRefIter::from_bytes(&self.data)
+    }
+
+    // TODO: tests
+    /// Decode this commits parent ids on the fly without allocating.
+    pub fn parent_ids(&self) -> impl Iterator<Item = crate::Id<'repo>> + '_ {
+        use crate::ext::ObjectIdExt;
+        let repo = self.repo;
+        git_object::CommitRefIter::from_bytes(&self.data)
+            .parent_ids()
+            .map(move |id| id.attach(repo))
+    }
+
     /// Parse the commit and return the the tree object it points to.
     pub fn tree(&self) -> Result<Tree<'repo>, Error> {
         let tree_id = self.tree_id().ok_or(Error::Decode)?;
@@ -64,4 +97,15 @@ impl<'repo> Commit<'repo> {
     pub fn tree_id(&self) -> Option<git_hash::ObjectId> {
         git_object::CommitRefIter::from_bytes(&self.data).tree_id()
     }
+
+    /// Return our id own id with connection to this repository.
+    pub fn id(&self) -> crate::Id<'repo> {
+        use crate::ext::ObjectIdExt;
+        self.id.attach(self.repo)
+    }
+
+    /// Obtain a platform for traversing ancestors of this commit.
+    pub fn ancestors(&self) -> Ancestors<'repo> {
+        self.id().ancestors()
+    }
 }

git-repository/src/object/impls.rs

@@ -9,18 +9,32 @@ impl<'repo> std::fmt::Debug for Object<'repo> {
 }
 
 impl<'repo> From<Object<'repo>> for DetachedObject {
-    fn from(r: Object<'repo>) -> Self {
-        r.into_owned()
+    fn from(mut v: Object<'repo>) -> Self {
+        DetachedObject {
+            id: v.id,
+            kind: v.kind,
+            data: std::mem::take(&mut v.data),
+        }
+    }
+}
+
+impl<'repo> From<Commit<'repo>> for DetachedObject {
+    fn from(mut v: Commit<'repo>) -> Self {
+        DetachedObject {
+            id: v.id,
+            kind: git_object::Kind::Commit,
+            data: std::mem::take(&mut v.data),
+        }
     }
 }
 
 impl<'repo> From<Commit<'repo>> for Object<'repo> {
-    fn from(mut r: Commit<'repo>) -> Self {
+    fn from(mut v: Commit<'repo>) -> Self {
         Object {
-            id: r.id,
+            id: v.id,
             kind: git_object::Kind::Commit,
-            data: steal_from_freelist(&mut r.data),
-            repo: r.repo,
+            data: steal_from_freelist(&mut v.data),
+            repo: v.repo,
         }
     }
 }

git-repository/src/object/mod.rs

@@ -94,26 +94,15 @@ impl<'repo> Object<'repo> {
 
 impl<'repo> Object<'repo> {
     /// Create an owned instance of this object, copying our data in the process.
-    pub fn to_owned(&self) -> DetachedObject {
+    pub fn detached(&self) -> DetachedObject {
         DetachedObject {
             id: self.id,
             kind: self.kind,
             data: self.data.clone(),
         }
     }
 
-    /// Turn this instance into an owned one, copying our data in the process.
-    pub fn into_owned(mut self) -> DetachedObject {
-        DetachedObject {
-            id: self.id,
-            kind: self.kind,
-            data: std::mem::take(&mut self.data),
-        }
-    }
-
-    /// Sever the connection to `Easy` and turn this instance into a standalone object.
-    ///
-    /// Note that the data buffer will be copied in the process.
+    /// Sever the connection to the `Repository` and turn this instance into a standalone object.
     pub fn detach(self) -> DetachedObject {
         self.into()
     }