fix!: make Time::to_zoned() fallible and add Time::format_or_raw().

Byron · Byron · commit fda4e40c043f · 2025-11-03T08:57:30.000+01:00
After all, the timezone can be invalid, which makes the conversion (and formatting) fail.
The `format_or_raw()` method brings back an infallible version.
diff --git a/gix-date/src/time/format.rs b/gix-date/src/time/format.rs
@@ -36,25 +36,31 @@ impl Time {
     ///
     /// Use [`Format::Unix`], [`Format::Raw`] or one of the custom formats
     /// defined in the [`format`](mod@crate::time::format) submodule.
-    pub fn format(&self, format: impl Into<Format>) -> String {
+    ///
+    /// Note that this can fail if the timezone isn't valid and the format requires a conversion to [`jiff::Zoned`].
+    pub fn format(&self, format: impl Into<Format>) -> Result<String, jiff::Error> {
         self.format_inner(format.into())
     }
 
-    fn format_inner(&self, format: Format) -> String {
-        match format {
-            Format::Custom(CustomFormat(format)) => self.to_zoned().strftime(format).to_string(),
+    /// Like [`Self::format()`], but on time conversion error, produce the [RAW] format instead to make it
+    /// infallible.
+    pub fn format_or_raw(&self, format: impl Into<Format>) -> String {
+        self.format_inner(format.into()).unwrap_or_else(|_| self.to_string())
+    }
+
+    fn format_inner(&self, format: Format) -> Result<String, jiff::Error> {
+        Ok(match format {
+            Format::Custom(CustomFormat(format)) => self.to_zoned()?.strftime(format).to_string(),
             Format::Unix => self.seconds.to_string(),
             Format::Raw => self.to_string(),
-        }
+        })
     }
 }
 
 impl Time {
     /// Produce a `Zoned` time for complex time computations and limitless formatting.
-    pub fn to_zoned(self) -> jiff::Zoned {
-        let offset = jiff::tz::Offset::from_seconds(self.offset).expect("valid offset");
-        jiff::Timestamp::from_second(self.seconds)
-            .expect("always valid unix time")
-            .to_zoned(offset.to_time_zone())
+    pub fn to_zoned(self) -> Result<jiff::Zoned, jiff::Error> {
+        let offset = jiff::tz::Offset::from_seconds(self.offset)?;
+        Ok(jiff::Timestamp::from_second(self.seconds)?.to_zoned(offset.to_time_zone()))
     }
 }
diff --git a/gix-date/tests/time/baseline.rs b/gix-date/tests/time/baseline.rs
@@ -66,15 +66,17 @@ fn parse_compare_format() {
                 "{pattern:?} disagrees with baseline seconds since epoch: {actual:?}"
             );
             if let Some(format_name) = format_name {
-                let reformatted = t.format(match format_name.as_str() {
-                    "RFC2822" => Format::Custom(format::RFC2822),
-                    "ISO8601" => Format::Custom(format::ISO8601),
-                    "ISO8601_STRICT" => Format::Custom(format::ISO8601_STRICT),
-                    "GITOXIDE" => Format::Custom(format::GITOXIDE),
-                    "UNIX" => Format::Unix,
-                    "RAW" => Format::Raw,
-                    unknown => unreachable!("All formats should be well-known and implemented: {unknown:?}"),
-                });
+                let reformatted = t
+                    .format(match format_name.as_str() {
+                        "RFC2822" => Format::Custom(format::RFC2822),
+                        "ISO8601" => Format::Custom(format::ISO8601),
+                        "ISO8601_STRICT" => Format::Custom(format::ISO8601_STRICT),
+                        "GITOXIDE" => Format::Custom(format::GITOXIDE),
+                        "UNIX" => Format::Unix,
+                        "RAW" => Format::Raw,
+                        unknown => unreachable!("All formats should be well-known and implemented: {unknown:?}"),
+                    })
+                    .expect("valid input time");
                 assert_eq!(
                     reformatted, *pattern,
                     "{reformatted:?} disagrees with baseline pattern: {pattern:?}"
diff --git a/gix-date/tests/time/format.rs b/gix-date/tests/time/format.rs
@@ -4,19 +4,21 @@ use gix_date::{
 };
 
 #[test]
-fn short() {
-    assert_eq!(time().format(format::SHORT), "1973-11-30");
+fn short() -> gix_testtools::Result {
+    assert_eq!(time().format(format::SHORT)?, "1973-11-30");
+    Ok(())
 }
 
 #[test]
-fn unix() {
+fn unix() -> gix_testtools::Result {
     let expected = "123456789";
-    assert_eq!(time().format(Format::Unix), expected);
-    assert_eq!(time().format(format::UNIX), expected);
+    assert_eq!(time().format(Format::Unix)?, expected);
+    assert_eq!(time().format(format::UNIX)?, expected);
+    Ok(())
 }
 
 #[test]
-fn raw() {
+fn raw() -> gix_testtools::Result {
     for (time, expected) in [
         (time(), "123456789 +0230"),
         (
@@ -27,58 +29,65 @@ fn raw() {
             "1112911993 +0100",
         ),
     ] {
-        assert_eq!(time.format(Format::Raw), expected);
-        assert_eq!(time.format(format::RAW), expected);
+        assert_eq!(time.format(Format::Raw)?, expected);
+        assert_eq!(time.format(format::RAW)?, expected);
     }
+    Ok(())
 }
 
 #[test]
-fn iso8601() {
-    assert_eq!(time().format(format::ISO8601), "1973-11-30 00:03:09 +0230");
+fn iso8601() -> gix_testtools::Result {
+    assert_eq!(time().format(format::ISO8601)?, "1973-11-30 00:03:09 +0230");
+    Ok(())
 }
 
 #[test]
-fn iso8601_strict() {
-    assert_eq!(time().format(format::ISO8601_STRICT), "1973-11-30T00:03:09+02:30");
+fn iso8601_strict() -> gix_testtools::Result {
+    assert_eq!(time().format(format::ISO8601_STRICT)?, "1973-11-30T00:03:09+02:30");
+    Ok(())
 }
 
 #[test]
-fn rfc2822() {
-    assert_eq!(time().format(format::RFC2822), "Fri, 30 Nov 1973 00:03:09 +0230");
-    assert_eq!(time_dec1().format(format::RFC2822), "Sat, 01 Dec 1973 00:03:09 +0230");
+fn rfc2822() -> gix_testtools::Result {
+    assert_eq!(time().format(format::RFC2822)?, "Fri, 30 Nov 1973 00:03:09 +0230");
+    assert_eq!(time_dec1().format(format::RFC2822)?, "Sat, 01 Dec 1973 00:03:09 +0230");
+    Ok(())
 }
 
 #[test]
-fn git_rfc2822() {
-    assert_eq!(time().format(format::GIT_RFC2822), "Fri, 30 Nov 1973 00:03:09 +0230");
+fn git_rfc2822() -> gix_testtools::Result {
+    assert_eq!(time().format(format::GIT_RFC2822)?, "Fri, 30 Nov 1973 00:03:09 +0230");
     assert_eq!(
-        time_dec1().format(format::GIT_RFC2822),
+        time_dec1().format(format::GIT_RFC2822)?,
         "Sat, 1 Dec 1973 00:03:09 +0230"
     );
+    Ok(())
 }
 
 #[test]
-fn default() {
+fn default() -> gix_testtools::Result {
     assert_eq!(
-        time().format(gix_date::time::format::GITOXIDE),
+        time().format(gix_date::time::format::GITOXIDE)?,
         "Fri Nov 30 1973 00:03:09 +0230"
     );
     assert_eq!(
-        time_dec1().format(gix_date::time::format::GITOXIDE),
+        time_dec1().format(gix_date::time::format::GITOXIDE)?,
         "Sat Dec 01 1973 00:03:09 +0230"
     );
+    Ok(())
 }
 
 #[test]
-fn git_default() {
+fn git_default() -> gix_testtools::Result {
     assert_eq!(
-        time().format(gix_date::time::format::DEFAULT),
+        time().format(gix_date::time::format::DEFAULT)?,
         "Fri Nov 30 00:03:09 1973 +0230"
     );
     assert_eq!(
-        time_dec1().format(gix_date::time::format::DEFAULT),
+        time_dec1().format(gix_date::time::format::DEFAULT)?,
         "Sat Dec 1 00:03:09 1973 +0230"
     );
+    Ok(())
 }
 
 fn time() -> Time {
