[pack #179] refactor bundle

Author: Byron

etc/check-package-size.sh

@@ -30,7 +30,7 @@ indent cargo diet -n --package-size-limit 25KB
 (enter git-validate && indent cargo diet -n --package-size-limit 5KB)
 (enter git-object && indent cargo diet -n --package-size-limit 20KB)
 (enter git-commitgraph && indent cargo diet -n --package-size-limit 15KB)
-(enter git-pack && indent cargo diet -n --package-size-limit 70KB)
+(enter git-pack && indent cargo diet -n --package-size-limit 75KB)
 (enter git-odb && indent cargo diet -n --package-size-limit 15KB)
 (enter git-protocol && indent cargo diet -n --package-size-limit 25KB)
 (enter git-packetline && indent cargo diet -n --package-size-limit 15KB)

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

@@ -12,7 +12,7 @@ pub enum Error {
     #[error("The objects directory at '{0}' is not an accessible directory")]
     Inaccessible(PathBuf),
     #[error(transparent)]
-    Pack(#[from] pack::bundle::Error),
+    Pack(#[from] pack::bundle::init::Error),
     #[error(transparent)]
     Alternate(#[from] Box<crate::alternate::Error>),
 }

git-pack/CHANGELOG.md

@@ -7,3 +7,8 @@
    - `Find::find_existing_*` -> `Find::find_*`
    - `Find::find_existing_*` -> `Find::find_*`
    - `Find::find()-> `Find::try_find()`
+   - `bundle::Bundle` -> `Bundle`
+   - `bundle::Error` -> `bundle::init::Error`
+ 
+* **new methods**
+   - `Find::find_tag_iter()`

git-pack/src/bundle/init.rs

@@ -0,0 +1,50 @@
+use crate::Bundle;
+use std::{
+    convert::TryFrom,
+    path::{Path, PathBuf},
+};
+
+/// Returned by [`Bundle::at()`]
+#[derive(thiserror::Error, Debug)]
+#[allow(missing_docs)]
+pub enum Error {
+    #[error("An 'idx' extension is expected of an index file: '{0}'")]
+    InvalidPath(PathBuf),
+    #[error(transparent)]
+    Pack(#[from] crate::data::header::decode::Error),
+    #[error(transparent)]
+    Index(#[from] crate::index::init::Error),
+}
+
+/// Initialization
+impl Bundle {
+    /// Create a `Bundle` from `path`, which is either a pack file _(*.pack)_ or an index file _(*.idx)_.
+    ///
+    /// The corresponding complementary file is expected to be present.
+    /// Also available via [`Bundle::try_from()`].
+    pub fn at(path: impl AsRef<Path>) -> Result<Self, Error> {
+        Self::try_from(path.as_ref())
+    }
+}
+
+impl TryFrom<&Path> for Bundle {
+    type Error = Error;
+
+    fn try_from(path: &Path) -> Result<Self, Self::Error> {
+        let ext = path
+            .extension()
+            .and_then(|e| e.to_str())
+            .ok_or_else(|| Error::InvalidPath(path.to_owned()))?;
+        Ok(match ext {
+            "idx" => Self {
+                index: crate::index::File::at(path)?,
+                pack: crate::data::File::at(path.with_extension("pack"))?,
+            },
+            "pack" => Self {
+                pack: crate::data::File::at(path)?,
+                index: crate::index::File::at(path.with_extension("idx"))?,
+            },
+            _ => return Err(Error::InvalidPath(path.to_owned())),
+        })
+    }
+}

git-pack/src/bundle/mod.rs

@@ -1,7 +1,26 @@
-use std::{
-    convert::TryFrom,
-    path::{Path, PathBuf},
-};
+/// A way to uniquely identify the location of an object within a pack bundle
+#[derive(PartialEq, Eq, Debug, Hash, Ord, PartialOrd, Clone)]
+#[cfg_attr(feature = "serde1", derive(serde::Serialize, serde::Deserialize))]
+pub struct Location {
+    /// The id of the pack containing the object //TODO: this should  probably at least by a typedef or even an opaque type
+    pub pack_id: u32,
+    /// The index at which the object can be found in the index file corresponding to the `pack_id`.
+    pub index_file_id: u32,
+    /// The size of the entry of disk so that the range of bytes of the entry is `pack_offset..pack_offset + entry_size`.
+    pub entry_size: usize,
+    /// The start of the entry in the pack identified by `pack_id`.
+    pub pack_offset: u64,
+}
+
+impl Location {
+    /// Compute a range suitable for lookup in pack data using the [`entry_slice()`][crate::data::File::entry_slice()] method.
+    pub fn entry_range(&self, pack_offset: u64) -> crate::data::EntryRange {
+        pack_offset..pack_offset + self.entry_size as u64
+    }
+}
+
+///
+pub mod init;
 
 mod find;
 ///
@@ -10,9 +29,10 @@ pub mod write;
 mod verify {
     use std::sync::{atomic::AtomicBool, Arc};
 
+    use crate::Bundle;
     use git_features::progress::Progress;
 
-    impl super::Bundle {
+    impl Bundle {
         /// Similar to [`crate::index::File::verify_integrity()`] but more convenient to call as the presence of the
         /// pack file is a given.
         pub fn verify_integrity<C, P>(
@@ -40,77 +60,3 @@ mod verify {
         }
     }
 }
-
-/// Returned by [`Bundle::at()`]
-#[derive(thiserror::Error, Debug)]
-#[allow(missing_docs)]
-pub enum Error {
-    #[error("An 'idx' extension is expected of an index file: '{0}'")]
-    InvalidPath(PathBuf),
-    #[error(transparent)]
-    Pack(#[from] crate::data::header::decode::Error),
-    #[error(transparent)]
-    Index(#[from] crate::index::init::Error),
-}
-
-/// A way to uniquely identify the location of an object within a pack bundle
-#[derive(PartialEq, Eq, Debug, Hash, Ord, PartialOrd, Clone)]
-#[cfg_attr(feature = "serde1", derive(serde::Serialize, serde::Deserialize))]
-pub struct Location {
-    /// The id of the pack containing the object //TODO: this should  probably at least by a typedef or even an opaque type
-    pub pack_id: u32,
-    /// The index at which the object can be found in the index file corresponding to the `pack_id`.
-    pub index_file_id: u32,
-    /// The size of the entry of disk so that the range of bytes of the entry is `pack_offset..pack_offset + entry_size`.
-    pub entry_size: usize,
-    /// The start of the entry in the pack identified by `pack_id`.
-    pub pack_offset: u64,
-}
-
-impl Location {
-    /// Compute a range suitable for lookup in pack data using the [`entry_slice()`][crate::data::File::entry_slice()] method.
-    pub fn entry_range(&self, pack_offset: u64) -> crate::data::EntryRange {
-        pack_offset..pack_offset + self.entry_size as u64
-    }
-}
-
-/// A bundle of pack data and the corresponding pack index
-pub struct Bundle {
-    /// The pack file corresponding to `index`
-    pub pack: crate::data::File,
-    /// The index file corresponding to `pack`
-    pub index: crate::index::File,
-}
-
-/// Initialization
-impl Bundle {
-    /// Create a `Bundle` from `path`, which is either a pack file _(*.pack)_ or an index file _(*.idx)_.
-    ///
-    /// The corresponding complementary file is expected to be present.
-    /// Also available via [`Bundle::try_from()`].
-    pub fn at(path: impl AsRef<Path>) -> Result<Self, Error> {
-        Self::try_from(path.as_ref())
-    }
-}
-
-impl TryFrom<&Path> for Bundle {
-    type Error = Error;
-
-    fn try_from(path: &Path) -> Result<Self, Self::Error> {
-        let ext = path
-            .extension()
-            .and_then(|e| e.to_str())
-            .ok_or_else(|| Error::InvalidPath(path.to_owned()))?;
-        Ok(match ext {
-            "idx" => Self {
-                index: crate::index::File::at(path)?,
-                pack: crate::data::File::at(path.with_extension("pack"))?,
-            },
-            "pack" => Self {
-                pack: crate::data::File::at(path)?,
-                index: crate::index::File::at(path.with_extension("idx"))?,
-            },
-            _ => return Err(Error::InvalidPath(path.to_owned())),
-        })
-    }
-}

git-pack/src/bundle/write/types.rs

@@ -43,7 +43,7 @@ pub struct Outcome {
 
 impl Outcome {
     /// Instantiate a bundle from the newly written index and data file that are represented by this `Outcome`
-    pub fn to_bundle(&self) -> Option<Result<crate::Bundle, crate::bundle::Error>> {
+    pub fn to_bundle(&self) -> Option<Result<crate::Bundle, crate::bundle::init::Error>> {
         self.index_path.as_ref().map(crate::Bundle::at)
     }
 }

git-pack/src/lib.rs

@@ -15,7 +15,13 @@
 
 ///
 pub mod bundle;
-pub use crate::bundle::Bundle;
+/// A bundle of pack data and the corresponding pack index
+pub struct Bundle {
+    /// The pack file corresponding to `index`
+    pub pack: crate::data::File,
+    /// The index file corresponding to `pack`
+    pub index: crate::index::File,
+}
 
 ///
 pub mod find;

git-pack/src/loose.rs

@@ -2,7 +2,10 @@
 pub mod object {
     ///
     pub mod header {
-        //! loose object header encoding and decoding
+        //! loose object header encoding and decoding.
+        //!
+        //! Note that these are still relevant for packs as they are part of the computed hash of any git object, packed or not.
+        //! It just so happened that loose objects where the first ones used for implementing an object database.
         use byteorder::WriteBytesExt;
         use git_object as object;
 

gitoxide-core/src/pack/receive.rs

@@ -301,15 +301,9 @@ fn receive_pack_blocking<W: io::Write>(
         index_kind: pack::index::Version::V2,
         iteration_mode: pack::data::input::Mode::Verify,
     };
-    let outcome = pack::bundle::Bundle::write_to_directory(
-        input,
-        directory.take(),
-        progress,
-        &ctx.should_interrupt,
-        None,
-        options,
-    )
-    .map_err(|err| io::Error::new(io::ErrorKind::Other, err))?;
+    let outcome =
+        pack::Bundle::write_to_directory(input, directory.take(), progress, &ctx.should_interrupt, None, options)
+            .map_err(|err| io::Error::new(io::ErrorKind::Other, err))?;
 
     if let Some(directory) = refs_directory.take() {
         write_raw_refs(refs, directory)?;