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

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`.

Sebastian Thiel committed 4 years ago

Commit 59f67911 parent fa6bcde8 files · +21 −32Browse files

Unified · Split

8 files

git-index/src/access.rs +5 −0
git-index/src/decode/mod.rs +1 −0
git-index/src/file/write.rs +1 −1
git-index/src/init.rs +1 −0
git-index/src/lib.rs +4 −0
git-index/src/write.rs +3 −12
git-index/tests/index/file/init.rs +1 −4
git-index/tests/index/file/write.rs +5 −15

git-index/src/access.rs+5−0

         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

git-index/src/decode/mod.rs+1−0

@@ -209,6 +209,7 @@ impl State { · 208 unmodified lines
209		209
210	Ok((	210	Ok((
211	State {	211	State {
		212	object_hash,
212	timestamp,	213	timestamp,
213	version,	214	version,
214	entries,	215	entries,

git-index/src/file/write.rs+1−1

@@ -22,7 +22,7 @@ impl File { · 21 unmodified lines
22	mut out: impl std::io::Write,	22	mut out: impl std::io::Write,
23	options: write::Options,	23	options: write::Options,
24	) -> std::io::Result<(Version, git_hash::ObjectId)> {	24	) -> std::io::Result<(Version, git_hash::ObjectId)> {
25	let mut hasher = hash::Write::new(&mut out, options.hash_kind);	25	let mut hasher = hash::Write::new(&mut out, self.state.object_hash);
26	let version = self.state.write_to(&mut hasher, options)?;	26	let version = self.state.write_to(&mut hasher, options)?;
27		27
28	let hash = hasher.hash.digest();	28	let hash = hasher.hash.digest();

git-index/src/init.rs+1−0

@@ -37,6 +37,7 @@ mod from_tree { · 36 unmodified lines
37	entries.sort_by(\|a, b\| Entry::cmp_filepaths(a.path_in(&path_backing), b.path_in(&path_backing)));	37	entries.sort_by(\|a, b\| Entry::cmp_filepaths(a.path_in(&path_backing), b.path_in(&path_backing)));
38		38
39	Ok(State {	39	Ok(State {
		40	object_hash: tree.kind(),
40	timestamp: filetime::FileTime::now(),	41	timestamp: filetime::FileTime::now(),
41	version: Version::V2,	42	version: Version::V2,
42	entries,	43	entries,

git-index/src/lib.rs+4−0

 /// 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

git-index/src/write.rs+3−12

 /// 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(
+    pub fn write_to(&self, out: impl std::io::Write, Options { extensions }: Options) -> std::io::Result<Version> {
-        &self,
-        out: impl std::io::Write,
-        Options { hash_kind, extensions }: Options,
-    ) -> std::io::Result<Version> {
         let version = self.detect_required_version();
         let mut write = CountBytes::new(out);
                 .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)

git-index/tests/index/file/init.rs+1−4

             assert!(index.checksum().is_none());
             assert_eq!(index.path(), index_path);
-            index.write(git_index::write::Options {
+            index.write(git_index::write::Options::default())?;
-                hash_kind: git_hash::Kind::Sha1,
-                extensions: Default::default(),
-            })?;
             assert!(index.checksum().is_some(), "checksum is adjusted after writing");
             assert!(index.path().is_file());
             assert_eq!(index.version(), expected_version,);

git-index/tests/index/file/write.rs+5−15

         (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"), Default::default()),
-        (Generated("V2_empty"), sha1_options()),
+        (Generated("V2_empty"), Default::default()),
         (Generated("v2_more_files"), all_ext_but_eoie()),
         (Generated("v2_all_file_kinds"), all_ext_but_eoie()),
     ];
 #[test]
 fn state_comparisons_with_various_extension_configurations() {
     fn options_with(extensions: write::Extensions) -> Options {
-        Options {
+        Options { extensions }
-            hash_kind: git_hash::Kind::Sha1,
-            extensions,
-        }
     }
     for fixture in [
     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(())
             end_of_index_entry: false,
             tree_cache: true,
         },
-        ..sha1_options()
+        ..Default::default()
-    }
-}
-fn sha1_options() -> git_index::write::Options {
-    git_index::write::Options {
-        hash_kind: git_hash::Kind::Sha1,
-        extensions: Default::default(),
     }
 }