feat!: Represent time as 64 bit integer.

That way, dates beyond 2038 are supported.

Further, we rename `Time::seconds_since_unix_epoch` to `seconds`, and remove `seconds()`
as there now is a new type, `SecondsSinceUnixEpoch`. In the same vein, we rename
`Time::offset_in_seconds` to `offset` as it now has at type `OffsetInSeconds`.

Author: Byron

gix-date/src/lib.rs

@@ -22,9 +22,14 @@ pub use parse::function::parse;
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Time {
     /// time in seconds since epoch.
-    pub seconds_since_unix_epoch: u32,
+    pub seconds: SecondsSinceUnixEpoch,
     /// time offset in seconds, may be negative to match the `sign` field.
-    pub offset_in_seconds: i32,
+    pub offset: OffsetInSeconds,
     /// the sign of `offset`, used to encode `-0000` which would otherwise loose sign information.
     pub sign: time::Sign,
 }
+
+/// The amount of seconds since unix epoch.
+pub type SecondsSinceUnixEpoch = u64;
+/// time offset in seconds.
+pub type OffsetInSeconds = i32;

gix-date/src/parse.rs

@@ -7,7 +7,7 @@ pub enum Error {
     RelativeTimeConversion,
     #[error("Date string can not be parsed")]
     InvalidDateString { input: String },
-    #[error("Dates past 2038 can not be represented.")]
+    #[error("The heat-death of the universe happens before this date")]
     InvalidDate(#[from] std::num::TryFromIntError),
     #[error("Current time is missing but required to handle relative dates.")]
     MissingCurrentTime,
@@ -24,7 +24,7 @@ pub(crate) mod function {
             format::{DEFAULT, GITOXIDE, ISO8601, ISO8601_STRICT, SHORT},
             Sign,
         },
-        Time,
+        SecondsSinceUnixEpoch, Time,
     };
 
     #[allow(missing_docs)]
@@ -47,7 +47,7 @@ pub(crate) mod function {
             Time::new(val.unix_timestamp().try_into()?, val.offset().whole_seconds())
         } else if let Ok(val) = OffsetDateTime::parse(input, DEFAULT) {
             Time::new(val.unix_timestamp().try_into()?, val.offset().whole_seconds())
-        } else if let Ok(val) = u32::from_str(input) {
+        } else if let Ok(val) = SecondsSinceUnixEpoch::from_str(input) {
             // Format::Unix
             Time::new(val, 0)
         } else if let Some(val) = parse_raw(input) {
@@ -60,7 +60,7 @@ pub(crate) mod function {
         })
     }
 
-    fn timestamp(date: OffsetDateTime) -> Result<u32, Error> {
+    fn timestamp(date: OffsetDateTime) -> Result<SecondsSinceUnixEpoch, Error> {
         let timestamp = date.unix_timestamp();
         if timestamp < 0 {
             Err(Error::TooEarly { timestamp })
@@ -71,7 +71,7 @@ pub(crate) mod function {
 
     fn parse_raw(input: &str) -> Option<Time> {
         let mut split = input.split_whitespace();
-        let seconds_since_unix_epoch: u32 = split.next()?.parse().ok()?;
+        let seconds: SecondsSinceUnixEpoch = split.next()?.parse().ok()?;
         let offset = split.next()?;
         if offset.len() != 5 || split.next().is_some() {
             return None;
@@ -88,8 +88,8 @@ pub(crate) mod function {
             offset_in_seconds *= -1;
         };
         let time = Time {
-            seconds_since_unix_epoch,
-            offset_in_seconds,
+            seconds,
+            offset: offset_in_seconds,
             sign,
         };
         Some(time)

gix-date/src/time/format.rs

@@ -73,16 +73,16 @@ impl Time {
                 .to_time()
                 .format(&format)
                 .expect("well-known format into memory never fails"),
-            Format::Unix => self.seconds_since_unix_epoch.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_since_unix_epoch as i64)
+        time::OffsetDateTime::from_unix_timestamp(self.seconds as i64)
             .expect("always valid unix time")
-            .to_offset(time::UtcOffset::from_whole_seconds(self.offset_in_seconds).expect("valid offset"))
+            .to_offset(time::UtcOffset::from_whole_seconds(self.offset).expect("valid offset"))
     }
 }

gix-date/src/time/init.rs

@@ -1,68 +1,68 @@
 use std::{convert::TryInto, ops::Sub};
 
-use crate::{time::Sign, Time};
+use crate::{time::Sign, OffsetInSeconds, SecondsSinceUnixEpoch, Time};
 
 /// Instantiation
 impl Time {
     /// Create a new instance from seconds and offset.
-    pub fn new(seconds_since_unix_epoch: u32, offset_in_seconds: i32) -> Self {
+    pub fn new(seconds: SecondsSinceUnixEpoch, offset: OffsetInSeconds) -> Self {
         Time {
-            seconds_since_unix_epoch,
-            offset_in_seconds,
-            sign: offset_in_seconds.into(),
+            seconds,
+            offset,
+            sign: offset.into(),
         }
     }
 
     /// Return the current time without figuring out a timezone offset
     pub fn now_utc() -> Self {
-        let seconds_since_unix_epoch = time::OffsetDateTime::now_utc()
+        let seconds = time::OffsetDateTime::now_utc()
             .sub(std::time::SystemTime::UNIX_EPOCH)
             .whole_seconds()
             .try_into()
-            .expect("this is not year 2038");
+            .expect("this is not the end of the universe");
         Self {
-            seconds_since_unix_epoch,
-            offset_in_seconds: 0,
+            seconds,
+            offset: 0,
             sign: Sign::Plus,
         }
     }
 
     /// 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_since_unix_epoch = now
+        let seconds = now
             .sub(std::time::SystemTime::UNIX_EPOCH)
             .whole_seconds()
             .try_into()
-            .expect("this is not year 2038");
+            .expect("this is not the end of the universe");
         // TODO: make this work without cfg(unsound_local_offset), see
         //       https://github.com/time-rs/time/issues/293#issuecomment-909158529
-        let offset_in_seconds = time::UtcOffset::local_offset_at(now).ok()?.whole_seconds();
+        let offset = time::UtcOffset::local_offset_at(now).ok()?.whole_seconds();
         Self {
-            seconds_since_unix_epoch,
-            offset_in_seconds,
-            sign: offset_in_seconds.into(),
+            seconds,
+            offset,
+            sign: offset.into(),
         }
         .into()
     }
 
     /// 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_since_unix_epoch = now
+        let seconds = now
             .sub(std::time::SystemTime::UNIX_EPOCH)
             .whole_seconds()
             .try_into()
-            .expect("this is not year 2038");
+            .expect("this is not the end of the universe");
         // TODO: make this work without cfg(unsound_local_offset), see
         //       https://github.com/time-rs/time/issues/293#issuecomment-909158529
-        let offset_in_seconds = time::UtcOffset::local_offset_at(now)
+        let offset = time::UtcOffset::local_offset_at(now)
             .map(|ofs| ofs.whole_seconds())
             .unwrap_or(0);
         Self {
-            seconds_since_unix_epoch,
-            offset_in_seconds,
-            sign: offset_in_seconds.into(),
+            seconds,
+            offset,
+            sign: offset.into(),
         }
     }
 }

gix-date/src/time/mod.rs

@@ -6,11 +6,6 @@ impl Time {
     pub fn is_set(&self) -> bool {
         *self != Self::default()
     }
-
-    /// Return the passed seconds since epoch since this signature was made.
-    pub fn seconds(&self) -> u32 {
-        self.seconds_since_unix_epoch
-    }
 }
 
 /// Indicates if a number is positive or negative for use in [`Time`].
@@ -58,8 +53,8 @@ mod impls {
     impl Default for Time {
         fn default() -> Self {
             Time {
-                seconds_since_unix_epoch: 0,
-                offset_in_seconds: 0,
+                seconds: 0,
+                offset: 0,
                 sign: Sign::Plus,
             }
         }

gix-date/src/time/write.rs

@@ -14,7 +14,7 @@ impl Time {
     /// Serialize this instance to `out` in a format suitable for use in header fields of serialized git commits or tags.
     pub fn write_to(&self, mut out: impl std::io::Write) -> std::io::Result<()> {
         let mut itoa = itoa::Buffer::new();
-        out.write_all(itoa.format(self.seconds_since_unix_epoch).as_bytes())?;
+        out.write_all(itoa.format(self.seconds).as_bytes())?;
         out.write_all(b" ")?;
         out.write_all(match self.sign {
             Sign::Plus => b"+",
@@ -24,7 +24,7 @@ impl Time {
         const ZERO: &[u8; 1] = b"0";
 
         const SECONDS_PER_HOUR: i32 = 60 * 60;
-        let offset = self.offset_in_seconds.abs();
+        let offset = self.offset.abs();
         let hours = offset / SECONDS_PER_HOUR;
         assert!(hours < 25, "offset is more than a day: {hours}");
         let minutes = (offset - (hours * SECONDS_PER_HOUR)) / 60;
@@ -40,30 +40,48 @@ impl Time {
         out.write_all(itoa.format(minutes).as_bytes()).map(|_| ())
     }
 
-    /// Computes the number of bytes necessary to render this time.
+    /// Computes the number of bytes necessary to write it using [`Time::write_to()`].
     pub fn size(&self) -> usize {
-        // TODO: this is not year 2038 safe…but we also can't parse larger numbers (or represent them) anyway. It's a trap nonetheless
-        //       that can be fixed by increasing the size to usize.
-        (if self.seconds_since_unix_epoch >= 1_000_000_000 {
+        (if self.seconds >= 10_000_000_000_000_000_000 {
+            20
+        } else if self.seconds >= 1_000_000_000_000_000_000 {
+            19
+        } else if self.seconds >= 100_000_000_000_000_000 {
+            18
+        } else if self.seconds >= 10_000_000_000_000_000 {
+            17
+        } else if self.seconds >= 1_000_000_000_000_000 {
+            16
+        } else if self.seconds >= 100_000_000_000_000 {
+            15
+        } else if self.seconds >= 10_000_000_000_000 {
+            14
+        } else if self.seconds >= 1_000_000_000_000 {
+            13
+        } else if self.seconds >= 100_000_000_000 {
+            12
+        } else if self.seconds >= 10_000_000_000 {
+            11
+        } else if self.seconds >= 1_000_000_000 {
             10
-        } else if self.seconds_since_unix_epoch >= 100_000_000 {
+        } else if self.seconds >= 100_000_000 {
             9
-        } else if self.seconds_since_unix_epoch >= 10_000_000 {
+        } else if self.seconds >= 10_000_000 {
             8
-        } else if self.seconds_since_unix_epoch >= 1_000_000 {
+        } else if self.seconds >= 1_000_000 {
             7
-        } else if self.seconds_since_unix_epoch >= 100_000 {
+        } else if self.seconds >= 100_000 {
             6
-        } else if self.seconds_since_unix_epoch >= 10_000 {
+        } else if self.seconds >= 10_000 {
             5
-        } else if self.seconds_since_unix_epoch >= 1_000 {
+        } else if self.seconds >= 1_000 {
             4
-        } else if self.seconds_since_unix_epoch >= 100 {
+        } else if self.seconds >= 100 {
             3
-        } else if self.seconds_since_unix_epoch >= 10 {
+        } else if self.seconds >= 10 {
             2
         } else {
             1
-        }) + 2 /*space + sign*/ + 2 /*hours*/ + 2 /*minutes*/
+        }) + 2 /*space + offset sign*/ + 2 /*offset hours*/ + 2 /*offset minutes*/
     }
 }

gix-date/tests/fixtures/generate_git_date_baseline.sh

@@ -38,7 +38,9 @@ baseline '2022-08-17T21:43:13+08:00' 'ISO8601_STRICT'
 baseline 'Thu Sep 04 2022 10:45:06 -0400' '' # cannot round-trip, incorrect day-of-week
 baseline 'Sun Sep 04 2022 10:45:06 -0400' 'GITOXIDE'
 # unix
-baseline '123456789' 'UNIX'
+baseline '1234567890' 'UNIX'
 # raw
 baseline '1660874655 +0800' 'RAW'
 
+# Note that we can't necessarily put 64bit dates here yet as `git` on the system might not yet support it.
+

gix-date/tests/fixtures/generated-archives/generate_git_date_baseline.tar.xz

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:f78af3da4b598ccee56688adf4ff3dcc35a9e002b2b9372d17dd3b342b2bdecd
-size 9256
+oid sha256:376819eee3c7e23a16abb5ffe4540c215676c183e89c415f0a997b325a0b1331
+size 9260

gix-date/tests/time/baseline.rs

@@ -1,14 +1,15 @@
 use std::{collections::HashMap, time::SystemTime};
 
 use gix_date::time::{format, Format};
+use gix_date::SecondsSinceUnixEpoch;
 use once_cell::sync::Lazy;
 
 type Result<T = ()> = std::result::Result<T, Box<dyn std::error::Error>>;
 
 struct Sample {
     format_name: Option<String>,
     exit_code: usize,
-    time_in_seconds_since_unix_epoch: u32,
+    seconds: SecondsSinceUnixEpoch,
 }
 
 static BASELINE: Lazy<HashMap<String, Sample>> = Lazy::new(|| {
@@ -21,7 +22,7 @@ static BASELINE: Lazy<HashMap<String, Sample>> = Lazy::new(|| {
         while let Some(date_str) = lines.next() {
             let format_name = lines.next().expect("four lines per baseline").to_string();
             let exit_code = lines.next().expect("four lines per baseline").parse()?;
-            let time_in_seconds_since_unix_epoch: u32 = lines
+            let seconds: SecondsSinceUnixEpoch = lines
                 .next()
                 .expect("four lines per baseline")
                 .parse()
@@ -31,7 +32,7 @@ static BASELINE: Lazy<HashMap<String, Sample>> = Lazy::new(|| {
                 Sample {
                     format_name: (!format_name.is_empty()).then_some(format_name),
                     exit_code,
-                    time_in_seconds_since_unix_epoch,
+                    seconds,
                 },
             );
         }
@@ -47,7 +48,7 @@ fn parse_compare_format() {
         Sample {
             format_name,
             exit_code,
-            time_in_seconds_since_unix_epoch,
+            seconds: time_in_seconds_since_unix_epoch,
         },
     ) in BASELINE.iter()
     {
@@ -58,7 +59,7 @@ fn parse_compare_format() {
             "{pattern:?} disagrees with baseline: {res:?}"
         );
         if let Ok(t) = res {
-            let actual = t.seconds_since_unix_epoch;
+            let actual = t.seconds;
             assert_eq!(
                 actual, *time_in_seconds_since_unix_epoch,
                 "{pattern:?} disagrees with baseline seconds since epoch: {actual:?}"

gix-date/tests/time/format.rs

@@ -82,16 +82,16 @@ fn custom_compile_time() {
 
 fn time() -> Time {
     Time {
-        seconds_since_unix_epoch: 123456789,
-        offset_in_seconds: 9000,
+        seconds: 123456789,
+        offset: 9000,
         sign: Sign::Plus,
     }
 }
 
 fn time_dec1() -> Time {
     Time {
-        seconds_since_unix_epoch: 123543189,
-        offset_in_seconds: 9000,
+        seconds: 123543189,
+        offset: 9000,
         sign: Sign::Plus,
     }
 }