support jiff

Author: magiclen

.github/workflows/ci-version.yml

@@ -24,6 +24,7 @@ jobs:
           -
           - --features chrono
           - --features time
+          - --features jiff
           - --all-features
     name: Test ${{ matrix.toolchain }} on ${{ matrix.os }} (${{ matrix.features }})
     runs-on: ${{ matrix.os }}
@@ -49,6 +50,7 @@ jobs:
           -
           - --features chrono
           - --features time
+          - --features jiff
           - --all-features
     name: Test ${{ matrix.toolchain }} on ${{ matrix.os }} (${{ matrix.features }})
     runs-on: ${{ matrix.os }}

.github/workflows/ci.yml

@@ -40,6 +40,7 @@ jobs:
           -
           - --features chrono
           - --features time
+          - --features jiff
           - --all-features
     name: Test ${{ matrix.toolchain }} on ${{ matrix.os }} (${{ matrix.features }})
     runs-on: ${{ matrix.os }}
@@ -65,6 +66,7 @@ jobs:
           -
           - --features chrono
           - --features time
+          - --features jiff
           - --all-features
     name: Test ${{ matrix.toolchain }} on ${{ matrix.os }} (${{ matrix.features }})
     runs-on: ${{ matrix.os }}

Cargo.toml

@@ -15,17 +15,20 @@ include = ["src/**/*", "Cargo.toml", "README.md", "LICENSE"]
 [features]
 default = []
 chrono = ["dep:chrono"]
+jiff = ["dep:jiff"]
 time = ["dep:time"]
 
 [dependencies]
 chrono = { version = "0.4", default-features = false, optional = true }
+jiff = { version = "0.2", default-features = false, optional = true }
 time = { version = "0.3", default-features = false, optional = true }
 
 year-helper = "0.2"
 
 [dev-dependencies]
 rand = "0.9"
 chrono = { version = "0.4", default-features = false, features = ["clock"] }
+jiff = "0.2"
 time = { version = "0.3", default-features = false, features = ["local-offset"] }
 
 [[example]]
@@ -36,6 +39,10 @@ required-features = ["chrono"]
 name = "time"
 required-features = ["time"]
 
+[[example]]
+name = "jiff"
+required-features = ["jiff"]
+
 [package.metadata.docs.rs]
 all-features = true
-rustdoc-args = ["--cfg", "docsrs"]
+rustdoc-args = ["--cfg", "docsrs"]

README.md

@@ -12,6 +12,7 @@ Date-time crate support is enabled through Cargo features. Enable only the provi
 | Feature | Time-zone aware types | Naive/local date-time types |
 | --- | --- | --- |
 | `chrono` | `chrono::DateTime<Tz>` | `chrono::NaiveDateTime` |
+| `jiff` | `jiff::Zoned` | `jiff::civil::DateTime` |
 | `time` | `time::OffsetDateTime`, `time::UtcDateTime` | `time::PrimitiveDateTime` |
 
 Time-zone aware types keep a timezone or UTC offset in the value. Naive/local types store only calendar and clock fields, so the caller decides how to interpret them.

examples/jiff.rs

@@ -0,0 +1,75 @@
+use date_differencer::{add_date_time_diff, date_diff, date_time_diff};
+use jiff::{Zoned, civil::date, tz::TimeZone};
+
+fn date_time(
+    time_zone: &TimeZone,
+    year: i16,
+    month: i8,
+    day: i8,
+    hour: i8,
+    minute: i8,
+    second: i8,
+) -> Zoned {
+    date(year, month, day).at(hour, minute, second, 0).to_zoned(time_zone.clone()).unwrap()
+}
+
+fn main() {
+    // Use the system time zone so this example feels like local date-time code.
+    let time_zone = TimeZone::system();
+
+    let a = date_time(&time_zone, 2022, 4, 6, 0, 0, 0);
+    let b = date_time(&time_zone, 2023, 6, 9, 1, 0, 0);
+
+    println!("{:?}", date_diff(a.clone(), b.clone()));
+    /*
+    {
+        "years": 1,
+        "months": 2,
+        "days": 3
+    }
+    */
+
+    println!("{:?}", date_time_diff(a.clone(), b.clone()));
+    /*
+    {
+        "years": 1,
+        "months": 2,
+        "days": 3,
+        "hours": 1,
+        "minutes": 0,
+        "seconds": 0,
+        "nanoseconds": 0
+    }
+    */
+
+    println!("{}", add_date_time_diff(a.clone(), &date_time_diff(a.clone(), b.clone())).unwrap()); // the same as b
+
+    let a = date_time(&time_zone, 2020, 2, 27, 0, 0, 0);
+    let b = date_time(&time_zone, 2021, 3, 1, 0, 0, 0);
+
+    println!("{:?}", date_diff(a.clone(), b.clone()));
+    /*
+    {
+        "years": 1,
+        "months": 0,
+        "days": 2
+    }
+
+    Explanation:
+        1. 2020-02-27 + 1 year -> 2021-02-27
+        2. 2021-02-27 + 2 days -> 2021-03-01 (2021-02 has 28 days)
+    */
+
+    println!("{:?}", date_diff(b, a));
+    /*
+    {
+        "years": -1,
+        "months": 0,
+        "days": -3
+    }
+
+    Explanation:
+        1. 2021-03-01 - 1 year -> 2020-03-01
+        2. 2020-03-01 - 3 days -> 2020-02-27 (2020-02 has 29 days)
+    */
+}

src/add_diff/jiff_support.rs

@@ -0,0 +1,64 @@
+use core::fmt;
+
+use jiff::{Zoned, civil::DateTime};
+
+use super::{AddDateTimeDiff, AddedDateTimeParts, DateTimeDiff, add_date_time_parts};
+
+#[inline]
+fn jiff_error(args: fmt::Arguments<'_>) -> jiff::Error {
+    jiff::Error::from_args(args)
+}
+
+#[inline]
+fn added_date_time_parts(
+    from: &impl super::DateTimeParts,
+    date_time_diff: &impl DateTimeDiff,
+) -> Result<AddedDateTimeParts, jiff::Error> {
+    add_date_time_parts(from, date_time_diff).ok_or_else(|| {
+        jiff_error(format_args!("date-time addition overflowed before constructing the Jiff value"))
+    })
+}
+
+#[inline]
+fn jiff_year(year: i32) -> Result<i16, jiff::Error> {
+    i16::try_from(year)
+        .map_err(|_| jiff_error(format_args!("date-time year is outside Jiff's supported range")))
+}
+
+impl AddDateTimeDiff for DateTime {
+    type Output = Result<DateTime, jiff::Error>;
+
+    #[inline]
+    fn add_date_time_diff(self, date_time_diff: &impl DateTimeDiff) -> Self::Output {
+        let parts = added_date_time_parts(&self, date_time_diff)?;
+
+        DateTime::new(
+            jiff_year(parts.year)?,
+            parts.month as i8,
+            parts.day as i8,
+            parts.hour as i8,
+            parts.minute as i8,
+            parts.second as i8,
+            parts.nanosecond as i32,
+        )
+    }
+}
+
+impl AddDateTimeDiff for Zoned {
+    type Output = Result<Zoned, jiff::Error>;
+
+    #[inline]
+    fn add_date_time_diff(self, date_time_diff: &impl DateTimeDiff) -> Self::Output {
+        let parts = added_date_time_parts(&self, date_time_diff)?;
+
+        self.with()
+            .year(jiff_year(parts.year)?)
+            .month(parts.month as i8)
+            .day(parts.day as i8)
+            .hour(parts.hour as i8)
+            .minute(parts.minute as i8)
+            .second(parts.second as i8)
+            .subsec_nanosecond(parts.nanosecond as i32)
+            .build()
+    }
+}

src/add_diff/mod.rs

@@ -1,13 +1,15 @@
 #[cfg(feature = "chrono")]
 mod chrono_support;
+#[cfg(feature = "jiff")]
+mod jiff_support;
 #[cfg(feature = "time")]
 mod time_support;
 
-#[cfg(any(feature = "chrono", feature = "time"))]
+#[cfg(any(feature = "chrono", feature = "jiff", feature = "time"))]
 use super::constants::*;
 use super::{DateTimeDiff, DateTimeParts};
 
-#[cfg(any(feature = "chrono", feature = "time"))]
+#[cfg(any(feature = "chrono", feature = "jiff", feature = "time"))]
 #[derive(Debug, Clone, Copy)]
 struct AddedDateTimeParts {
     year:       i32,
@@ -19,7 +21,7 @@ struct AddedDateTimeParts {
     nanosecond: u32,
 }
 
-#[cfg(any(feature = "chrono", feature = "time"))]
+#[cfg(any(feature = "chrono", feature = "jiff", feature = "time"))]
 #[inline]
 fn month_add(year: &mut i32, month: &mut i32, n: i32) -> Option<()> {
     *month = month.checked_add(n)?;
@@ -40,7 +42,7 @@ fn month_add(year: &mut i32, month: &mut i32, n: i32) -> Option<()> {
     Some(())
 }
 
-#[cfg(any(feature = "chrono", feature = "time"))]
+#[cfg(any(feature = "chrono", feature = "jiff", feature = "time"))]
 #[inline]
 fn date_add(year: &mut i32, month: &mut i32, date: &mut i32, n: i32) -> Option<()> {
     *date = date.checked_add(n)?;
@@ -81,7 +83,7 @@ fn date_add(year: &mut i32, month: &mut i32, date: &mut i32, n: i32) -> Option<(
     Some(())
 }
 
-#[cfg(any(feature = "chrono", feature = "time"))]
+#[cfg(any(feature = "chrono", feature = "jiff", feature = "time"))]
 #[inline]
 fn hour_add(year: &mut i32, month: &mut i32, date: &mut i32, hour: &mut i32, n: i32) -> Option<()> {
     *hour = hour.checked_add(n)?;
@@ -102,7 +104,7 @@ fn hour_add(year: &mut i32, month: &mut i32, date: &mut i32, hour: &mut i32, n:
     Some(())
 }
 
-#[cfg(any(feature = "chrono", feature = "time"))]
+#[cfg(any(feature = "chrono", feature = "jiff", feature = "time"))]
 #[inline]
 fn minute_add(
     year: &mut i32,
@@ -130,7 +132,7 @@ fn minute_add(
     Some(())
 }
 
-#[cfg(any(feature = "chrono", feature = "time"))]
+#[cfg(any(feature = "chrono", feature = "jiff", feature = "time"))]
 #[inline]
 fn second_add(
     year: &mut i32,
@@ -159,7 +161,7 @@ fn second_add(
     Some(())
 }
 
-#[cfg(any(feature = "chrono", feature = "time"))]
+#[cfg(any(feature = "chrono", feature = "jiff", feature = "time"))]
 #[allow(clippy::too_many_arguments)]
 #[inline]
 fn nanosecond_add(
@@ -187,7 +189,7 @@ fn nanosecond_add(
     Some(())
 }
 
-#[cfg(any(feature = "chrono", feature = "time"))]
+#[cfg(any(feature = "chrono", feature = "jiff", feature = "time"))]
 fn add_date_time_parts(
     from: &impl DateTimeParts,
     date_time_diff: &impl DateTimeDiff,

src/diff/jiff_support.rs

@@ -0,0 +1,77 @@
+use jiff::{Zoned, civil::DateTime};
+
+use super::DateTimeParts;
+
+impl DateTimeParts for DateTime {
+    #[inline]
+    fn year(&self) -> i32 {
+        i32::from(DateTime::year(*self))
+    }
+
+    #[inline]
+    fn month(&self) -> u8 {
+        DateTime::month(*self) as u8
+    }
+
+    #[inline]
+    fn day(&self) -> u8 {
+        DateTime::day(*self) as u8
+    }
+
+    #[inline]
+    fn hour(&self) -> u8 {
+        DateTime::hour(*self) as u8
+    }
+
+    #[inline]
+    fn minute(&self) -> u8 {
+        DateTime::minute(*self) as u8
+    }
+
+    #[inline]
+    fn second(&self) -> u8 {
+        DateTime::second(*self) as u8
+    }
+
+    #[inline]
+    fn nanosecond(&self) -> u32 {
+        DateTime::subsec_nanosecond(*self) as u32
+    }
+}
+
+impl DateTimeParts for Zoned {
+    #[inline]
+    fn year(&self) -> i32 {
+        i32::from(self.year())
+    }
+
+    #[inline]
+    fn month(&self) -> u8 {
+        self.month() as u8
+    }
+
+    #[inline]
+    fn day(&self) -> u8 {
+        self.day() as u8
+    }
+
+    #[inline]
+    fn hour(&self) -> u8 {
+        self.hour() as u8
+    }
+
+    #[inline]
+    fn minute(&self) -> u8 {
+        self.minute() as u8
+    }
+
+    #[inline]
+    fn second(&self) -> u8 {
+        self.second() as u8
+    }
+
+    #[inline]
+    fn nanosecond(&self) -> u32 {
+        self.subsec_nanosecond() as u32
+    }
+}

src/diff/mod.rs

@@ -1,5 +1,7 @@
 #[cfg(feature = "chrono")]
 mod chrono_support;
+#[cfg(feature = "jiff")]
+mod jiff_support;
 #[cfg(feature = "time")]
 mod time_support;
 

src/lib.rs

@@ -10,6 +10,7 @@ Date-time crate support is enabled through Cargo features. Enable only the provi
 | Feature | Time-zone aware types | Naive/local date-time types |
 | --- | --- | --- |
 | `chrono` | `chrono::DateTime<Tz>` | `chrono::NaiveDateTime` |
+| `jiff` | `jiff::Zoned` | `jiff::civil::DateTime` |
 | `time` | `time::OffsetDateTime`, `time::UtcDateTime` | `time::PrimitiveDateTime` |
 
 Time-zone aware types keep a timezone or UTC offset in the value. Naive/local types store only calendar and clock fields, so the caller decides how to interpret them.