Merge branch 'ag/jiff'

Author: Byron

Diff for: .github/workflows/msrv.yml

@@ -19,8 +19,9 @@ jobs:
           - ubuntu-latest
     runs-on: ${{ matrix.os }}
     env:
-      # dictated by `firefox` to support the `helix` editor, but now driven by the `time` crate. IMPORTANT: adjust etc/msrv-badge.svg as well
-      rust_version: 1.67.0
+      # dictated by `firefox` to support the `helix` editor, but now probably effectively be controlled by `jiff`, which also aligns with `regex`.
+      # IMPORTANT: adjust etc/msrv-badge.svg as well
+      rust_version: 1.70.0
     steps:
       - uses: actions/checkout@v4
       - uses: extractions/setup-just@v2

Diff for: Cargo.lock

@@ -164,14 +164,12 @@ http-client-reqwest = ["gix/blocking-http-transport-reqwest-rust-tls"]
 ## Use async client networking.
 gitoxide-core-async-client = ["gitoxide-core/async-client", "futures-lite"]
 
-
 [dependencies]
 anyhow = "1.0.42"
 
 gitoxide-core = { version = "^0.39.1", path = "gitoxide-core" }
 gix-features = { version = "^0.38.2", path = "gix-features" }
 gix = { version = "^0.64.0", path = "gix", default-features = false }
-time = "0.3.23"
 
 clap = { version = "4.1.1", features = ["derive", "cargo"] }
 clap_complete = "4.4.3"

Diff for: Cargo.toml

@@ -18,7 +18,7 @@ doctest = false
 serde = ["dep:serde", "bstr/serde", "gix-date/serde"]
 
 [dependencies]
-gix-date = { version = "^0.8.7", path = "../gix-date" }
+gix-date = { version = "^0.9.0", path = "../gix-date" }
 gix-utils = { version = "^0.1.11", path = "../gix-utils" }
 
 thiserror = "1.0.38"

Diff for: etc/msrv-badge.svg

@@ -21,18 +21,18 @@ tar = ["dep:tar", "dep:gix-path"]
 tar_gz = ["tar", "dep:flate2"]
 
 ## Enable the `zip` archive format.
-zip = ["dep:zip", "dep:time"]
+zip = ["dep:zip"]
 
 
 [dependencies]
 gix-worktree-stream = { version = "^0.13.1", path = "../gix-worktree-stream" }
 gix-object = { version = "^0.42.3", path = "../gix-object" }
 gix-path = { version = "^0.10.9", path = "../gix-path", optional = true }
-gix-date = { version = "^0.8.7", path = "../gix-date" }
+gix-date = { version = "^0.9.0", path = "../gix-date" }
 
 flate2 = { version = "1.0.26", optional = true }
-zip = { version = "2.1.0", optional = true, default-features = false, features = ["deflate", "time"] }
-time = { version = "0.3.23", optional = true, default-features = false, features = ["std"] }
+zip = { version = "2.1.0", optional = true, default-features = false, features = ["deflate"] }
+jiff = { version = "0.1.2", default-features = false, features = ["std"] }
 
 thiserror = "1.0.26"
 bstr = { version = "1.5.0", default-features = false }

Diff for: gix-actor/Cargo.toml

@@ -134,10 +134,22 @@ where
     {
         let mut ar = zip::write::ZipWriter::new(out);
         let mut buf = Vec::new();
-        let mtime = time::OffsetDateTime::from_unix_timestamp(opts.modification_time)
+        let zdt = jiff::Timestamp::from_second(opts.modification_time)
             .map_err(|err| Error::InvalidModificationTime(Box::new(err)))?
-            .try_into()
-            .map_err(|err| Error::InvalidModificationTime(Box::new(err)))?;
+            .to_zoned(jiff::tz::TimeZone::UTC);
+        let mtime = zip::DateTime::from_date_and_time(
+            zdt.year()
+                .try_into()
+                .map_err(|err| Error::InvalidModificationTime(Box::new(err)))?,
+            // These are all OK because month, day, hour, minute and second
+            // are always positive.
+            zdt.month().try_into().expect("non-negative"),
+            zdt.day().try_into().expect("non-negative"),
+            zdt.hour().try_into().expect("non-negative"),
+            zdt.minute().try_into().expect("non-negative"),
+            zdt.second().try_into().expect("non-negative"),
+        )
+        .map_err(|err| Error::InvalidModificationTime(Box::new(err)))?;
         while let Some(entry) = next_entry(stream)? {
             append_zip_entry(
                 &mut ar,

Diff for: gix-archive/Cargo.toml

@@ -1,32 +1,32 @@
 [package]
 name = "gix-date"
-version = "0.8.7"
+version = "0.9.0"
 repository = "https://github.com/Byron/gitoxide"
 license = "MIT OR Apache-2.0"
 description = "A crate of the gitoxide project parsing dates the way git does"
 authors = ["Sebastian Thiel <sebastian.thiel@icloud.com>"]
 edition = "2021"
 include = ["src/**/*", "LICENSE-*"]
-rust-version = "1.65"
+rust-version = "1.70"
 
 [lib]
 doctest = false
 
 [features]
 ## Data structures implement `serde::Serialize` and `serde::Deserialize`.
-serde= ["dep:serde", "bstr/serde"]
+serde = ["dep:serde", "bstr/serde"]
 
 [dependencies]
-bstr = { version = "1.3.0", default-features = false, features = ["std"]}
-serde = { version = "1.0.114", optional = true, default-features = false, features = ["derive"]}
+bstr = { version = "1.3.0", default-features = false, features = ["std"] }
+serde = { version = "1.0.114", optional = true, default-features = false, features = ["derive"] }
 itoa = "1.0.1"
-time = { version = "0.3.23", default-features = false, features = ["local-offset", "formatting", "macros", "parsing"] }
+jiff = "0.1.1"
 thiserror = "1.0.32"
 
 document-features = { version = "0.2.0", optional = true }
 
 [dev-dependencies]
-gix-testtools = { path = "../tests/tools"}
+gix-testtools = { path = "../tests/tools" }
 once_cell = "1.12.0"
 gix-hash = { path = "../gix-hash" }
 

Diff for: gix-archive/src/write.rs

@@ -14,7 +14,7 @@ pub enum Error {
 pub(crate) mod function {
     use std::{str::FromStr, time::SystemTime};
 
-    use time::{format_description::well_known, Date, OffsetDateTime};
+    use jiff::{civil::Date, fmt::rfc2822, tz::TimeZone, Zoned};
 
     use crate::{
         parse::{relative, Error},
@@ -32,27 +32,27 @@ pub(crate) mod function {
             return Ok(Time::new(42, 1800));
         }
 
-        Ok(if let Ok(val) = Date::parse(input, SHORT) {
-            let val = val.with_hms(0, 0, 0).expect("date is in range").assume_utc();
-            Time::new(val.unix_timestamp(), val.offset().whole_seconds())
-        } else if let Ok(val) = OffsetDateTime::parse(input, &well_known::Rfc2822) {
-            Time::new(val.unix_timestamp(), val.offset().whole_seconds())
-        } else if let Ok(val) = OffsetDateTime::parse(input, ISO8601) {
-            Time::new(val.unix_timestamp(), val.offset().whole_seconds())
-        } else if let Ok(val) = OffsetDateTime::parse(input, ISO8601_STRICT) {
-            Time::new(val.unix_timestamp(), val.offset().whole_seconds())
-        } else if let Ok(val) = OffsetDateTime::parse(input, GITOXIDE) {
-            Time::new(val.unix_timestamp(), val.offset().whole_seconds())
-        } else if let Ok(val) = OffsetDateTime::parse(input, DEFAULT) {
-            Time::new(val.unix_timestamp(), val.offset().whole_seconds())
+        Ok(if let Ok(val) = Date::strptime(SHORT.0, input) {
+            let val = val.to_zoned(TimeZone::UTC).expect("date is in range");
+            Time::new(val.timestamp().as_second(), val.offset().seconds())
+        } else if let Ok(val) = rfc2822_relaxed(input) {
+            Time::new(val.timestamp().as_second(), val.offset().seconds())
+        } else if let Ok(val) = strptime_relaxed(ISO8601.0, input) {
+            Time::new(val.timestamp().as_second(), val.offset().seconds())
+        } else if let Ok(val) = strptime_relaxed(ISO8601_STRICT.0, input) {
+            Time::new(val.timestamp().as_second(), val.offset().seconds())
+        } else if let Ok(val) = strptime_relaxed(GITOXIDE.0, input) {
+            Time::new(val.timestamp().as_second(), val.offset().seconds())
+        } else if let Ok(val) = strptime_relaxed(DEFAULT.0, input) {
+            Time::new(val.timestamp().as_second(), val.offset().seconds())
         } else if let Ok(val) = SecondsSinceUnixEpoch::from_str(input) {
             // Format::Unix
             Time::new(val, 0)
         } else if let Some(val) = parse_raw(input) {
             // Format::Raw
             val
-        } else if let Some(time) = relative::parse(input, now).transpose()? {
-            Time::new(time.unix_timestamp(), time.offset().whole_seconds())
+        } else if let Some(val) = relative::parse(input, now).transpose()? {
+            Time::new(val.timestamp().as_second(), val.offset().seconds())
         } else {
             return Err(Error::InvalidDateString { input: input.into() });
         })
@@ -83,52 +83,79 @@ pub(crate) mod function {
         };
         Some(time)
     }
+
+    /// This is just like `Zoned::strptime`, but it allows parsing datetimes
+    /// whose weekdays are inconsistent with the date. While the day-of-week
+    /// still must be parsed, it is otherwise ignored. This seems to be
+    /// consistent with how `git` behaves.
+    fn strptime_relaxed(fmt: &str, input: &str) -> Result<Zoned, jiff::Error> {
+        let mut tm = jiff::fmt::strtime::parse(fmt, input)?;
+        tm.set_weekday(None);
+        tm.to_zoned()
+    }
+
+    /// This is just like strptime_relaxed, except for RFC 2822 parsing.
+    /// Namely, it permits the weekday to be inconsistent with the date.
+    fn rfc2822_relaxed(input: &str) -> Result<Zoned, jiff::Error> {
+        static P: rfc2822::DateTimeParser = rfc2822::DateTimeParser::new().relaxed_weekday(true);
+        P.parse_zoned(input)
+    }
 }
 
 mod relative {
     use std::{str::FromStr, time::SystemTime};
 
-    use time::{Duration, OffsetDateTime};
+    use jiff::{tz::TimeZone, Span, Timestamp, Zoned};
 
     use crate::parse::Error;
 
-    fn parse_inner(input: &str) -> Option<Duration> {
+    fn parse_inner(input: &str) -> Option<Result<Span, Error>> {
         let mut split = input.split_whitespace();
-        let multiplier = i64::from_str(split.next()?).ok()?;
+        let units = i64::from_str(split.next()?).ok()?;
         let period = split.next()?;
         if split.next()? != "ago" {
             return None;
         }
-        duration(period, multiplier)
+        span(period, units)
     }
 
-    pub(crate) fn parse(input: &str, now: Option<SystemTime>) -> Option<Result<OffsetDateTime, Error>> {
-        parse_inner(input).map(|offset| {
-            let offset = std::time::Duration::from_secs(offset.whole_seconds().try_into()?);
+    pub(crate) fn parse(input: &str, now: Option<SystemTime>) -> Option<Result<Zoned, Error>> {
+        parse_inner(input).map(|result| {
+            let span = result?;
+            // This was an error case in a previous version of this code, where
+            // it would fail when converting from a negative signed integer
+            // to an unsigned integer. This preserves that failure case even
+            // though the code below handles it okay.
+            if span.is_negative() {
+                return Err(Error::RelativeTimeConversion);
+            }
             now.ok_or(Error::MissingCurrentTime).and_then(|now| {
-                std::panic::catch_unwind(|| {
-                    now.checked_sub(offset)
-                        .expect("BUG: values can't be large enough to cause underflow")
-                        .into()
-                })
-                .map_err(|_| Error::RelativeTimeConversion)
+                let ts = Timestamp::try_from(now).map_err(|_| Error::RelativeTimeConversion)?;
+                // N.B. This matches the behavior of this code when it was
+                // written with `time`, but we might consider using the system
+                // time zone here. If we did, then it would implement "1 day
+                // ago" correctly, even when it crosses DST transitions. Since
+                // we're in the UTC time zone here, which has no DST, 1 day is
+                // in practice always 24 hours. ---AG
+                let zdt = ts.to_zoned(TimeZone::UTC);
+                zdt.checked_sub(span).map_err(|_| Error::RelativeTimeConversion)
             })
         })
     }
 
-    fn duration(period: &str, multiplier: i64) -> Option<Duration> {
+    fn span(period: &str, units: i64) -> Option<Result<Span, Error>> {
         let period = period.strip_suffix('s').unwrap_or(period);
-        let seconds: i64 = match period {
-            "second" => 1,
-            "minute" => 60,
-            "hour" => 60 * 60,
-            "day" => 24 * 60 * 60,
-            "week" => 7 * 24 * 60 * 60,
+        let result = match period {
+            "second" => Span::new().try_seconds(units),
+            "minute" => Span::new().try_minutes(units),
+            "hour" => Span::new().try_hours(units),
+            "day" => Span::new().try_days(units),
+            "week" => Span::new().try_weeks(units),
             // TODO months & years? YES
             // Ignore values you don't know, assume seconds then (so does git)
             _ => return None,
         };
-        seconds.checked_mul(multiplier).map(Duration::seconds)
+        Some(result.map_err(|_| Error::RelativeTimeConversion))
     }
 
     #[cfg(test)]
@@ -137,7 +164,7 @@ mod relative {
 
         #[test]
         fn two_weeks_ago() {
-            assert_eq!(parse_inner("2 weeks ago"), Some(Duration::weeks(2)));
+            assert_eq!(parse_inner("2 weeks ago").unwrap().unwrap(), Span::new().weeks(2));
         }
     }
 }

Diff for: gix-date/CHANGELOG.md

@@ -1,92 +1,59 @@
-use time::{format_description::FormatItem, macros::format_description};
-
-use crate::{time::Format, Time};
+use crate::{
+    time::{CustomFormat, Format},
+    Time,
+};
 
 /// E.g. `2018-12-24`
-pub const SHORT: &[FormatItem<'_>] = format_description!("[year]-[month]-[day]");
+pub const SHORT: CustomFormat = CustomFormat("%Y-%m-%d");
 
 /// E.g. `Thu, 18 Aug 2022 12:45:06 +0800`
-pub const RFC2822: &[FormatItem<'_>] = format_description!(
-    "[weekday repr:short], [day] [month repr:short] [year] [hour]:[minute]:[second] [offset_hour sign:mandatory][offset_minute]"
-);
+pub const RFC2822: CustomFormat = CustomFormat("%a, %d %b %Y %H:%M:%S %z");
 
 /// E.g. `Thu, 8 Aug 2022 12:45:06 +0800`. This is output by `git log --pretty=%aD`.
-pub const GIT_RFC2822: &[FormatItem<'_>] = format_description!(
-    "[weekday repr:short], \
-     [day padding:none] \
-     [month repr:short] \
-     [year] \
-     [hour]:[minute]:[second] \
-     [offset_hour sign:mandatory][offset_minute]"
-);
+pub const GIT_RFC2822: CustomFormat = CustomFormat("%a, %-d %b %Y %H:%M:%S %z");
 
 /// E.g. `2022-08-17 22:04:58 +0200`
-pub const ISO8601: &[FormatItem<'_>] =
-    format_description!("[year]-[month]-[day] [hour]:[minute]:[second] [offset_hour sign:mandatory][offset_minute]");
+pub const ISO8601: CustomFormat = CustomFormat("%Y-%m-%d %H:%M:%S %z");
 
 /// E.g. `2022-08-17T21:43:13+08:00`
-pub const ISO8601_STRICT: &[FormatItem<'_>] =
-    format_description!("[year]-[month]-[day]T[hour]:[minute]:[second][offset_hour sign:mandatory]:[offset_minute]");
+pub const ISO8601_STRICT: CustomFormat = CustomFormat("%Y-%m-%dT%H:%M:%S%:z");
 
 /// E.g. `123456789`
-pub const UNIX: Format<'static> = Format::Unix;
+pub const UNIX: Format = Format::Unix;
 
 /// E.g. `1660874655 +0800`
-pub const RAW: Format<'static> = Format::Raw;
+pub const RAW: Format = Format::Raw;
 
 /// E.g. `Thu Sep 04 2022 10:45:06 -0400`, like the git `DEFAULT`, but with the year and time fields swapped.
-pub const GITOXIDE: &[FormatItem<'_>] = format_description!(
-    "[weekday repr:short] [month repr:short] [day] [year] [hour]:[minute]:[second] [offset_hour sign:mandatory][offset_minute]"
-);
+pub const GITOXIDE: CustomFormat = CustomFormat("%a %b %d %Y %H:%M:%S %z");
 
 /// E.g. `Thu Sep 4 10:45:06 2022 -0400`. This is output by `git log --pretty=%ad`.
-pub const DEFAULT: &[FormatItem<'_>] = format_description!(
-    "[weekday repr:short] \
-     [month repr:short] \
-     [day padding:none] \
-     [hour]:[minute]:[second] \
-     [year] \
-     [offset_hour sign:mandatory][offset_minute]"
-);
-
-mod format_impls {
-    use time::format_description::FormatItem;
-
-    use crate::time::Format;
-
-    impl<'a> From<&'a [FormatItem<'a>]> for Format<'a> {
-        fn from(f: &'a [FormatItem<'a>]) -> Self {
-            Format::Custom(f)
-        }
-    }
-}
+pub const DEFAULT: CustomFormat = CustomFormat("%a %b %-d %H:%M:%S %Y %z");
 
 /// Formatting
 impl Time {
     /// Format this instance according to the given `format`.
     ///
-    /// Use the [`format_description`](https://time-rs.github.io/book/api/format-description.html) macro to create and
-    /// validate formats at compile time, courtesy of the [`time`] crate.
-    pub fn format<'a>(&self, format: impl Into<Format<'a>>) -> String {
+    /// 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 {
         self.format_inner(format.into())
     }
 
-    fn format_inner(&self, format: Format<'_>) -> String {
+    fn format_inner(&self, format: Format) -> String {
         match format {
-            Format::Custom(format) => self
-                .to_time()
-                .format(&format)
-                .expect("well-known format into memory never fails"),
+            Format::Custom(CustomFormat(format)) => self.to_time().strftime(format).to_string(),
             Format::Unix => self.seconds.to_string(),
             Format::Raw => self.to_bstring().to_string(),
         }
     }
 }
 
 impl Time {
-    fn to_time(self) -> time::OffsetDateTime {
-        time::OffsetDateTime::from_unix_timestamp(self.seconds)
+    fn to_time(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_offset(time::UtcOffset::from_whole_seconds(self.offset).expect("valid offset"))
+            .to_zoned(offset.to_time_zone())
     }
 }

Diff for: gix-date/Cargo.toml

@@ -1,5 +1,3 @@
-use std::ops::Sub;
-
 use crate::{time::Sign, OffsetInSeconds, SecondsSinceUnixEpoch, Time};
 
 /// Instantiation
@@ -15,9 +13,7 @@ impl Time {
 
     /// Return the current time without figuring out a timezone offset
     pub fn now_utc() -> Self {
-        let seconds = time::OffsetDateTime::now_utc()
-            .sub(std::time::SystemTime::UNIX_EPOCH)
-            .whole_seconds();
+        let seconds = jiff::Timestamp::now().as_second();
         Self {
             seconds,
             offset: 0,
@@ -27,28 +23,14 @@ impl Time {
 
     /// Return the current local time, or `None` if the local time wasn't available.
     pub fn now_local() -> Option<Self> {
-        let now = time::OffsetDateTime::now_utc();
-        let seconds = now.sub(std::time::SystemTime::UNIX_EPOCH).whole_seconds();
-        // TODO: make this work without cfg(unsound_local_offset), see
-        //       https://github.com/time-rs/time/issues/293#issuecomment-909158529
-        let offset = time::UtcOffset::local_offset_at(now).ok()?.whole_seconds();
-        Self {
-            seconds,
-            offset,
-            sign: offset.into(),
-        }
-        .into()
+        Some(Self::now_local_or_utc())
     }
 
     /// Return the current local time, or the one at UTC if the local time wasn't available.
     pub fn now_local_or_utc() -> Self {
-        let now = time::OffsetDateTime::now_utc();
-        let seconds = now.sub(std::time::SystemTime::UNIX_EPOCH).whole_seconds();
-        // TODO: make this work without cfg(unsound_local_offset), see
-        //       https://github.com/time-rs/time/issues/293#issuecomment-909158529
-        let offset = time::UtcOffset::local_offset_at(now)
-            .map(time::UtcOffset::whole_seconds)
-            .unwrap_or(0);
+        let zdt = jiff::Zoned::now();
+        let seconds = zdt.timestamp().as_second();
+        let offset = zdt.offset().seconds();
         Self {
             seconds,
             offset,

Diff for: gix-date/src/parse.rs

@@ -19,15 +19,26 @@ pub enum Sign {
 
 /// Various ways to describe a time format.
 #[derive(Debug, Clone, Copy)]
-pub enum Format<'a> {
-    /// A custom format typically defined with the [`format_description`][time::format_description] macro.
-    Custom(&'a [time::format_description::FormatItem<'a>]),
+pub enum Format {
+    /// A custom format limited to what's in the
+    /// [`format`](mod@crate::time::format) submodule.
+    Custom(CustomFormat),
     /// The seconds since 1970, also known as unix epoch, like `1660874655`.
     Unix,
     /// The seconds since 1970, followed by the offset, like `1660874655 +0800`
     Raw,
 }
 
+/// A custom format for printing and parsing time.
+#[derive(Clone, Copy, Debug)]
+pub struct CustomFormat(pub(crate) &'static str);
+
+impl From<CustomFormat> for Format {
+    fn from(custom_format: CustomFormat) -> Format {
+        Format::Custom(custom_format)
+    }
+}
+
 ///
 #[allow(clippy::empty_docs)]
 pub mod format;

Diff for: gix-date/src/time/format.rs

@@ -2,7 +2,6 @@ use gix_date::{
     time::{format, Format, Sign},
     Time,
 };
-use time::macros::format_description;
 
 #[test]
 fn short() {
@@ -72,14 +71,6 @@ fn git_default() {
     )
 }
 
-#[test]
-fn custom_compile_time() {
-    assert_eq!(
-        time().format(format_description!("[year]-[month]-[day] [hour]:[minute]:[second]")),
-        "1973-11-30 00:03:09",
-    );
-}
-
 fn time() -> Time {
     Time {
         seconds: 123456789,

Diff for: gix-date/src/time/init.rs

@@ -146,7 +146,7 @@ mod relative {
     use std::time::SystemTime;
 
     use gix_date::time::Sign;
-    use time::{Duration, OffsetDateTime};
+    use jiff::{ToSpan, Zoned};
 
     #[test]
     fn large_offsets() {
@@ -173,12 +173,19 @@ mod relative {
         let two_weeks_ago = gix_date::parse("2 weeks ago", Some(now)).unwrap();
         assert_eq!(Sign::Plus, two_weeks_ago.sign);
         assert_eq!(0, two_weeks_ago.offset);
-        let expected = OffsetDateTime::from(now).saturating_sub(Duration::weeks(2));
-        // account for the loss of precision when creating `Time` with seconds
-        let expected = expected.replace_nanosecond(0).unwrap();
+        let expected = Zoned::try_from(now)
+            .unwrap()
+            // account for the loss of precision when creating `Time` with seconds
+            .round(
+                jiff::ZonedRound::new()
+                    .smallest(jiff::Unit::Second)
+                    .mode(jiff::RoundMode::Trunc),
+            )
+            .unwrap()
+            .saturating_sub(2.weeks());
         assert_eq!(
-            OffsetDateTime::from_unix_timestamp(two_weeks_ago.seconds).unwrap(),
-            expected,
+            jiff::Timestamp::from_second(two_weeks_ago.seconds).unwrap(),
+            expected.timestamp(),
             "relative times differ"
         );
     }

Diff for: gix-date/src/time/mod.rs

@@ -14,19 +14,19 @@ doctest = false
 
 [features]
 ## Data structures implement `serde::Serialize` and `serde::Deserialize`.
-serde= ["dep:serde", "bstr/serde", "gix-actor/serde"]
+serde = ["dep:serde", "bstr/serde", "gix-actor/serde"]
 
 [dependencies]
 gix-actor = { version = "^0.31.5", path = "../gix-actor" }
-gix-date = { version = "^0.8.7", path = "../gix-date" }
-bstr = { version = "1.3.0", default-features = false, features = ["std", "unicode"]}
+gix-date = { version = "^0.9.0", path = "../gix-date" }
+bstr = { version = "1.3.0", default-features = false, features = ["std", "unicode"] }
 thiserror = "1.0.38"
-serde = { version = "1.0.114", optional = true, default-features = false, features = ["derive"]}
+serde = { version = "1.0.114", optional = true, default-features = false, features = ["derive"] }
 
 document-features = { version = "0.2.0", optional = true }
 
 [dev-dependencies]
-gix-testtools = { path = "../tests/tools"}
+gix-testtools = { path = "../tests/tools" }
 
 [package.metadata.docs.rs]
 all-features = true

Diff for: gix-date/tests/time/format.rs

@@ -16,7 +16,7 @@ test = false
 [dependencies]
 gix-hash = { version = "^0.14.2", path = "../gix-hash" }
 gix-object = { version = "^0.42.3", path = "../gix-object" }
-gix-date = { version = "^0.8.7", path = "../gix-date" }
+gix-date = { version = "^0.9.0", path = "../gix-date" }
 gix-commitgraph = { version = "^0.24.3", path = "../gix-commitgraph" }
 gix-revwalk = { version = "^0.13.2", path = "../gix-revwalk" }
 thiserror = "1.0.40"

Diff for: gix-date/tests/time/parse.rs

@@ -41,7 +41,7 @@ gix-features = { version = "^0.38.2", path = "../gix-features", features = [
 gix-hash = { version = "^0.14.2", path = "../gix-hash" }
 gix-validate = { version = "^0.8.5", path = "../gix-validate" }
 gix-actor = { version = "^0.31.4", path = "../gix-actor" }
-gix-date = { version = "^0.8.7", path = "../gix-date" }
+gix-date = { version = "^0.9.0", path = "../gix-date" }
 gix-utils = { version = "^0.1.11", path = "../gix-utils" }
 
 itoa = "1.0.1"

Diff for: gix-mailmap/Cargo.toml

@@ -20,7 +20,7 @@ serde = ["dep:serde", "gix-hash/serde", "gix-object/serde", "gix-pack/serde"]
 [dependencies]
 gix-features = { version = "^0.38.2", path = "../gix-features", features = ["rustsha1", "walkdir", "zlib", "crc32"] }
 gix-hash = { version = "^0.14.2", path = "../gix-hash" }
-gix-date = { version = "^0.8.7", path = "../gix-date" }
+gix-date = { version = "^0.9.0", path = "../gix-date" }
 gix-path = { version = "^0.10.9", path = "../gix-path" }
 gix-quote = { version = "^0.4.12", path = "../gix-quote" }
 gix-object = { version = "^0.42.3", path = "../gix-object" }

Diff for: gix-negotiate/Cargo.toml

@@ -50,7 +50,7 @@ gix-features = { version = "^0.38.2", path = "../gix-features", features = [
 ] }
 gix-transport = { version = "^0.42.2", path = "../gix-transport" }
 gix-hash = { version = "^0.14.2", path = "../gix-hash" }
-gix-date = { version = "^0.8.7", path = "../gix-date" }
+gix-date = { version = "^0.9.0", path = "../gix-date" }
 gix-credentials = { version = "^0.24.4", path = "../gix-credentials" }
 gix-utils = { version = "^0.1.12", path = "../gix-utils" }
 

Diff for: gix-object/Cargo.toml

@@ -19,7 +19,7 @@ test = true
 serde = ["dep:serde", "gix-hash/serde", "gix-actor/serde", "gix-object/serde"]
 
 [dependencies]
-gix-features = { version = "^0.38.2", path = "../gix-features", features = ["walkdir"]}
+gix-features = { version = "^0.38.2", path = "../gix-features", features = ["walkdir"] }
 gix-fs = { version = "^0.11.2", path = "../gix-fs" }
 gix-path = { version = "^0.10.9", path = "../gix-path" }
 gix-hash = { version = "^0.14.2", path = "../gix-hash" }
@@ -32,7 +32,7 @@ gix-tempfile = { version = "^14.0.0", default-features = false, path = "../gix-t
 
 thiserror = "1.0.34"
 winnow = { version = "0.6.0", features = ["simd"] }
-serde = { version = "1.0.114", optional = true, default-features = false, features = ["derive"]}
+serde = { version = "1.0.114", optional = true, default-features = false, features = ["derive"] }
 
 # packed refs
 memmap2 = "0.9.0"
@@ -41,7 +41,7 @@ document-features = { version = "0.2.1", optional = true }
 
 [dev-dependencies]
 gix-testtools = { path = "../tests/tools" }
-gix-date = { version = "^0.8.7", path = "../gix-date" }
+gix-date = { version = "^0.9.0", path = "../gix-date" }
 
 [package.metadata.docs.rs]
 features = ["document-features", "serde"]

Diff for: gix-odb/Cargo.toml

@@ -19,17 +19,17 @@ default = ["describe"]
 describe = ["dep:gix-trace", "dep:gix-hashtable"]
 
 ## Data structures implement `serde::Serialize` and `serde::Deserialize`.
-serde = [ "dep:serde", "gix-hash/serde", "gix-object/serde" ]
+serde = ["dep:serde", "gix-hash/serde", "gix-object/serde"]
 
 [dependencies]
 gix-hash = { version = "^0.14.2", path = "../gix-hash" }
 gix-object = { version = "^0.42.3", path = "../gix-object" }
-gix-date = { version = "^0.8.7", path = "../gix-date" }
+gix-date = { version = "^0.9.0", path = "../gix-date" }
 gix-hashtable = { version = "^0.5.2", path = "../gix-hashtable", optional = true }
 gix-revwalk = { version = "^0.13.2", path = "../gix-revwalk" }
 gix-trace = { version = "^0.1.8", path = "../gix-trace", optional = true }
 
-bstr = { version = "1.3.0", default-features = false, features = ["std"]}
+bstr = { version = "1.3.0", default-features = false, features = ["std"] }
 thiserror = "1.0.26"
 serde = { version = "1.0.114", optional = true, default-features = false, features = ["derive"] }
 document-features = { version = "0.2.1", optional = true }

Diff for: gix-protocol/Cargo.toml

@@ -15,7 +15,7 @@ doctest = false
 [dependencies]
 gix-hash = { version = "^0.14.2", path = "../gix-hash" }
 gix-object = { version = "^0.42.3", path = "../gix-object" }
-gix-date = { version = "^0.8.7", path = "../gix-date" }
+gix-date = { version = "^0.9.0", path = "../gix-date" }
 gix-hashtable = { version = "^0.5.2", path = "../gix-hashtable" }
 gix-commitgraph = { version = "^0.24.3", path = "../gix-commitgraph" }
 

Diff for: gix-ref/Cargo.toml

@@ -16,7 +16,7 @@ doctest = false
 [dependencies]
 gix-hash = { version = "^0.14.2", path = "../gix-hash" }
 gix-object = { version = "^0.42.3", path = "../gix-object" }
-gix-date = { version = "^0.8.7", path = "../gix-date" }
+gix-date = { version = "^0.9.0", path = "../gix-date" }
 gix-hashtable = { version = "^0.5.2", path = "../gix-hashtable" }
 gix-revwalk = { version = "^0.13.2", path = "../gix-revwalk" }
 gix-commitgraph = { version = "^0.24.3", path = "../gix-commitgraph" }

Diff for: gix-revision/Cargo.toml

@@ -306,7 +306,7 @@ gix-tempfile = { version = "^14.0.0", path = "../gix-tempfile", default-features
 gix-lock = { version = "^14.0.0", path = "../gix-lock" }
 gix-validate = { version = "^0.8.5", path = "../gix-validate" }
 gix-sec = { version = "^0.10.7", path = "../gix-sec" }
-gix-date = { version = "^0.8.7", path = "../gix-date" }
+gix-date = { version = "^0.9.0", path = "../gix-date" }
 gix-refspec = { version = "^0.23.1", path = "../gix-refspec" }
 gix-filter = { version = "^0.11.3", path = "../gix-filter", optional = true }
 gix-dir = { version = "^0.6.0", path = "../gix-dir", optional = true }

Diff for: gix-revwalk/Cargo.toml

@@ -54,11 +54,6 @@ pub mod async_util {
 
 pub fn main() -> Result<()> {
     let args: Args = Args::parse_from(gix::env::args_os());
-    #[allow(unsafe_code)]
-    unsafe {
-        // SAFETY: we don't manipulate the environment from any thread
-        time::util::local_offset::set_soundness(time::util::local_offset::Soundness::Unsound);
-    }
     let thread_limit = args.threads;
     let verbose = args.verbose;
     let format = args.format;

Diff for: gix-traverse/Cargo.toml

@@ -12,11 +12,6 @@ use crate::porcelain::options::{Args, Subcommands};
 
 pub fn main() -> Result<()> {
     let args: Args = Args::parse_from(gix::env::args_os());
-    #[allow(unsafe_code)]
-    unsafe {
-        // SAFETY: we don't manipulate the environment from any thread
-        time::util::local_offset::set_soundness(time::util::local_offset::Soundness::Unsound);
-    }
     let should_interrupt = Arc::new(AtomicBool::new(false));
     #[allow(unsafe_code)]
     unsafe {

Diff for: gix/Cargo.toml

@@ -1,3 +1,3 @@
-thread 'main' panicked at src/porcelain/main.rs:45:42:
+thread 'main' panicked at src/porcelain/main.rs:40:42:
 something went very wrong
 note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

Diff for: src/plumbing/main.rs

@@ -1,4 +1,4 @@
-thread 'main' panicked at src/porcelain/main.rs:45:42:
+thread 'main' panicked at src/porcelain/main.rs:40:42:
 something went very wrong
 note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
 

Diff for: src/porcelain/main.rs

@@ -1,4 +1,4 @@
-[?1049h[?25lthread '<unnamed>' panicked at src/porcelain/main.rs:45:42:
+[?1049h[?25lthread '<unnamed>' panicked at src/porcelain/main.rs:40:42:
 something went very wrong
 note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
 [?25h[?1049l