git-object refactor

cargo-smart-release/src/command/release/git.rs

@@ -6,10 +6,9 @@ use cargo_metadata::{
     camino::{Utf8Component, Utf8Path},
     Package,
 };
-use git_repository::easy::object;
+use git_repository::{easy::object, prelude::ReferenceAccessExt, refs};
 
 use super::{tag_name_for, utils::will, Context, Oid, Options};
-use git_repository::{prelude::ReferenceAccessExt, refs};
 
 fn is_top_level_package(manifest_path: &Utf8Path, shared: &git_repository::Easy) -> bool {
     manifest_path

experiments/diffing/src/main.rs

@@ -6,7 +6,7 @@ use git_repository::{
     diff,
     easy::object,
     hash::{oid, ObjectId},
-    objs::{bstr::BStr, immutable},
+    objs::{bstr::BStr, TreeRefIter},
     odb,
     prelude::*,
     refs::file::loose::reference::peel,
@@ -254,14 +254,14 @@ where
         }
     };
 
-    fn find_tree_iter<'b, L>(id: &oid, buf: &'b mut Vec<u8>, mut find: L) -> Option<immutable::TreeIter<'b>>
+    fn find_tree_iter<'b, L>(id: &oid, buf: &'b mut Vec<u8>, mut find: L) -> Option<TreeRefIter<'b>>
     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())
     }
 
-    fn tree_iter_by_commit<'b, L>(id: &oid, buf: &'b mut Vec<u8>, mut find: L) -> immutable::TreeIter<'b>
+    fn tree_iter_by_commit<'b, L>(id: &oid, buf: &'b mut Vec<u8>, mut find: L) -> TreeRefIter<'b>
     where
         L: for<'a> FnMut(&oid, &'a mut Vec<u8>) -> Option<odb::data::Object<'a>>,
     {

experiments/traversal/src/main.rs

@@ -7,7 +7,7 @@ use anyhow::anyhow;
 use dashmap::DashSet;
 use git_repository::{
     hash::ObjectId,
-    objs::{bstr::BStr, immutable::tree::Entry},
+    objs::{bstr::BStr, tree::EntryRef},
     odb,
     prelude::*,
     refs::file::loose::reference::peel,
@@ -186,7 +186,7 @@ where
                 fn push_back_tracked_path_component(&mut self, _component: &BStr) {}
                 fn push_path_component(&mut self, _component: &BStr) {}
                 fn pop_path_component(&mut self) {}
-                fn visit_tree(&mut self, entry: &Entry<'_>) -> Action {
+                fn visit_tree(&mut self, entry: &EntryRef<'_>) -> Action {
                     self.entries += 1;
                     let inserted = self.seen.insert(entry.oid.to_owned());
                     if !inserted {
@@ -195,7 +195,7 @@ where
                         tree::visit::Action::Continue
                     }
                 }
-                fn visit_nontree(&mut self, entry: &Entry<'_>) -> Action {
+                fn visit_nontree(&mut self, entry: &EntryRef<'_>) -> Action {
                     self.entries += 1;
                     self.seen.insert(entry.oid.to_owned());
                     tree::visit::Action::Continue
@@ -241,7 +241,7 @@ where
                 fn push_back_tracked_path_component(&mut self, _component: &BStr) {}
                 fn push_path_component(&mut self, _component: &BStr) {}
                 fn pop_path_component(&mut self) {}
-                fn visit_tree(&mut self, entry: &Entry<'_>) -> Action {
+                fn visit_tree(&mut self, entry: &EntryRef<'_>) -> Action {
                     self.entries += 1;
                     let inserted = self.seen.insert(entry.oid.to_owned());
                     if !inserted {
@@ -250,7 +250,7 @@ where
                         tree::visit::Action::Continue
                     }
                 }
-                fn visit_nontree(&mut self, entry: &Entry<'_>) -> Action {
+                fn visit_nontree(&mut self, entry: &EntryRef<'_>) -> Action {
                     self.entries += 1;
                     self.seen.insert(entry.oid.to_owned());
                     tree::visit::Action::Continue

git-actor/src/lib.rs

@@ -1,4 +1,4 @@
-//! This crate provides ways of identifying an actor within the git repository both in shared/signature_ref and mutable variants.
+//! This crate provides ways of identifying an actor within the git repository both in shared/mutable and mutable variants.
 #![forbid(unsafe_code)]
 #![deny(rust_2018_idioms, missing_docs)]
 use bstr::{BStr, BString};

git-actor/src/signature/mod.rs

@@ -41,7 +41,7 @@ mod convert {
     }
 
     impl Signature {
-        /// Borrow this instance as signature_ref
+        /// Borrow this instance as immutable
         pub fn to_ref(&self) -> SignatureRef<'_> {
             SignatureRef {
                 name: self.name.as_ref(),

git-config/src/file/git_config.rs

@@ -306,7 +306,7 @@ impl<'event> GitConfig<'event> {
             .map_err(|_| GitConfigError::FailedConversion)
     }
 
-    /// Returns an signature_ref section reference.
+    /// Returns an immutable section reference.
     ///
     /// # Errors
     ///

git-diff/Cargo.toml

@@ -15,7 +15,7 @@ doctest = false
 
 [dependencies]
 git-hash = { version = "^0.5.0", path = "../git-hash" }
-git-object = { version ="0.12.0", path = "../git-object" }
+git-object = { version ="^0.13.0", path = "../git-object" }
 quick-error = "2.0.0"
 
 [dev-dependencies]

git-diff/src/tree/changes.rs

@@ -1,7 +1,6 @@
 use std::{borrow::BorrowMut, collections::VecDeque};
 
 use git_hash::{oid, ObjectId};
-use git_object::immutable;
 use quick_error::quick_error;
 
 use crate::{
@@ -20,7 +19,7 @@ quick_error! {
         Cancelled {
             display("The delegate cancelled the operation")
         }
-        EntriesDecode(err: immutable::object::decode::Error) {
+        EntriesDecode(err: git_object::decode::Error) {
             display("tree entries could not be decoded.")
             from()
             source(err)
@@ -54,13 +53,13 @@ impl<'a> tree::Changes<'a> {
     /// [git_cmp_rs]: https://github.com/Byron/gitoxide/blob/a4d5f99c8dc99bf814790928a3bf9649cd99486b/git-object/src/mutable/tree.rs#L52-L55
     pub fn needed_to_obtain<FindFn, R, StateMut>(
         mut self,
-        other: immutable::TreeIter<'_>,
+        other: git_object::TreeRefIter<'_>,
         mut state: StateMut,
         mut find: FindFn,
         delegate: &mut R,
     ) -> Result<(), Error>
     where
-        FindFn: for<'b> FnMut(&oid, &'b mut Vec<u8>) -> Option<immutable::tree::TreeIter<'b>>,
+        FindFn: for<'b> FnMut(&oid, &'b mut Vec<u8>) -> Option<git_object::TreeRefIter<'b>>,
         R: tree::Visit,
         StateMut: BorrowMut<tree::State>,
     {
@@ -120,7 +119,7 @@ impl<'a> tree::Changes<'a> {
 }
 
 fn delete_entry_schedule_recursion<R: tree::Visit>(
-    entry: immutable::tree::Entry<'_>,
+    entry: git_object::tree::EntryRef<'_>,
     queue: &mut VecDeque<TreeInfoPair>,
     delegate: &mut R,
 ) -> Result<(), Error> {
@@ -143,7 +142,7 @@ fn delete_entry_schedule_recursion<R: tree::Visit>(
 }
 
 fn add_entry_schedule_recursion<R: tree::Visit>(
-    entry: immutable::tree::Entry<'_>,
+    entry: git_object::tree::EntryRef<'_>,
     queue: &mut VecDeque<TreeInfoPair>,
     delegate: &mut R,
 ) -> Result<(), Error> {
@@ -165,9 +164,9 @@ fn add_entry_schedule_recursion<R: tree::Visit>(
     Ok(())
 }
 fn catchup_rhs_with_lhs<R: tree::Visit>(
-    rhs_entries: &mut IteratorType<immutable::TreeIter<'_>>,
-    lhs: immutable::tree::Entry<'_>,
-    rhs: immutable::tree::Entry<'_>,
+    rhs_entries: &mut IteratorType<git_object::TreeRefIter<'_>>,
+    lhs: git_object::tree::EntryRef<'_>,
+    rhs: git_object::tree::EntryRef<'_>,
     queue: &mut VecDeque<TreeInfoPair>,
     delegate: &mut R,
 ) -> Result<(), Error> {
@@ -205,9 +204,9 @@ fn catchup_rhs_with_lhs<R: tree::Visit>(
 }
 
 fn catchup_lhs_with_rhs<R: tree::Visit>(
-    lhs_entries: &mut IteratorType<immutable::TreeIter<'_>>,
-    lhs: immutable::tree::Entry<'_>,
-    rhs: immutable::tree::Entry<'_>,
+    lhs_entries: &mut IteratorType<git_object::TreeRefIter<'_>>,
+    lhs: git_object::tree::EntryRef<'_>,
+    rhs: git_object::tree::EntryRef<'_>,
     queue: &mut VecDeque<TreeInfoPair>,
     delegate: &mut R,
 ) -> Result<(), Error> {
@@ -245,8 +244,8 @@ fn catchup_lhs_with_rhs<R: tree::Visit>(
 }
 
 fn handle_lhs_and_rhs_with_equal_filenames<R: tree::Visit>(
-    lhs: immutable::tree::Entry<'_>,
-    rhs: immutable::tree::Entry<'_>,
+    lhs: git_object::tree::EntryRef<'_>,
+    rhs: git_object::tree::EntryRef<'_>,
     queue: &mut VecDeque<TreeInfoPair>,
     delegate: &mut R,
 ) -> Result<(), Error> {

git-diff/src/tree/mod.rs

@@ -1,7 +1,7 @@
 use std::collections::VecDeque;
 
 use git_hash::ObjectId;
-use git_object::immutable;
+use git_object::TreeRefIter;
 
 /// The state required to visit [Changes] to be instantiated with `State::default()`.
 #[derive(Default, Clone)]
@@ -22,11 +22,11 @@ impl State {
 }
 
 /// An iterator over changes of a tree, instantiated using `Changes::from(…)`.
-pub struct Changes<'a>(Option<immutable::TreeIter<'a>>);
+pub struct Changes<'a>(Option<TreeRefIter<'a>>);
 
 impl<'a, T> From<T> for Changes<'a>
 where
-    T: Into<Option<immutable::TreeIter<'a>>>,
+    T: Into<Option<TreeRefIter<'a>>>,
 {
     fn from(v: T) -> Self {
         Changes(v.into())

git-diff/tests/visit/mod.rs

@@ -2,7 +2,7 @@ mod changes {
     mod to_obtain_tree {
         use git_diff::tree::{recorder, recorder::Change::*};
         use git_hash::{oid, ObjectId};
-        use git_object::{bstr::ByteSlice, immutable, tree::EntryMode};
+        use git_object::{bstr::ByteSlice, tree::EntryMode, TreeRefIter};
         use git_odb::{linked, pack, Find};
 
         use crate::hex_to_id;
@@ -22,7 +22,7 @@ mod changes {
             db: &linked::Store,
             commit: &oid,
             buf: &'a mut Vec<u8>,
-        ) -> crate::Result<immutable::TreeIter<'a>> {
+        ) -> crate::Result<TreeRefIter<'a>> {
             let tree_id = db
                 .find(commit, buf, &mut pack::cache::Never)?
                 .ok_or_else(|| format!("start commit {:?} to be present", commit))?

git-object/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "git-object"
-version = "0.12.2"
+version = "0.13.0"
 description = "Immutable and mutable git objects with decoding and encoding support"
 authors = ["Sebastian Thiel <sebastian.thiel@icloud.com>"]
 repository = "https://github.com/Byron/gitoxide"

git-object/src/blob.rs

@@ -0,0 +1,17 @@
+use std::{convert::Infallible, io};
+
+use crate::{Blob, BlobRef};
+
+impl Blob {
+    /// Write the blobs data to `out` verbatim.
+    pub fn write_to(&self, mut out: impl io::Write) -> io::Result<()> {
+        out.write_all(&self.data)
+    }
+}
+
+impl<'a> BlobRef<'a> {
+    /// Instantiate a `Blob` from the given `data`, which is used as-is.
+    pub fn from_bytes(data: &[u8]) -> Result<BlobRef<'_>, Infallible> {
+        Ok(BlobRef { data })
+    }
+}

git-object/src/immutable/commit/decode.rs → git-object/src/commit/decode.rs

@@ -10,10 +10,7 @@ use nom::{
 };
 use smallvec::SmallVec;
 
-use crate::{
-    immutable::{parse, parse::NL, Commit},
-    BStr, ByteSlice,
-};
+use crate::{parse, parse::NL, BStr, ByteSlice, CommitRef};
 
 pub fn message<'a, E: ParseError<&'a [u8]> + ContextError<&'a [u8]>>(i: &'a [u8]) -> IResult<&'a [u8], &'a BStr, E> {
     if i.is_empty() {
@@ -28,7 +25,9 @@ pub fn message<'a, E: ParseError<&'a [u8]> + ContextError<&'a [u8]>>(i: &'a [u8]
     Ok((&[], i.as_bstr()))
 }
 
-pub fn commit<'a, E: ParseError<&'a [u8]> + ContextError<&'a [u8]>>(i: &'a [u8]) -> IResult<&'a [u8], Commit<'_>, E> {
+pub fn commit<'a, E: ParseError<&'a [u8]> + ContextError<&'a [u8]>>(
+    i: &'a [u8],
+) -> IResult<&'a [u8], CommitRef<'_>, E> {
     let (i, tree) = context("tree <40 lowercase hex char>", |i| {
         parse::header_field(i, b"tree", parse::hex_hash)
     })(i)?;
@@ -59,7 +58,7 @@ pub fn commit<'a, E: ParseError<&'a [u8]> + ContextError<&'a [u8]>>(i: &'a [u8])
 
     Ok((
         i,
-        Commit {
+        CommitRef {
             tree,
             parents: SmallVec::from(parents),
             author,