adapt to changes in gix-date and gix-actor

Author: Byron

examples/log.rs

@@ -150,7 +150,7 @@ fn run(args: Args) -> anyhow::Result<()> {
                         commit_ref.author.actor().write_to(&mut buf)?;
                         buf.into()
                     },
-                    time: gix_date::Time::from_bytes(commit_ref.author.time)?.format(format::DEFAULT),
+                    time: commit_ref.author.time()?.format(format::DEFAULT),
                     message: commit_ref.message.to_owned(),
                 })
             }),

gitoxide-core/src/query/engine/command.rs

@@ -76,9 +76,7 @@ impl query::Engine {
                             usize,
                         ) = row?;
                         let id = gix::ObjectId::from(hash);
-                        let commit_time = gix_date::Time::from_bytes(
-                            id.attach(&self.repo).object()?.into_commit().committer()?.time,
-                        )?;
+                        let commit_time = id.attach(&self.repo).object()?.into_commit().committer()?.time()?;
                         let mode = FileMode::from_usize(mode).context("invalid file mode")?;
                         info.push(trace_path::Info {
                             id,

gix-actor/tests/signature/mod.rs

@@ -65,10 +65,7 @@ fn round_trip() -> Result<(), Box<dyn std::error::Error>> {
     ];
 
     for input in DEFAULTS {
-        let signature: Signature = gix_actor::SignatureRef::from_bytes::<()>(input)
-            .unwrap()
-            .try_into()
-            .unwrap();
+        let signature: Signature = gix_actor::SignatureRef::from_bytes::<()>(input).unwrap().into();
         let mut output = Vec::new();
         signature.write_to(&mut output)?;
         assert_eq!(output.as_bstr(), input.as_bstr());
@@ -95,7 +92,7 @@ fn parse_timestamp_with_trailing_digits() {
         SignatureRef {
             name: "first last".into(),
             email: "[email protected]".into(),
-            time: "1312735823 +051800".into(),
+            time: "1312735823 +051800",
         }
     );
 
@@ -106,7 +103,7 @@ fn parse_timestamp_with_trailing_digits() {
         SignatureRef {
             name: "first last".into(),
             email: "[email protected]".into(),
-            time: "1312735823 +0518".into(),
+            time: "1312735823 +0518",
         }
     );
 }
@@ -120,7 +117,7 @@ fn parse_missing_timestamp() {
         SignatureRef {
             name: "first last".into(),
             email: "[email protected]".into(),
-            time: "".into(),
+            time: ""
         }
     );
 }

gix-date/src/parse.rs

@@ -36,7 +36,7 @@ impl TimeBuf {
     }
 
     /// Clear the previous content.
-    pub fn clear(&mut self) {
+    fn clear(&mut self) {
         self.buf.clear();
     }
 }

gix-mailmap/src/snapshot/mod.rs

@@ -138,7 +138,11 @@ impl Snapshot {
     ///
     /// Note that this method will always allocate.
     pub fn resolve(&self, signature: gix_actor::SignatureRef<'_>) -> gix_actor::Signature {
-        self.try_resolve(signature).unwrap_or_else(|| signature.to_owned())
+        self.try_resolve(signature).unwrap_or_else(|| gix_actor::Signature {
+            name: signature.name.to_owned(),
+            email: signature.email.to_owned(),
+            time: signature.time().unwrap_or_default(),
+        })
     }
 
     /// Like [`try_resolve()`][Snapshot::try_resolve()], but always returns a special copy-on-write signature, which contains
@@ -157,17 +161,17 @@ fn enriched_signature<'a>(
         (Some(new_email), Some(new_name)) => Signature {
             email: new_email.to_owned().into(),
             name: new_name.to_owned().into(),
-            time: gix_date::Time::from_bytes(time).unwrap_or_default(),
+            time: time.parse().unwrap_or_default(),
         },
         (Some(new_email), None) => Signature {
             email: new_email.to_owned().into(),
             name: name.into(),
-            time: gix_date::Time::from_bytes(time).unwrap_or_default(),
+            time: time.parse().unwrap_or_default(),
         },
         (None, Some(new_name)) => Signature {
             email: email.into(),
             name: new_name.to_owned().into(),
-            time: gix_date::Time::from_bytes(time).unwrap_or_default(),
+            time: time.parse().unwrap_or_default(),
         },
         (None, None) => unreachable!("BUG: ResolvedSignatures don't exist here when nothing is set"),
     }

gix-mailmap/src/snapshot/signature.rs

@@ -29,7 +29,7 @@ impl<'a> From<gix_actor::SignatureRef<'a>> for Signature<'a> {
         Signature {
             name: s.name.into(),
             email: s.email.into(),
-            time: gix_date::Time::from_bytes(s.time).unwrap_or_default(),
+            time: s.time.parse().unwrap_or_default(),
         }
     }
 }

gix-mailmap/tests/snapshot/mod.rs

@@ -1,67 +1,59 @@
+use gix_date::parse::TimeBuf;
 use gix_mailmap::{Entry, Snapshot};
 use gix_testtools::fixture_bytes;
 
 #[test]
 fn try_resolve() {
     let snapshot = Snapshot::from_bytes(&fixture_bytes("typical.txt"));
-    let mut buf = Vec::with_capacity(64);
+    let mut buf = TimeBuf::default();
     assert_eq!(
         snapshot.try_resolve(signature("Foo", "[email protected]").to_ref(&mut buf)),
         Some(signature("Joe R. Developer", "[email protected]")),
         "resolved signatures contain all original fields, and normalize the email as well to match the one that it was looked up with"
     );
-    buf.clear();
     assert_eq!(
         snapshot.try_resolve(signature("Joe", "[email protected]").to_ref(&mut buf)),
         Some(signature("Joe R. Developer", "[email protected]")),
         "name and email can be mapped specifically"
     );
 
-    buf.clear();
     assert_eq!(
         snapshot.try_resolve(signature("Jane", "jane@laptop.(none)").to_ref(&mut buf)),
         Some(signature("Jane Doe", "[email protected]")),
         "fix name and email by email"
     );
-    buf.clear();
     assert_eq!(
         snapshot.try_resolve(signature("Jane", "jane@desktop.(none)").to_ref(&mut buf)),
         Some(signature("Jane Doe", "[email protected]")),
         "fix name and email by other email"
     );
 
-    buf.clear();
     assert_eq!(
         snapshot.try_resolve(signature("janE", "[email protected]").to_ref(&mut buf)),
         Some(signature("Jane Doe", "[email protected]")),
         "name and email can be mapped specifically, case insensitive matching of name"
     );
-    buf.clear();
     assert_eq!(
         snapshot.resolve(signature("janE", "jane@ipad.(none)").to_ref(&mut buf)),
         signature("janE", "[email protected]"),
         "an email can be mapped by name and email specifically, both match case-insensitively"
     );
 
     let sig = signature("Jane", "[email protected]");
-    buf.clear();
     assert_eq!(snapshot.try_resolve(sig.to_ref(&mut buf)), None, "unmatched email");
 
-    buf.clear();
     assert_eq!(
         snapshot.resolve(sig.to_ref(&mut buf)),
         sig,
         "resolution always works here, returning a copy of the original"
     );
 
     let sig = signature("Jean", "[email protected]");
-    buf.clear();
     assert_eq!(
         snapshot.try_resolve(sig.to_ref(&mut buf)),
         None,
         "matched email, unmatched name"
     );
-    buf.clear();
     assert_eq!(snapshot.resolve(sig.to_ref(&mut buf)), sig);
 
     assert_eq!(
@@ -95,17 +87,15 @@ fn non_name_and_name_mappings_will_not_clash() {
             "old-email",
         ),
     ];
-    let mut buf = Vec::with_capacity(64);
+    let mut buf = TimeBuf::default();
     for entries in [entries.clone().into_iter().rev().collect::<Vec<_>>(), entries] {
         let snapshot = Snapshot::new(entries);
 
-        buf.clear();
         assert_eq!(
             snapshot.try_resolve(signature("replace-by-email", "Old-Email").to_ref(&mut buf)),
             Some(signature("new-name", "old-email")),
             "it can match by email only, and the email is normalized"
         );
-        buf.clear();
         assert_eq!(
             snapshot.try_resolve(signature("old-name", "Old-Email").to_ref(&mut buf)),
             Some(signature("other-new-name", "other-new-email")),
@@ -130,28 +120,25 @@ fn non_name_and_name_mappings_will_not_clash() {
 #[test]
 fn overwrite_entries() {
     let snapshot = Snapshot::from_bytes(&fixture_bytes("overwrite.txt"));
-    let mut buf = Vec::with_capacity(64);
+    let mut buf = TimeBuf::default();
     assert_eq!(
         snapshot.try_resolve(signature("does not matter", "old-a-email").to_ref(&mut buf)),
         Some(signature("A-overwritten", "old-a-email")),
         "email only by email"
     );
 
-    buf.clear();
     assert_eq!(
         snapshot.try_resolve(signature("to be replaced", "old-b-EMAIL").to_ref(&mut buf)),
         Some(signature("B-overwritten", "new-b-email-overwritten")),
         "name and email by email"
     );
 
-    buf.clear();
     assert_eq!(
         snapshot.try_resolve(signature("old-c", "old-C-email").to_ref(&mut buf)),
         Some(signature("C-overwritten", "new-c-email-overwritten")),
         "name and email by name and email"
     );
 
-    buf.clear();
     assert_eq!(
         snapshot.try_resolve(signature("unchanged", "old-d-email").to_ref(&mut buf)),
         Some(signature("unchanged", "new-d-email-overwritten")),
@@ -178,6 +165,6 @@ fn signature(name: &str, email: &str) -> gix_actor::Signature {
     gix_actor::Signature {
         name: name.into(),
         email: email.into(),
-        time: gix_date::parse_raw("42 +0800").unwrap(),
+        time: gix_date::parse_header("42 +0800").unwrap(),
     }
 }

gix-object/src/commit/mod.rs

@@ -110,9 +110,14 @@ impl<'a> CommitRef<'a> {
         MessageRef::from_bytes(self.message)
     }
 
-    /// Returns the time at which this commit was created.
+    /// Returns the time at which this commit was created, or a default time if it could not be parsed.
     pub fn time(&self) -> gix_date::Time {
-        gix_date::Time::from_bytes(self.committer.time).expect("Time from Git should be valid")
+        self.committer.time.parse().unwrap_or_default()
+    }
+
+    /// Returns the time at which this commit was created.
+    pub fn try_time(&self) -> Result<gix_date::Time, gix_date::parse::Error> {
+        self.committer.time.parse()
     }
 }
 

gix-object/src/commit/write.rs

@@ -11,9 +11,8 @@ impl crate::WriteTo for Commit {
         for parent in &self.parents {
             encode::trusted_header_id(b"parent", parent, &mut out)?;
         }
-        let mut buf = Vec::with_capacity(64);
+        let mut buf = gix_date::parse::TimeBuf::default();
         encode::trusted_header_signature(b"author", &self.author.to_ref(&mut buf), &mut out)?;
-        buf.clear();
         encode::trusted_header_signature(b"committer", &self.committer.to_ref(&mut buf), &mut out)?;
         if let Some(encoding) = self.encoding.as_ref() {
             encode::header_field(b"encoding", encoding, &mut out)?;

gix-object/src/tag/write.rs

@@ -1,8 +1,8 @@
 use std::io;
 
-use bstr::BStr;
-
 use crate::{encode, encode::NL, Kind, Tag, TagRef};
+use bstr::BStr;
+use gix_date::parse::TimeBuf;
 
 /// An Error used in [`Tag::write_to()`][crate::WriteTo::write_to()].
 #[derive(Debug, thiserror::Error)]
@@ -26,7 +26,7 @@ impl crate::WriteTo for Tag {
         encode::trusted_header_field(b"type", self.target_kind.as_bytes(), out)?;
         encode::header_field(b"tag", validated_name(self.name.as_ref())?, out)?;
         if let Some(tagger) = &self.tagger {
-            let mut buf = Vec::with_capacity(64);
+            let mut buf = TimeBuf::default();
             encode::trusted_header_signature(b"tagger", &tagger.to_ref(&mut buf), out)?;
         }