[git-odb] refactor

Author: Byron

experiments/diffing/src/main.rs

@@ -53,7 +53,7 @@ fn main() -> anyhow::Result<()> {
         d.push("objects");
         d
     };
-    let db = git_odb::store::linked::Db::at(&repo_objects_dir)?;
+    let db = git_odb::linked::Store::at(&repo_objects_dir)?;
 
     let start = Instant::now();
     let all_commits = commit::Ancestors::new(Some(commit_id), commit::ancestors::State::default(), |oid, buf| {
@@ -83,7 +83,7 @@ fn main() -> anyhow::Result<()> {
         oid: &oid,
         buf: &'b mut Vec<u8>,
         obj_cache: &mut memory_lru::MemoryLruCache<ObjectId, ObjectInfo>,
-        db: &git_odb::store::linked::Db,
+        db: &git_odb::linked::Store,
         pack_cache: &mut impl git_odb::pack::cache::DecodeEntry,
     ) -> Option<git_odb::data::Object<'b>> {
         let oid = oid.to_owned();

experiments/object-access/src/main.rs

@@ -31,7 +31,7 @@ fn main() -> anyhow::Result<()> {
     };
 
     let hashes = {
-        let db = git_odb::store::linked::Db::at(&repo_objects_dir)?;
+        let db = git_odb::linked::Store::at(&repo_objects_dir)?;
         let start = Instant::now();
         let hashes = db.iter().collect::<Result<Vec<_>, _>>()?;
         let elapsed = start.elapsed();
@@ -174,7 +174,7 @@ fn do_gitoxide<C>(hashes: &[ObjectId], objects_dir: &Path, new_cache: impl FnOnc
 where
     C: git_odb::pack::cache::DecodeEntry,
 {
-    let odb = git_odb::store::linked::Db::at(objects_dir)?;
+    let odb = git_odb::linked::Store::at(objects_dir)?;
     let mut buf = Vec::new();
     let mut bytes = 0u64;
     let mut cache = new_cache();
@@ -194,7 +194,7 @@ where
     C: git_odb::pack::cache::DecodeEntry,
 {
     use rayon::prelude::*;
-    let odb = git_odb::store::linked::Db::at(objects_dir)?;
+    let odb = git_odb::linked::Store::at(objects_dir)?;
     let bytes = std::sync::atomic::AtomicU64::default();
     hashes.par_iter().try_for_each_init::<_, _, _, anyhow::Result<_>>(
         || (Vec::new(), new_cache()),

experiments/traversal/src/main.rs

@@ -47,7 +47,7 @@ fn main() -> anyhow::Result<()> {
         d.push("objects");
         d
     };
-    let db = git_odb::store::linked::Db::at(&repo_objects_dir)?;
+    let db = git_odb::linked::Store::at(&repo_objects_dir)?;
 
     let start = Instant::now();
     let all_commits = commit::Ancestors::new(Some(commit_id), commit::ancestors::State::default(), |oid, buf| {
@@ -155,7 +155,7 @@ fn main() -> anyhow::Result<()> {
 
 fn do_gitoxide_commit_graph_traversal<C>(
     tip: ObjectId,
-    db: &git_odb::store::linked::Db,
+    db: &git_odb::linked::Store,
     new_cache: impl FnOnce() -> C,
 ) -> anyhow::Result<usize>
 where
@@ -181,7 +181,7 @@ enum Computation {
 
 fn do_gitoxide_tree_dag_traversal<C>(
     commits: &[ObjectId],
-    db: &git_odb::store::linked::Db,
+    db: &git_odb::linked::Store,
     new_cache: impl Fn() -> C + Sync + Send,
     mode: Computation,
 ) -> anyhow::Result<(usize, u64)>

git-diff/tests/visit/mod.rs

@@ -3,15 +3,15 @@ mod changes {
         use git_diff::tree::{recorder, recorder::Change::*};
         use git_hash::{oid, ObjectId};
         use git_object::{bstr::ByteSlice, immutable, tree::EntryMode};
-        use git_odb::store::linked;
+        use git_odb::linked;
         use git_odb::{pack, Find};
 
         use crate::hex_to_id;
 
         type Changes = Vec<recorder::Change>;
 
-        fn db(args: impl IntoIterator<Item = &'static str>) -> crate::Result<linked::Db> {
-            linked::Db::at(
+        fn db(args: impl IntoIterator<Item = &'static str>) -> crate::Result<linked::Store> {
+            linked::Store::at(
                 git_testtools::scripted_fixture_repo_read_only_with_args("make_diff_repo.sh", args)?
                     .join(".git")
                     .join("objects"),
@@ -20,7 +20,7 @@ mod changes {
         }
 
         fn locate_tree_by_commit<'a>(
-            db: &linked::Db,
+            db: &linked::Store,
             commit: &oid,
             buf: &'a mut Vec<u8>,
         ) -> crate::Result<immutable::TreeIter<'a>> {
@@ -39,7 +39,7 @@ mod changes {
                 .expect("id to be a tree"))
         }
 
-        fn diff_commits(db: &linked::Db, lhs: impl Into<Option<ObjectId>>, rhs: &oid) -> crate::Result<Changes> {
+        fn diff_commits(db: &linked::Store, lhs: impl Into<Option<ObjectId>>, rhs: &oid) -> crate::Result<Changes> {
             let mut buf = Vec::new();
             let lhs_tree = lhs
                 .into()
@@ -61,7 +61,7 @@ mod changes {
             Ok(recorder.records)
         }
 
-        fn diff_with_previous_commit_from(db: &linked::Db, commit_id: &oid) -> crate::Result<Changes> {
+        fn diff_with_previous_commit_from(db: &linked::Store, commit_id: &oid) -> crate::Result<Changes> {
             let mut buf = Vec::new();
             let (main_tree_id, parent_commit_id) = {
                 let commit = db
@@ -107,7 +107,7 @@ mod changes {
             Ok(recorder.records)
         }
 
-        fn head_of(db: &linked::Db) -> ObjectId {
+        fn head_of(db: &linked::Store) -> ObjectId {
             ObjectId::from_hex(
                 &std::fs::read(
                     db.dbs[0]
@@ -126,7 +126,7 @@ mod changes {
             .expect("valid hex id")
         }
 
-        fn all_commits(db: &linked::Db) -> Vec<ObjectId> {
+        fn all_commits(db: &linked::Store) -> Vec<ObjectId> {
             use git_traverse::commit;
 
             let head = head_of(db);

git-odb/src/lib.rs

@@ -6,23 +6,20 @@
 //!
 //! There are various flavours of object databases, all of which supporting iteration, reading and possibly writing.
 //!
-//! * [`store::loose::Backend`]
+//! * [`loose::Store`]
 //!   * A database storing one object per file, named by its hash, using zlib compression.
 //!   * O(1) reads and writes, bound by IO operations per second
-//! * [`pack::Bundle`]
-//!   * A database storing multiple objects within an indexed pack file, reaching compression ratios of 60 to 1 or more.
-//!   * Slow writes and fast reads
-//! * [`store::compound::Backend`]
-//!   * A database using a [`store::loose::Backend`] for writes and multiple [`pack::Bundle`]s for object reading. It can also refer to multiple
-//!     additional [`store::compound::Backend`] instances using git-alternates.
+//! * [`compound::Store`]
+//!   * A database using a [`loose::Store`] for writes and multiple [`pack::Bundle`]s for object reading. It can also refer to multiple
+//!     additional [`compound::Store`] instances using git-alternates.
 //!   * This is the database closely resembling the object database in a git repository, and probably what most people would want to use.
-//! * [`store::linked::Db`]
-//!   * A database containing various [`compound::Backends`][store::compound::Backend] as gathered from `alternates` files.
+//! * [linked::Store`]
+//!   * A database containing various [`compound::Stores`][compound::Store] as gathered from `alternates` files.
 pub use git_pack as pack;
 pub use pack::{data, Find, FindExt};
 
-///
-pub mod store;
+mod store;
+pub use store::*;
 
 pub mod alternate;
 ///

git-odb/src/store/compound/find.rs

@@ -4,7 +4,7 @@ use crate::{
 };
 use git_pack::data;
 
-/// Returned by [`compound::Backend::find()`]
+/// Returned by [`compound::Store::find()`]
 #[derive(thiserror::Error, Debug)]
 #[allow(missing_docs)]
 pub enum Error {
@@ -20,7 +20,7 @@ pub(crate) struct PackLocation {
     pub entry_index: u32,
 }
 
-impl compound::Backend {
+impl compound::Store {
     /// Find an object as identified by [`ObjectId`][git_hash::ObjectId] and store its data in full in the provided `buffer`.
     /// This will search the object in all contained object databases.
     /// Use a `pack_cache` to accelerate pack access by reducing the amount of work duplication, or [`pack::cache::Never`] to disable any caching.
@@ -44,7 +44,7 @@ impl compound::Backend {
     }
 
     /// Internal-use function to look up a packed object index or loose object.
-    /// Used to avoid double-lookups in linked::Db::locate.
+    /// Used to avoid double-lookups in linked::Store::locate.
     /// (The polonius borrow-checker would support this via the locate
     /// function, so this can be [simplified](https://github.com/Byron/gitoxide/blob/0c5f4043da4615820cb180804a81c2d4fe75fe5e/git-odb/src/compound/locate.rs#L47)
     /// once polonius is stable.)
@@ -73,7 +73,7 @@ impl compound::Backend {
 }
 
 /// Special-use function to look up an object index. Used to avoid double-lookups in
-/// [compound::Backend::find()][crate::store::compound::Backend::find()]. (The polonius borrow-checker would support this via the 'find'
+/// [compound::Store::find()][crate::store::compound::Store::find()]. (The polonius borrow-checker would support this via the 'find'
 /// function, so this can be [simplified](https://github.com/Byron/gitoxide/blob/0c5f4043da4615820cb180804a81c2d4fe75fe5e/git-odb/src/compound/locate.rs#L47)
 /// once polonius is stable.)
 pub fn find_pack_index(bundle: &git_pack::Bundle, id: &git_hash::oid) -> Option<u32> {

git-odb/src/store/compound/init.rs

@@ -5,7 +5,7 @@ use crate::{
     store::{compound, loose},
 };
 
-/// Returned by [`compound::Backend::at()`]
+/// Returned by [`compound::Store::at()`]
 #[derive(thiserror::Error, Debug)]
 #[allow(missing_docs)]
 pub enum Error {
@@ -18,12 +18,12 @@ pub enum Error {
 }
 
 /// Instantiation
-impl compound::Backend {
+impl compound::Store {
     /// Returns a compound database as initialized from the given git `objects_directory`, commonly `.git/objects`.
     ///
-    /// Only loose and packed objects will be considered. See the [linked Db][crate::store::linked::Db] for a database with
+    /// Only loose and packed objects will be considered. See the [linked Db][crate::store::linked::Store] for a database with
     /// support for _git alternates_, i.e. linking to other repositories.
-    pub fn at(objects_directory: impl Into<PathBuf>) -> Result<compound::Backend, Error> {
+    pub fn at(objects_directory: impl Into<PathBuf>) -> Result<compound::Store, Error> {
         let loose_objects = objects_directory.into();
         if !loose_objects.is_dir() {
             return Err(Error::Inaccessible(loose_objects));
@@ -46,8 +46,8 @@ impl compound::Backend {
             Err(_) => Vec::new(),
         };
 
-        Ok(compound::Backend {
-            loose: loose::Backend::at(loose_objects),
+        Ok(compound::Store {
+            loose: loose::Store::at(loose_objects),
             bundles: packs,
         })
     }

git-odb/src/store/compound/mod.rs

@@ -9,9 +9,9 @@ mod write;
 
 /// An object database with tiered lookup packs and loose objects.
 /// This is a typical git database as used in git repositories, sans 'alternates'.
-pub struct Backend {
+pub struct Store {
     /// A loose object database into which new objects are written
-    pub loose: loose::Backend,
+    pub loose: loose::Store,
     /// All packs in the `objects/packs` directory
     pub bundles: Vec<pack::Bundle>,
 }

git-odb/src/store/compound/write.rs

@@ -3,7 +3,7 @@ use std::io::Read;
 use crate::store::{compound, loose};
 use git_object::{mutable, Kind};
 
-impl crate::write::Write for compound::Backend {
+impl crate::write::Write for compound::Store {
     type Error = loose::write::Error;
 
     fn write(&self, object: &mutable::Object, hash: git_hash::Kind) -> Result<git_hash::ObjectId, Self::Error> {

git-odb/src/store/linked/find.rs

@@ -8,7 +8,7 @@ use crate::{
 };
 use git_pack::{data::Object, find::PackEntry};
 
-impl crate::Find for linked::Db {
+impl crate::Find for linked::Store {
     type Error = compound::find::Error;
 
     fn find<'a>(
@@ -86,7 +86,7 @@ impl crate::Find for linked::Db {
     }
 }
 
-impl crate::Find for &linked::Db {
+impl crate::Find for &linked::Store {
     type Error = compound::find::Error;
 
     fn find<'a>(

git-odb/src/store/linked/init.rs

@@ -3,7 +3,7 @@ use std::path::PathBuf;
 use crate::alternate;
 use crate::store::{compound, linked};
 
-/// The error returned by [`linked::Db::at()`]
+/// The error returned by [`linked::Store::at()`]
 #[derive(Debug, thiserror::Error)]
 #[allow(missing_docs)]
 pub enum Error {
@@ -13,27 +13,27 @@ pub enum Error {
     AlternateResolve(#[from] alternate::Error),
 }
 
-impl linked::Db {
+impl linked::Store {
     /// Instantiate an instance at the given `objects_directory`, commonly `.git/objects`.
     ///
-    /// _git alternate_ files will be traversed to build a chain of [`compound::Backend`] instances.
+    /// _git alternate_ files will be traversed to build a chain of [`compound::Store`] instances.
     pub fn at(objects_directory: impl Into<PathBuf>) -> Result<Self, Error> {
-        let mut dbs = vec![compound::Backend::at(objects_directory.into())?];
+        let mut dbs = vec![compound::Store::at(objects_directory.into())?];
         for object_path in alternate::resolve(dbs[0].loose.path.clone())?.into_iter() {
-            dbs.push(compound::Backend::at(object_path)?);
+            dbs.push(compound::Store::at(object_path)?);
         }
         assert!(
             !dbs.is_empty(),
             "we can rely on at least one compound database to be present"
         );
-        Ok(linked::Db { dbs })
+        Ok(linked::Store { dbs })
     }
 }
 
-impl std::convert::TryFrom<PathBuf> for linked::Db {
+impl std::convert::TryFrom<PathBuf> for linked::Store {
     type Error = Error;
 
     fn try_from(value: PathBuf) -> Result<Self, Self::Error> {
-        linked::Db::at(value)
+        linked::Store::at(value)
     }
 }

git-odb/src/store/linked/iter.rs

@@ -28,7 +28,7 @@ pub struct AllObjects<Db> {
 
 impl<Db> AllObjects<Db>
 where
-    Db: Borrow<linked::Db>,
+    Db: Borrow<linked::Store>,
 {
     /// Create a new iterator from a linked database
     pub fn new(db: Db) -> Self {
@@ -38,7 +38,7 @@ where
                 .borrow()
                 .dbs
                 .get(db_index)
-                .expect("at least one db or no linked::Db at all");
+                .expect("at least one db or no linked::Store at all");
             if db.bundles.is_empty() {
                 DbState::Loose { iter: db.loose.iter() }
             } else {
@@ -51,7 +51,7 @@ where
 
 impl<Db> Iterator for AllObjects<Db>
 where
-    Db: Borrow<linked::Db>,
+    Db: Borrow<linked::Store>,
 {
     type Item = Result<ObjectId, loose::iter::Error>;
 
@@ -108,18 +108,18 @@ where
     }
 }
 
-impl linked::Db {
+impl linked::Store {
     /// Return an iterator over all objects in all linked databases, database after database, first packed
     /// objects with the 'best' packs first, followed by loose objects.
     /// For specialized iterations, use the `dbs` fields directly as all databases are accessible.
-    pub fn iter(&self) -> AllObjects<&linked::Db> {
+    pub fn iter(&self) -> AllObjects<&linked::Store> {
         AllObjects::new(self)
     }
 
-    /// Like [`iter()`][linked::Db::iter()] but works with this instance living in an [`Arc`]
+    /// Like [`iter()`][linked::Store::iter()] but works with this instance living in an [`Arc`]
     ///
     /// Useful in conjunction with `'static threads`.
-    pub fn arc_iter(self: &Arc<linked::Db>) -> AllObjects<Arc<linked::Db>> {
+    pub fn arc_iter(self: &Arc<linked::Store>) -> AllObjects<Arc<linked::Store>> {
         AllObjects::new(Arc::clone(&self))
     }
 }

git-odb/src/store/linked/mod.rs

@@ -1,12 +1,12 @@
-//! An object database representing a list of [compound databases][compound::Backend] commonly created using _git alternates_.
+//! An object database representing a list of [compound databases][compound::Store] commonly created using _git alternates_.
 use crate::store::compound;
 
-/// A database with a list of [compound databases][compound::Backend] created by traversing git `alternates` files.
+/// A database with a list of [compound databases][compound::Store] created by traversing git `alternates` files.
 ///
 /// It does not contain any objects itself.
-pub struct Db {
+pub struct Store {
     /// The compound databases containing the actual objects.
-    pub dbs: Vec<compound::Backend>,
+    pub dbs: Vec<compound::Store>,
 }
 
 ///

git-odb/src/store/linked/write.rs

@@ -3,7 +3,7 @@ use std::io::Read;
 
 use crate::store::{linked, loose};
 
-impl crate::write::Write for linked::Db {
+impl crate::write::Write for linked::Store {
     type Error = loose::write::Error;
 
     fn write(&self, object: &mutable::Object, hash: git_hash::Kind) -> Result<git_hash::ObjectId, Self::Error> {