change!: write::Options::object_hash is now implied by the State itself.

Byron · Byron · commit 59f679126aba · 2022-10-12T16:08:35.000+08:00
The `State`, once initialized, knows the kind of object hash it uses and
there is no need to specify it again.

This affects some method signatures which now work without
`object_hash`.
diff --git a/git-index/src/access.rs b/git-index/src/access.rs
@@ -9,6 +9,11 @@ impl State {
         self.version
     }
 
+    /// Return the kind of hashes used in this instance.
+    pub fn object_hash(&self) -> git_hash::Kind {
+        self.object_hash
+    }
+
     /// Return our entries
     pub fn entries(&self) -> &[Entry] {
         &self.entries
diff --git a/git-index/src/decode/mod.rs b/git-index/src/decode/mod.rs
@@ -209,6 +209,7 @@ impl State {
 
         Ok((
             State {
+                object_hash,
                 timestamp,
                 version,
                 entries,
diff --git a/git-index/src/file/write.rs b/git-index/src/file/write.rs
@@ -22,7 +22,7 @@ impl File {
         mut out: impl std::io::Write,
         options: write::Options,
     ) -> std::io::Result<(Version, git_hash::ObjectId)> {
-        let mut hasher = hash::Write::new(&mut out, options.hash_kind);
+        let mut hasher = hash::Write::new(&mut out, self.state.object_hash);
         let version = self.state.write_to(&mut hasher, options)?;
 
         let hash = hasher.hash.digest();
diff --git a/git-index/src/init.rs b/git-index/src/init.rs
@@ -37,6 +37,7 @@ mod from_tree {
             entries.sort_by(|a, b| Entry::cmp_filepaths(a.path_in(&path_backing), b.path_in(&path_backing)));
 
             Ok(State {
+                object_hash: tree.kind(),
                 timestamp: filetime::FileTime::now(),
                 version: Version::V2,
                 entries,
diff --git a/git-index/src/lib.rs b/git-index/src/lib.rs
@@ -81,6 +81,10 @@ pub type PathStorageRef = [u8];
 /// We treat index and its state synonymous.
 #[derive(Clone)]
 pub struct State {
+    /// The kind of object hash used when storing the underlying file.
+    ///
+    /// Empty states for example won't have a single object id, so deduction of the hash used isn't always possible.
+    object_hash: git_hash::Kind,
     /// The time at which the state was created, indicating its freshness compared to other files on disk.
     ///
     /// Note that on platforms that only have a precisions of a second for this time, we will treat all entries with the
diff --git a/git-index/src/write.rs b/git-index/src/write.rs
@@ -46,24 +46,15 @@ impl Extensions {
 /// The options for use when [writing an index][State::write_to()].
 ///
 /// Note that default options write either index V2 or V3 depending on the content of the entries.
-#[derive(Debug, Clone, Copy)]
+#[derive(Debug, Default, Clone, Copy)]
 pub struct Options {
-    /// The hash kind to use when writing the index file.
-    ///
-    /// It is not always possible to infer the hash kind when reading an index, so this is required.
-    pub hash_kind: git_hash::Kind,
-
     /// Configures which extensions to write
     pub extensions: Extensions,
 }
 
 impl State {
     /// Serialize this instance to `out` with [`options`][Options].
-    pub fn write_to(
-        &self,
-        out: impl std::io::Write,
-        Options { hash_kind, extensions }: Options,
-    ) -> std::io::Result<Version> {
+    pub fn write_to(&self, out: impl std::io::Write, Options { extensions }: Options) -> std::io::Result<Version> {
         let version = self.detect_required_version();
 
         let mut write = CountBytes::new(out);
@@ -83,7 +74,7 @@ impl State {
                 .is_some()
             && !extension_toc.is_empty()
         {
-            extension::end_of_index_entry::write_to(out, hash_kind, offset_to_extensions, extension_toc)?
+            extension::end_of_index_entry::write_to(out, self.object_hash, offset_to_extensions, extension_toc)?
         }
 
         Ok(version)
diff --git a/git-index/tests/index/file/init.rs b/git-index/tests/index/file/init.rs
@@ -23,10 +23,7 @@ mod from_state {
             assert!(index.checksum().is_none());
             assert_eq!(index.path(), index_path);
 
-            index.write(git_index::write::Options {
-                hash_kind: git_hash::Kind::Sha1,
-                extensions: Default::default(),
-            })?;
+            index.write(git_index::write::Options::default())?;
             assert!(index.checksum().is_some(), "checksum is adjusted after writing");
             assert!(index.path().is_file());
             assert_eq!(index.version(), expected_version,);
diff --git a/git-index/tests/index/file/write.rs b/git-index/tests/index/file/write.rs
@@ -11,8 +11,8 @@ fn roundtrips() -> crate::Result {
         (Loose("extended-flags"), all_ext_but_eoie()),
         (Loose("conflicting-file"), all_ext_but_eoie()),
         (Loose("very-long-path"), all_ext_but_eoie()),
-        (Generated("v2"), sha1_options()),
-        (Generated("V2_empty"), sha1_options()),
+        (Generated("v2"), Default::default()),
+        (Generated("V2_empty"), Default::default()),
         (Generated("v2_more_files"), all_ext_but_eoie()),
         (Generated("v2_all_file_kinds"), all_ext_but_eoie()),
     ];
@@ -44,10 +44,7 @@ fn roundtrips() -> crate::Result {
 #[test]
 fn state_comparisons_with_various_extension_configurations() {
     fn options_with(extensions: write::Extensions) -> Options {
-        Options {
-            hash_kind: git_hash::Kind::Sha1,
-            extensions,
-        }
+        Options { extensions }
     }
 
     for fixture in [
@@ -98,7 +95,7 @@ fn extended_flags_automatically_upgrade_the_version_to_avoid_data_loss() -> crat
     expected.entries_mut()[0].flags.insert(entry::Flags::EXTENDED);
 
     let mut buf = Vec::new();
-    let (actual_version, _digest) = expected.write_to(&mut buf, sha1_options())?;
+    let (actual_version, _digest) = expected.write_to(&mut buf, Default::default())?;
     assert_eq!(actual_version, Version::V3, "extended flags need V3");
 
     Ok(())
@@ -158,13 +155,6 @@ fn all_ext_but_eoie() -> Options {
             end_of_index_entry: false,
             tree_cache: true,
         },
-        ..sha1_options()
-    }
-}
-
-fn sha1_options() -> git_index::write::Options {
-    git_index::write::Options {
-        hash_kind: git_hash::Kind::Sha1,
-        extensions: Default::default(),
+        ..Default::default()
     }
 }
