Initial implementation of Duration.prototype.total

src/builtins/compiled/duration.rs

@@ -1,6 +1,7 @@
 use crate::{
     builtins::TZ_PROVIDER,
     options::{RelativeTo, RoundingOptions, TemporalUnit},
+    primitive::FiniteF64,
     Duration, TemporalError, TemporalResult,
 };
 
@@ -44,7 +45,7 @@ impl Duration {
         &self,
         unit: TemporalUnit,
         relative_to: Option<RelativeTo>,
-    ) -> TemporalResult<i64> {
+    ) -> TemporalResult<FiniteF64> {
         let provider = TZ_PROVIDER
             .lock()
             .map_err(|_| TemporalError::general("Unable to acquire lock"))?;

src/builtins/compiled/duration/tests.rs

@@ -685,3 +685,118 @@ fn test_duration_compare() {
         )
     }
 }
+
+#[test]
+fn test_duration_total() {
+    let d1 = Duration::from_partial_duration(PartialDuration {
+        hours: Some(FiniteF64::from(130)),
+        minutes: Some(FiniteF64::from(20)),
+        ..Default::default()
+    })
+    .unwrap();
+    assert_eq!(d1.total(TemporalUnit::Second, None).unwrap(), 469200.0);
+
+    // How many 24-hour days is 123456789 seconds?
+    let d2 = Duration::from_str("PT123456789S").unwrap();
+    assert_eq!(
+        d2.total(TemporalUnit::Day, None).unwrap(),
+        1428.8980208333332
+    );
+
+    // Find totals in months, with and without taking DST into account
+    let d3 = Duration::from_partial_duration(PartialDuration {
+        hours: Some(FiniteF64::from(2756)),
+        ..Default::default()
+    })
+    .unwrap();
+    let relative_to = ZonedDateTime::from_str(
+        "2020-01-01T00:00+01:00[Europe/Rome]",
+        Default::default(),
+        OffsetDisambiguation::Reject,
+    )
+    .unwrap();
+    assert_eq!(
+        d3.total(
+            TemporalUnit::Month,
+            Some(RelativeTo::ZonedDateTime(relative_to))
+        )
+        .unwrap(),
+        3.7958333333333334
+    );
+    assert_eq!(
+        d3.total(
+            TemporalUnit::Month,
+            Some(RelativeTo::PlainDate(
+                PlainDate::new(2020, 1, 1, Calendar::default()).unwrap()
+            ))
+        )
+        .unwrap(),
+        3.7944444444444443
+    );
+}
+
+// balance-subseconds.js
+#[test]
+fn balance_subseconds() {
+    // Test positive
+    let pos = Duration::from_partial_duration(PartialDuration {
+        milliseconds: Some(FiniteF64::from(999)),
+        microseconds: Some(FiniteF64::from(999999)),
+        nanoseconds: Some(FiniteF64::from(999999999)),
+        ..Default::default()
+    })
+    .unwrap();
+    assert_eq!(pos.total(TemporalUnit::Second, None).unwrap(), 2.998998999);
+
+    // Test negative
+    let neg = Duration::from_partial_duration(PartialDuration {
+        milliseconds: Some(FiniteF64::from(-999)),
+        microseconds: Some(FiniteF64::from(-999999)),
+        nanoseconds: Some(FiniteF64::from(-999999999)),
+        ..Default::default()
+    })
+    .unwrap();
+    assert_eq!(neg.total(TemporalUnit::Second, None).unwrap(), -2.998998999);
+}
+
+// balances-days-up-to-both-years-and-months.js
+#[test]
+fn balance_days_up_to_both_years_and_months() {
+    // Test positive
+    let two_years = Duration::from_partial_duration(PartialDuration {
+        months: Some(FiniteF64::from(11)),
+        days: Some(FiniteF64::from(396)),
+        ..Default::default()
+    })
+    .unwrap();
+
+    let relative_to = PlainDate::new(2017, 1, 1, Calendar::default()).unwrap();
+
+    assert_eq!(
+        two_years
+            .total(
+                TemporalUnit::Year,
+                Some(RelativeTo::PlainDate(relative_to.clone()))
+            )
+            .unwrap(),
+        2.0
+    );
+
+    // Test negative
+    let two_years_negative = Duration::from_partial_duration(PartialDuration {
+        months: Some(FiniteF64::from(-11)),
+        days: Some(FiniteF64::from(-396)),
+        ..Default::default()
+    })
+    .unwrap();
+
+    assert_eq!(
+        two_years_negative
+            .total(
+                TemporalUnit::Year,
+                Some(RelativeTo::PlainDate(relative_to.clone()))
+            )
+            .unwrap(),
+        -2.0
+    );
+}

src/builtins/core/datetime.rs

@@ -12,6 +12,7 @@ use crate::{
         ResolvedRoundingOptions, RoundingOptions, TemporalUnit, ToStringRoundingOptions, UnitGroup,
     },
     parsers::{parse_date_time, IxdtfStringBuilder},
+    primitive::FiniteF64,
     provider::NeverProvider,
     temporal_assert, MonthCode, TemporalError, TemporalResult, TemporalUnwrap, TimeZone,
 };
@@ -202,6 +203,38 @@ impl PlainDateTime {
             options,
         )
     }
+
+    // 5.5.14 DifferencePlainDateTimeWithTotal ( isoDateTime1, isoDateTime2, calendar, unit )
+    pub(crate) fn diff_dt_with_total(
+        &self,
+        other: &Self,
+        unit: TemporalUnit,
+    ) -> TemporalResult<FiniteF64> {
+        // 1. If CompareISODateTime(isoDateTime1, isoDateTime2) = 0, then
+        //    a. Return 0.
+        if matches!(self.iso.cmp(&other.iso), Ordering::Equal) {
+            return FiniteF64::try_from(0.0);
+        }
+        // 2. If ISODateTimeWithinLimits(isoDateTime1) is false or ISODateTimeWithinLimits(isoDateTime2) is false, throw a RangeError exception.
+        if !self.iso.is_within_limits() || !other.iso.is_within_limits() {
+            return Err(TemporalError::range().with_message("DateTime is not within valid limits."));
+        }
+        // 3. Let diff be DifferenceISODateTime(isoDateTime1, isoDateTime2, calendar, unit).
+        let diff = self.iso.diff(&other.iso, &self.calendar, unit)?;
+        // 4. If unit is nanosecond, return diff.[[Time]].
+        if unit == TemporalUnit::Nanosecond {
+            return FiniteF64::try_from(diff.normalized_time_duration().0);
+        }
+        // 5. Let destEpochNs be GetUTCEpochNanoseconds(isoDateTime2).
+        let dest_epoch_ns = other.iso.as_nanoseconds()?;
+        // 6. Return ? TotalRelativeDuration(diff, destEpochNs, isoDateTime1, unset, calendar, unit).
+        diff.total_relative_duration(
+            dest_epoch_ns.0,
+            self,
+            Option::<(&TimeZone, &NeverProvider)>::None,
+            unit,
+        )
+    }
 }
 
 // ==== Public PlainDateTime API ====

src/builtins/core/duration.rs

@@ -686,11 +686,79 @@ impl Duration {
     /// Returns the total of the `Duration`
     pub fn total_with_provider(
         &self,
-        _unit: TemporalUnit,
-        _relative_to: Option<RelativeTo>,
-        _provider: &impl TimeZoneProvider,
-    ) -> TemporalResult<i64> {
-        Err(TemporalError::general("Not yet implemented"))
+        unit: TemporalUnit,
+        relative_to: Option<RelativeTo>,
+        provider: &impl TimeZoneProvider,
+        // Review question what is the return type of duration.prototye.total?
+    ) -> TemporalResult<FiniteF64> {
+        match relative_to {
+            // 11. If zonedRelativeTo is not undefined, then
+            Some(RelativeTo::ZonedDateTime(zoned_datetime)) => {
+                // a. Let internalDuration be ToInternalDurationRecord(duration).
+                // b. Let timeZone be zonedRelativeTo.[[TimeZone]].
+                // c. Let calendar be zonedRelativeTo.[[Calendar]].
+                // d. Let relativeEpochNs be zonedRelativeTo.[[EpochNanoseconds]].
+                // e. Let targetEpochNs be ? AddZonedDateTime(relativeEpochNs, timeZone, calendar, internalDuration, constrain).
+                let target_epcoh_ns =
+                    zoned_datetime.add_as_instant(self, ArithmeticOverflow::Constrain, provider)?;
+                // f. Let total be ? DifferenceZonedDateTimeWithTotal(relativeEpochNs, targetEpochNs, timeZone, calendar, unit).
+                let total = zoned_datetime.diff_with_total(
+                    &ZonedDateTime::new_unchecked(
+                        target_epcoh_ns,
+                        zoned_datetime.calendar().clone(),
+                        zoned_datetime.timezone().clone(),
+                    ),
+                    unit,
+                    provider,
+                )?;
+                Ok(total)
+            }
+            // 12. Else if plainRelativeTo is not undefined, then
+            Some(RelativeTo::PlainDate(plain_date)) => {
+                // a. Let internalDuration be ToInternalDurationRecordWith24HourDays(duration).
+                // b. Let targetTime be AddTime(MidnightTimeRecord(), internalDuration.[[Time]]).
+                let (balanced_days, time) =
+                    PlainTime::default().add_normalized_time_duration(self.time.to_normalized());
+                // c. Let calendar be plainRelativeTo.[[Calendar]].
+                // d. Let dateDuration be ! AdjustDateDurationRecord(internalDuration.[[Date]], targetTime.[[Days]]).
+                let date_duration = DateDuration::new(
+                    self.years(),
+                    self.months(),
+                    self.weeks(),
+                    self.days().checked_add(&FiniteF64::from(balanced_days))?,
+                )?;
+                // e. Let targetDate be ? CalendarDateAdd(calendar, plainRelativeTo.[[ISODate]], dateDuration, constrain).
+                let target_date = plain_date.calendar().date_add(
+                    &plain_date.iso,
+                    &Duration::from(date_duration),
+                    ArithmeticOverflow::Constrain,
+                )?;
+                // f. Let isoDateTime be CombineISODateAndTimeRecord(plainRelativeTo.[[ISODate]], MidnightTimeRecord()).
+                let iso_date_time = IsoDateTime::new_unchecked(plain_date.iso, IsoTime::default());
+                // g. Let targetDateTime be CombineISODateAndTimeRecord(targetDate, targetTime).
+                let target_date_time = IsoDateTime::new_unchecked(target_date.iso, time.iso);
+                // h. Let total be ? DifferencePlainDateTimeWithTotal(isoDateTime, targetDateTime, calendar, unit).
+                let plain_dt =
+                    PlainDateTime::new_unchecked(iso_date_time, plain_date.calendar().clone());
+                let total = plain_dt.diff_dt_with_total(
+                    &PlainDateTime::new_unchecked(target_date_time, plain_date.calendar().clone()),
+                    unit,
+                )?;
+                Ok(total)
+            }
+            None => {
+                // a. Let largestUnit be DefaultTemporalLargestUnit(duration).
+                let largest_unit = self.default_largest_unit();
+                // b. If IsCalendarUnit(largestUnit) is true, or IsCalendarUnit(unit) is true, throw a RangeError exception.
+                if largest_unit.is_calendar_unit() || unit.is_calendar_unit() {
+                    return Err(TemporalError::range());
+                }
+                // c. Let internalDuration be ToInternalDurationRecordWith24HourDays(duration).
+                // d. Let total be TotalTimeDuration(internalDuration.[[Time]], unit).
+                let total = self.time.to_normalized().total(unit)?;
+                Ok(total)
+            }
+        }
     }
 
     /// Returns the `Duration` as a formatted string