Remove re-export of git_object::borrowed::Id (#63)

Author: Byron

DEVELOPMENT.md

@@ -51,7 +51,7 @@
     * **this is optional but desirable if…**
       * …there is no leakage otherwise to support user interfaces. They background long-running operations and need them to be cancellable.
 
-* **prepare for SHA256 support by using `owned::Id` and `borrowed::Id`**
+* **prepare for SHA256 support by using `owned::Id` and `git_hash::borrowed::Id`**
   * eventually there will be the need to support both Sha1 and Sha256. We anticipate it by using the `Id` type instead 
     of slices or arrays of 20 bytes. This way, eventually we can support multiple hash digest sizes.
   * Right now it's unclear how Sha256 is going to work in git, so we only support Sha1 for now. It might be an avenue to proactively

git-commitgraph/src/file/access.rs

@@ -1,6 +1,6 @@
 use crate::file::{self, commit::Commit, File, COMMIT_DATA_ENTRY_SIZE};
 use git_hash::SIZE_OF_SHA1_DIGEST as SHA1_SIZE;
-use git_object::{borrowed, HashKind};
+use git_object::HashKind;
 use std::{
     convert::{TryFrom, TryInto},
     fmt::{Debug, Formatter},
@@ -35,7 +35,7 @@ impl File {
     /// Returns 20 bytes sha1 at the given index in our list of (sorted) sha1 hashes.
     /// The position ranges from 0 to self.num_commits()
     // copied from git-odb/src/pack/index/access.rs
-    pub fn id_at(&self, pos: file::Position) -> borrowed::Id<'_> {
+    pub fn id_at(&self, pos: file::Position) -> git_hash::borrowed::Id<'_> {
         assert!(
             pos.0 < self.num_commits(),
             "expected lexigraphical position less than {}, got {}",
@@ -47,16 +47,16 @@ impl File {
             .try_into()
             .expect("an architecture able to hold 32 bits of integer");
         let start = self.oid_lookup_offset + (pos * SHA1_SIZE);
-        borrowed::Id::try_from(&self.data[start..start + SHA1_SIZE]).expect("20 bytes SHA1 to be alright")
+        git_hash::borrowed::Id::try_from(&self.data[start..start + SHA1_SIZE]).expect("20 bytes SHA1 to be alright")
     }
 
     /// Return an iterator over all object hashes stored in the base graph.
-    pub fn iter_base_graph_ids(&self) -> impl Iterator<Item = borrowed::Id<'_>> {
+    pub fn iter_base_graph_ids(&self) -> impl Iterator<Item = git_hash::borrowed::Id<'_>> {
         let start = self.base_graphs_list_offset.unwrap_or(0);
         let base_graphs_list = &self.data[start..start + (SHA1_SIZE * usize::from(self.base_graph_count))];
         base_graphs_list
             .chunks(SHA1_SIZE)
-            .map(|bytes| borrowed::Id::try_from(bytes).expect("20 bytes SHA1 to be alright"))
+            .map(|bytes| git_hash::borrowed::Id::try_from(bytes).expect("20 bytes SHA1 to be alright"))
     }
 
     /// return an iterator over all commits in this file.
@@ -65,13 +65,13 @@ impl File {
     }
 
     /// Return an iterator over all object hashes stored in this file.
-    pub fn iter_ids(&self) -> impl Iterator<Item = borrowed::Id<'_>> {
+    pub fn iter_ids(&self) -> impl Iterator<Item = git_hash::borrowed::Id<'_>> {
         (0..self.num_commits()).map(move |i| self.id_at(file::Position(i)))
     }
 
     /// Translate the given object hash to its position within this file, if present.
     // copied from git-odb/src/pack/index/access.rs
-    pub fn lookup(&self, id: borrowed::Id<'_>) -> Option<file::Position> {
+    pub fn lookup(&self, id: git_hash::borrowed::Id<'_>) -> Option<file::Position> {
         let first_byte = usize::from(id.first_byte());
         let mut upper_bound = self.fan[first_byte];
         let mut lower_bound = if first_byte != 0 { self.fan[first_byte - 1] } else { 0 };

git-commitgraph/src/file/commit.rs

@@ -5,7 +5,7 @@ use crate::{
 };
 use byteorder::{BigEndian, ByteOrder};
 use git_hash::SIZE_OF_SHA1_DIGEST as SHA1_SIZE;
-use git_object::{borrowed, owned};
+use git_object::owned;
 use std::{
     convert::{TryFrom, TryInto},
     fmt::{Debug, Formatter},
@@ -40,7 +40,7 @@ pub struct Commit<'a> {
     generation: u32,
     parent1: ParentEdge,
     parent2: ParentEdge,
-    root_tree_id: borrowed::Id<'a>,
+    root_tree_id: git_hash::borrowed::Id<'a>,
 }
 
 impl<'a> Commit<'a> {
@@ -49,7 +49,7 @@ impl<'a> Commit<'a> {
         Commit {
             file,
             pos,
-            root_tree_id: borrowed::Id::try_from(&bytes[..SHA1_SIZE]).expect("20 bytes SHA1 to be alright"),
+            root_tree_id: git_hash::borrowed::Id::try_from(&bytes[..SHA1_SIZE]).expect("20 bytes SHA1 to be alright"),
             parent1: ParentEdge::from_raw(BigEndian::read_u32(&bytes[SHA1_SIZE..SHA1_SIZE + 4])),
             parent2: ParentEdge::from_raw(BigEndian::read_u32(&bytes[SHA1_SIZE + 4..SHA1_SIZE + 8])),
             generation: BigEndian::read_u32(&bytes[SHA1_SIZE + 8..SHA1_SIZE + 12]) >> 2,
@@ -84,7 +84,7 @@ impl<'a> Commit<'a> {
     }
 
     /// Returns the hash of this commit.
-    pub fn id(&self) -> borrowed::Id<'a> {
+    pub fn id(&self) -> git_hash::borrowed::Id<'a> {
         self.file.id_at(self.pos)
     }
 
@@ -99,7 +99,7 @@ impl<'a> Commit<'a> {
     }
 
     /// Return the hash of the tree this commit points to.
-    pub fn root_tree_id(&self) -> borrowed::Id<'a> {
+    pub fn root_tree_id(&self) -> git_hash::borrowed::Id<'a> {
         self.root_tree_id
     }
 }

git-commitgraph/src/file/verify.rs

@@ -5,7 +5,7 @@ use crate::{
 };
 use bstr::ByteSlice;
 use git_hash::SIZE_OF_SHA1_DIGEST as SHA1_SIZE;
-use git_object::{borrowed, owned};
+use git_object::owned;
 use std::{
     cmp::{max, min},
     collections::HashMap,
@@ -58,8 +58,9 @@ pub struct Outcome {
 /// Verification
 impl File {
     /// Returns the trailing checksum over the entire content of this file.
-    pub fn checksum(&self) -> borrowed::Id<'_> {
-        borrowed::Id::try_from(&self.data[self.data.len() - SHA1_SIZE..]).expect("file to be large enough for a hash")
+    pub fn checksum(&self) -> git_hash::borrowed::Id<'_> {
+        git_hash::borrowed::Id::try_from(&self.data[self.data.len() - SHA1_SIZE..])
+            .expect("file to be large enough for a hash")
     }
 
     /// Traverse all [commits][file::Commit] stored in this file and call `processor(commit) -> Result<(), Error>` on it.
@@ -74,7 +75,7 @@ impl File {
             .map_err(|(actual, expected)| Error::Mismatch { actual, expected })?;
         verify_split_chain_filename_hash(&self.path, self.checksum()).map_err(Error::Filename)?;
 
-        let null_id = borrowed::Id::null_sha1();
+        let null_id = git_hash::borrowed::Id::null_sha1();
 
         let mut stats = Outcome {
             max_generation: 0,
@@ -85,7 +86,7 @@ impl File {
         };
 
         // TODO: Verify self.fan values as we go.
-        let mut prev_id: borrowed::Id<'a> = null_id;
+        let mut prev_id: git_hash::borrowed::Id<'a> = null_id;
         for commit in self.iter_commits() {
             if commit.id() <= prev_id {
                 if commit.id() == null_id {
@@ -157,7 +158,10 @@ impl File {
 
 /// If the given path's filename matches "graph-{hash}.graph", check that `hash` matches the
 /// expected hash.
-fn verify_split_chain_filename_hash(path: impl AsRef<Path>, expected: borrowed::Id<'_>) -> Result<(), String> {
+fn verify_split_chain_filename_hash(
+    path: impl AsRef<Path>,
+    expected: git_hash::borrowed::Id<'_>,
+) -> Result<(), String> {
     let path = path.as_ref();
     path.file_name()
         .and_then(|filename| filename.to_str())

git-commitgraph/src/graph/access.rs

@@ -2,7 +2,6 @@ use crate::{
     file::{self, Commit, File},
     graph::{self, Graph},
 };
-use git_object::borrowed;
 
 /// Access
 impl Graph {
@@ -16,7 +15,7 @@ impl Graph {
     }
 
     /// Returns the commit matching the given `id`.
-    pub fn commit_by_id(&self, id: borrowed::Id<'_>) -> Option<Commit<'_>> {
+    pub fn commit_by_id(&self, id: git_hash::borrowed::Id<'_>) -> Option<Commit<'_>> {
         let r = self.lookup_by_id(id)?;
         Some(r.file.commit_at(r.file_pos))
     }
@@ -25,7 +24,7 @@ impl Graph {
     ///
     /// # Panics
     /// If `pos` is greater or equal to [`num_commits()`][Graph::num_commits()].
-    pub fn id_at(&self, pos: graph::Position) -> borrowed::Id<'_> {
+    pub fn id_at(&self, pos: graph::Position) -> git_hash::borrowed::Id<'_> {
         let r = self.lookup_by_pos(pos);
         r.file.id_at(r.pos)
     }
@@ -36,12 +35,12 @@ impl Graph {
     }
 
     /// Iterate over commit IDs in unsorted order.
-    pub fn iter_ids(&self) -> impl Iterator<Item = borrowed::Id<'_>> {
+    pub fn iter_ids(&self) -> impl Iterator<Item = git_hash::borrowed::Id<'_>> {
         self.files.iter().flat_map(|file| file.iter_ids())
     }
 
     /// Translate the given `id` to its position in the file.
-    pub fn lookup(&self, id: borrowed::Id<'_>) -> Option<graph::Position> {
+    pub fn lookup(&self, id: git_hash::borrowed::Id<'_>) -> Option<graph::Position> {
         Some(self.lookup_by_id(id)?.graph_pos)
     }
 
@@ -53,7 +52,7 @@ impl Graph {
 
 /// Access fundamentals
 impl Graph {
-    pub(crate) fn lookup_by_id(&self, id: borrowed::Id<'_>) -> Option<LookupByIdResult<'_>> {
+    pub(crate) fn lookup_by_id(&self, id: git_hash::borrowed::Id<'_>) -> Option<LookupByIdResult<'_>> {
         let mut current_file_start = 0;
         for file in &self.files {
             if let Some(lex_pos) = file.lookup(id) {

git-commitgraph/tests/commitgraph.rs

@@ -88,19 +88,19 @@ pub struct RefInfo {
 }
 
 impl RefInfo {
-    pub fn id(&self) -> borrowed::Id {
+    pub fn id(&self) -> git_hash::borrowed::Id {
         self.id.to_borrowed()
     }
 
     pub fn pos(&self) -> GraphPosition {
         self.pos
     }
 
-    pub fn parent_ids(&self) -> impl IntoIterator<Item = borrowed::Id> {
+    pub fn parent_ids(&self) -> impl IntoIterator<Item = git_hash::borrowed::Id> {
         self.parent_ids.iter().map(|x| x.to_borrowed())
     }
 
-    pub fn root_tree_id(&self) -> borrowed::Id {
+    pub fn root_tree_id(&self) -> git_hash::borrowed::Id {
         self.root_tree_id.to_borrowed()
     }
 }
@@ -136,7 +136,7 @@ pub fn inspect_refs(repo_dir: impl AsRef<Path>, refs: &[&'static str]) -> HashMa
         .collect();
     infos.sort_by_key(|x| x.1);
 
-    let get_pos = |id: borrowed::Id| -> GraphPosition {
+    let get_pos = |id: git_hash::borrowed::Id| -> GraphPosition {
         let pos: u32 = infos
             .binary_search_by_key(&id, |x| x.1.to_borrowed())
             .expect("sorted_ids to contain id")

git-object/src/borrowed/mod.rs

@@ -6,8 +6,6 @@
 mod commit;
 pub use commit::Commit;
 
-pub use git_hash::borrowed::Id;
-
 mod tag;
 pub use tag::Tag;
 

git-object/src/borrowed/tree.rs

@@ -1,4 +1,4 @@
-use crate::{borrowed, borrowed::parse::SPACE, borrowed::Error, tree};
+use crate::{borrowed::parse::SPACE, borrowed::Error, tree};
 use bstr::{BStr, ByteSlice};
 use nom::{
     bytes::complete::{tag, take, take_while1, take_while_m_n},
@@ -29,7 +29,7 @@ pub struct Entry<'a> {
     pub filename: &'a BStr,
     /// The id of the object representing the entry.
     #[cfg_attr(feature = "serde1", serde(borrow))]
-    pub oid: borrowed::Id<'a>,
+    pub oid: git_hash::borrowed::Id<'a>,
 }
 
 impl<'a> Tree<'a> {
@@ -68,7 +68,7 @@ fn parse_entry(i: &[u8]) -> IResult<&[u8], Entry<'_>, Error> {
         Entry {
             mode,
             filename: filename.as_bstr(),
-            oid: borrowed::Id::try_from(oid).expect("we counted exactly 20 bytes"),
+            oid: git_hash::borrowed::Id::try_from(oid).expect("we counted exactly 20 bytes"),
         },
     ))
 }

git-object/tests/borrowed/tree.rs

@@ -1,7 +1,6 @@
 mod from_bytes {
     use crate::borrowed::fixture_bytes;
     use git_object::{
-        borrowed,
         borrowed::{tree::Entry, Tree},
         bstr::ByteSlice,
         tree,
@@ -12,7 +11,7 @@ mod from_bytes {
         <[u8; 20]>::from_hex(hex).expect("40 bytes hex sha")
     }
 
-    pub fn as_id(id: &[u8; 20]) -> borrowed::Id {
+    pub fn as_id(id: &[u8; 20]) -> git_hash::borrowed::Id {
         id.into()
     }
 

git-odb/src/borrowed.rs

@@ -44,7 +44,7 @@ pub mod verify {
         /// Compute the checksum of `self` and compare it with the `desired` hash.
         /// If the hashes do not match, an [`Error`] is returned, containing the actual
         /// hash of `self`.
-        pub fn verify_checksum(&self, desired: borrowed::Id<'_>) -> Result<(), Error> {
+        pub fn verify_checksum(&self, desired: git_hash::borrowed::Id<'_>) -> Result<(), Error> {
             let mut sink = hash::Write::new(io::sink(), desired.kind());
 
             loose::object::header::encode(self.kind, self.data.len() as u64, &mut sink).expect("hash to always work");