Implement DateTime diffing methods Until and Since (#83)

This implements diffing for `DateTime` and the corresponding `since` and
`until` methods.

TODO: add basic unit tests for the methods.

Author: nekevss

src/components/date.rs

@@ -249,6 +249,8 @@ impl Date {
         other.iso.to_epoch_days() - self.iso.to_epoch_days()
     }
 
+    #[inline]
+    /// Adds a `Duration` to the current `Date`
     pub fn add(
         &self,
         duration: &Duration,
@@ -257,6 +259,8 @@ impl Date {
         self.add_date(duration, overflow)
     }
 
+    #[inline]
+    /// Subtracts a `Duration` to the current `Date`
     pub fn subtract(
         &self,
         duration: &Duration,
@@ -265,10 +269,14 @@ impl Date {
         self.add_date(&duration.negated(), overflow)
     }
 
+    #[inline]
+    /// Returns a `Duration` representing the time from this `Date` until the other `Date`.
     pub fn until(&self, other: &Self, settings: DifferenceSettings) -> TemporalResult<Duration> {
         self.diff_date(DifferenceOperation::Until, other, settings)
     }
 
+    #[inline]
+    /// Returns a `Duration` representing the time passed from this `Date` since the other `Date`.
     pub fn since(&self, other: &Self, settings: DifferenceSettings) -> TemporalResult<Duration> {
         self.diff_date(DifferenceOperation::Since, other, settings)
     }

src/components/datetime.rs

@@ -3,9 +3,12 @@
 use crate::{
     components::{calendar::Calendar, duration::TimeDuration, Instant},
     iso::{IsoDate, IsoDateSlots, IsoDateTime, IsoTime},
-    options::{ArithmeticOverflow, ResolvedRoundingOptions, TemporalUnit},
+    options::{
+        ArithmeticOverflow, DifferenceOperation, DifferenceSettings, ResolvedRoundingOptions,
+        TemporalUnit,
+    },
     parsers::parse_date_time,
-    temporal_assert, TemporalError, TemporalResult, TemporalUnwrap,
+    temporal_assert, Sign, TemporalError, TemporalResult, TemporalUnwrap,
 };
 
 use std::{cmp::Ordering, str::FromStr};
@@ -89,6 +92,42 @@ impl DateTime {
         Ok(Self::new_unchecked(result, self.calendar.clone()))
     }
 
+    /// Difference two `DateTime`s together.
+    pub(crate) fn diff(
+        &self,
+        op: DifferenceOperation,
+        other: &Self,
+        settings: DifferenceSettings,
+    ) -> TemporalResult<Duration> {
+        // 3. If ? CalendarEquals(dateTime.[[Calendar]], other.[[Calendar]]) is false, throw a RangeError exception.
+        if self.calendar != other.calendar {
+            return Err(TemporalError::range()
+                .with_message("Calendar must be the same when diffing two DateTimes"));
+        }
+
+        // 5. Let settings be ? GetDifferenceSettings(operation, resolvedOptions, datetime, « », "nanosecond", "day").
+        let (sign, options) = ResolvedRoundingOptions::from_diff_settings(
+            settings,
+            op,
+            TemporalUnit::Day,
+            TemporalUnit::Nanosecond,
+        )?;
+
+        // Step 7-8 combined.
+        if self.iso == other.iso {
+            return Ok(Duration::default());
+        }
+
+        // Step 10-11.
+        let (result, _) = self.diff_dt_with_rounding(other, options)?;
+
+        // Step 12
+        match sign {
+            Sign::Positive | Sign::Zero => Ok(result),
+            Sign::Negative => Ok(result.negated()),
+        }
+    }
+
     // TODO: Figure out whether to handle resolvedOptions
     // 5.5.12 DifferencePlainDateTimeWithRounding ( y1, mon1, d1, h1, min1, s1, ms1, mus1, ns1, y2, mon2, d2, h2, min2, s2, ms2,
     // mus2, ns2, calendarRec, largestUnit, roundingIncrement, smallestUnit, roundingMode, resolvedOptions )
@@ -381,6 +420,7 @@ impl DateTime {
     }
 
     #[inline]
+    /// Adds a `Duration` to the current `DateTime`.
     pub fn add(
         &self,
         duration: &Duration,
@@ -390,13 +430,26 @@ impl DateTime {
     }
 
     #[inline]
+    /// Subtracts a `Duration` to the current `DateTime`.
     pub fn subtract(
         &self,
         duration: &Duration,
         overflow: Option<ArithmeticOverflow>,
     ) -> TemporalResult<Self> {
         self.add_or_subtract_duration(&duration.negated(), overflow)
     }
+
+    #[inline]
+    /// Returns a `Duration` representing the period of time from this `DateTime` until the other `DateTime`.
+    pub fn until(&self, other: &Self, settings: DifferenceSettings) -> TemporalResult<Duration> {
+        self.diff(DifferenceOperation::Until, other, settings)
+    }
+
+    #[inline]
+    /// Returns a `Duration` representing the period of time from this `DateTime` since the other `DateTime`.
+    pub fn since(&self, other: &Self, settings: DifferenceSettings) -> TemporalResult<Duration> {
+        self.diff(DifferenceOperation::Since, other, settings)
+    }
 }
 
 // ==== Trait impls ====
@@ -464,6 +517,7 @@ mod tests {
     use crate::{
         components::{calendar::Calendar, duration::DateDuration, Duration},
         iso::{IsoDate, IsoTime},
+        options::{DifferenceSettings, RoundingIncrement, TemporalRoundingMode, TemporalUnit},
     };
 
     use super::DateTime;
@@ -575,4 +629,61 @@ mod tests {
             }
         );
     }
+
+    fn create_diff_setting(
+        smallest: TemporalUnit,
+        increment: u32,
+        rounding_mode: TemporalRoundingMode,
+    ) -> DifferenceSettings {
+        DifferenceSettings {
+            largest_unit: None,
+            smallest_unit: Some(smallest),
+            increment: Some(RoundingIncrement::try_new(increment).unwrap()),
+            rounding_mode: Some(rounding_mode),
+        }
+    }
+
+    #[test]
+    fn dt_until_basic() {
+        let earlier =
+            DateTime::new(2019, 1, 8, 8, 22, 36, 123, 456, 789, Calendar::default()).unwrap();
+        let later =
+            DateTime::new(2021, 9, 7, 12, 39, 40, 987, 654, 321, Calendar::default()).unwrap();
+
+        let settings = create_diff_setting(TemporalUnit::Hour, 3, TemporalRoundingMode::HalfExpand);
+        let result = earlier.until(&later, settings).unwrap();
+
+        assert_eq!(result.days(), 973.0);
+        assert_eq!(result.hours(), 3.0);
+
+        let settings =
+            create_diff_setting(TemporalUnit::Minute, 30, TemporalRoundingMode::HalfExpand);
+        let result = earlier.until(&later, settings).unwrap();
+
+        assert_eq!(result.days(), 973.0);
+        assert_eq!(result.hours(), 4.0);
+        assert_eq!(result.minutes(), 30.0);
+    }
+
+    #[test]
+    fn dt_since_basic() {
+        let earlier =
+            DateTime::new(2019, 1, 8, 8, 22, 36, 123, 456, 789, Calendar::default()).unwrap();
+        let later =
+            DateTime::new(2021, 9, 7, 12, 39, 40, 987, 654, 321, Calendar::default()).unwrap();
+
+        let settings = create_diff_setting(TemporalUnit::Hour, 3, TemporalRoundingMode::HalfExpand);
+        let result = later.since(&earlier, settings).unwrap();
+
+        assert_eq!(result.days(), 973.0);
+        assert_eq!(result.hours(), 3.0);
+
+        let settings =
+            create_diff_setting(TemporalUnit::Minute, 30, TemporalRoundingMode::HalfExpand);
+        let result = later.since(&earlier, settings).unwrap();
+
+        assert_eq!(result.days(), 973.0);
+        assert_eq!(result.hours(), 4.0);
+        assert_eq!(result.minutes(), 30.0);
+    }
 }

src/rounding.rs

@@ -100,7 +100,7 @@ impl Roundable for i128 {
     }
 
     fn compare_remainder(dividend: Self, divisor: Self) -> Option<Ordering> {
-        Some(dividend.rem_euclid(divisor).cmp(&divisor.div_euclid(2)))
+        Some((dividend.abs() % divisor).cmp(&(divisor / 2)))
     }
 
     fn is_even_cardinal(dividend: Self, divisor: Self) -> bool {
@@ -284,6 +284,14 @@ mod tests {
         .unwrap()
         .round(TemporalRoundingMode::Floor);
         assert_eq!(result, -10);
+
+        let result = IncrementRounder::<i128>::from_potentially_negative_parts(
+            -14,
+            NonZeroU128::new(3).unwrap(),
+        )
+        .unwrap()
+        .round(TemporalRoundingMode::HalfExpand);
+        assert_eq!(result, -15);
     }
 
     #[test]
@@ -304,4 +312,16 @@ mod tests {
         .round(TemporalRoundingMode::Floor);
         assert_eq!(result, -9);
     }
+
+    #[test]
+    fn dt_since_basic_rounding() {
+        let result = IncrementRounder::<i128>::from_potentially_negative_parts(
+            -84082624864197532,
+            NonZeroU128::new(1800000000000).unwrap(),
+        )
+        .unwrap()
+        .round(TemporalRoundingMode::HalfExpand);
+
+        assert_eq!(result, -84083400000000000);
+    }
 }