Remove previous round implementation and adjust fix tests

Author: nekevss

src/components/duration.rs

@@ -9,7 +9,7 @@ use crate::{
 use ixdtf::parsers::{records::TimeDurationRecord, IsoDurationParser};
 use std::str::FromStr;
 
-use self::normalized::{NormalizedDurationRecord, NormalizedTimeDuration};
+use self::normalized::NormalizedTimeDuration;
 
 mod date;
 pub(crate) mod normalized;
@@ -357,58 +357,6 @@ impl Duration {
     }
 }
 
-// ==== Private Duration methods ====
-
-impl Duration {
-    // TODO (nekevss): Build out `RelativeTo` handling
-    /// Abstract Operation 7.5.26 `RoundDuration ( years, months, weeks, days, hours, minutes,
-    ///   seconds, milliseconds, microseconds, nanoseconds, increment, unit,
-    ///   roundingMode [ , plainRelativeTo [, zonedRelativeTo [, precalculatedDateTime]]] )`
-    #[allow(clippy::type_complexity)]
-    pub(crate) fn round_internal(
-        &self,
-        increment: RoundingIncrement,
-        unit: TemporalUnit,
-        rounding_mode: TemporalRoundingMode,
-        relative_to: &RelativeTo,
-        precalculated_dt: Option<DateTime>,
-    ) -> TemporalResult<(NormalizedDurationRecord, f64)> {
-        match unit {
-            TemporalUnit::Year | TemporalUnit::Month | TemporalUnit::Week | TemporalUnit::Day => {
-                let round_result = self.date().round(
-                    Some(self.time.to_normalized()),
-                    increment,
-                    unit,
-                    rounding_mode,
-                    relative_to,
-                    precalculated_dt,
-                )?;
-                let norm_record = NormalizedDurationRecord::new(
-                    round_result.0,
-                    NormalizedTimeDuration::default(),
-                )?;
-                Ok((norm_record, round_result.1))
-            }
-            TemporalUnit::Hour
-            | TemporalUnit::Minute
-            | TemporalUnit::Second
-            | TemporalUnit::Millisecond
-            | TemporalUnit::Microsecond
-            | TemporalUnit::Nanosecond => {
-                let round_result = self.time().round(increment, unit, rounding_mode)?;
-                let norm = NormalizedDurationRecord::new(*self.date(), round_result.0)?;
-                Ok((norm, round_result.1 as f64))
-            }
-            TemporalUnit::Auto => {
-                Err(TemporalError::range().with_message("Invalid TemporalUnit for Duration.round"))
-            }
-        }
-        // 18. Let duration be ? CreateDurationRecord(years, months, weeks, days, hours,
-        // minutes, seconds, milliseconds, microseconds, nanoseconds).
-        // 19. Return the Record { [[DurationRecord]]: duration, [[Total]]: total }.
-    }
-}
-
 // ==== Public Duration methods ====
 
 impl Duration {
@@ -449,7 +397,7 @@ impl Duration {
     }
 
     #[inline]
-    pub fn round_v2(
+    pub fn round(
         &self,
         increment: Option<RoundingIncrement>,
         smallest_unit: Option<TemporalUnit>,
@@ -647,7 +595,9 @@ impl Duration {
             )?;
             // d. Let normWithDays be ? Add24HourDaysToNormalizedTimeDuration(roundRecord.[[NormalizedDuration]].[[NormalizedTime]],
             // roundRecord.[[NormalizedDuration]].[[Days]]).
-            let norm_with_days = round_record.0 .1.add_days(round_record.0 .0.days as i64)?;
+            let norm_with_days = round_record
+                .norm()
+                .add_days(round_record.date().days as i64)?;
             // e. Let balanceResult be ? BalanceTimeDuration(normWithDays, largestUnit).
             let (balanced_days, balanced_time) =
                 TimeDuration::from_normalized(norm_with_days, largest_unit)?;
@@ -660,202 +610,6 @@ impl Duration {
         // 41. Return ? CreateTemporalDuration(roundResult.[[Years]], roundResult.[[Months]], roundResult.[[Weeks]], roundResult.[[Days]], roundResult.[[Hours]], roundResult.[[Minutes]], roundResult.[[Seconds]], roundResult.[[Milliseconds]], roundResult.[[Microseconds]], roundResult.[[Nanoseconds]]).
         Ok(round_result)
     }
-
-    /// Rounds the current `Duration`.
-    #[inline]
-    pub fn round(
-        &self,
-        increment: Option<RoundingIncrement>,
-        smallest_unit: Option<TemporalUnit>,
-        largest_unit: Option<TemporalUnit>,
-        rounding_mode: Option<TemporalRoundingMode>,
-        relative_to: &RelativeTo,
-    ) -> TemporalResult<Self> {
-        // NOTE: Steps 1-14 seem to be implementation specific steps.
-
-        // 22. If smallestUnitPresent is false and largestUnitPresent is false, then
-        if largest_unit.is_none() && smallest_unit.is_none() {
-            // a. Throw a RangeError exception.
-            return Err(TemporalError::range()
-                .with_message("smallestUnit and largestUnit cannot both be None."));
-        }
-
-        // 14. Let roundingIncrement be ? ToTemporalRoundingIncrement(roundTo).
-        let increment = increment.unwrap_or_default();
-        // 15. Let roundingMode be ? ToTemporalRoundingMode(roundTo, "halfExpand").
-        let mode = rounding_mode.unwrap_or_default();
-
-        // 16. Let smallestUnit be ? GetTemporalUnit(roundTo, "smallestUnit", DATETIME, undefined).
-        // 17. If smallestUnit is undefined, then
-        // a. Set smallestUnitPresent to false.
-        // b. Set smallestUnit to "nanosecond".
-        let smallest_unit = smallest_unit.unwrap_or(TemporalUnit::Nanosecond);
-
-        // 18. Let existingLargestUnit be ! DefaultTemporalLargestUnit(duration.[[Years]],
-        // duration.[[Months]], duration.[[Weeks]], duration.[[Days]], duration.[[Hours]],
-        // duration.[[Minutes]], duration.[[Seconds]], duration.[[Milliseconds]],
-        // duration.[[Microseconds]]).
-        let existing_largest_unit = self.default_largest_unit();
-
-        // 19. Let defaultLargestUnit be LargerOfTwoTemporalUnits(existingLargestUnit, smallestUnit).
-        let default_largest = existing_largest_unit.max(smallest_unit);
-
-        // 20. If largestUnit is undefined, then
-        // a. Set largestUnitPresent to false.
-        // b. Set largestUnit to defaultLargestUnit.
-        // 21. Else if largestUnit is "auto", then
-        // a. Set largestUnit to defaultLargestUnit.
-        let largest_unit = match largest_unit {
-            Some(TemporalUnit::Auto) | None => default_largest,
-            Some(unit) => unit,
-        };
-
-        // 23. If LargerOfTwoTemporalUnits(largestUnit, smallestUnit) is not largestUnit, throw a RangeError exception.
-        if largest_unit.max(smallest_unit) != largest_unit {
-            return Err(TemporalError::range().with_message(
-                "largestUnit when rounding Duration was not the largest provided unit",
-            ));
-        }
-
-        // 24. Let maximum be MaximumTemporalDurationRoundingIncrement(smallestUnit).
-        let maximum = smallest_unit.to_maximum_rounding_increment();
-        // 25. If maximum is not undefined, perform ? ValidateTemporalRoundingIncrement(roundingIncrement, maximum, false).
-        if let Some(max) = maximum {
-            increment.validate(max.into(), false)?;
-        }
-
-        // 26. Let hoursToDaysConversionMayOccur be false.
-        // 27. If duration.[[Days]] ≠ 0 and zonedRelativeTo is not undefined, set hoursToDaysConversionMayOccur to true.
-        // 28. Else if abs(duration.[[Hours]]) ≥ 24, set hoursToDaysConversionMayOccur to true.
-        let hours_to_days_may_occur =
-            (self.days() != 0.0 && relative_to.zdt.is_some()) || self.hours().abs() >= 24.0;
-
-        // 29. If smallestUnit is "nanosecond" and roundingIncrement = 1, let roundingGranularityIsNoop
-        // be true; else let roundingGranularityIsNoop be false.
-        let is_noop =
-            smallest_unit == TemporalUnit::Nanosecond && increment == RoundingIncrement::ONE;
-        // 30. If duration.[[Years]] = 0 and duration.[[Months]] = 0 and duration.[[Weeks]] = 0,
-        // let calendarUnitsPresent be false; else let calendarUnitsPresent be true.
-        let calendar_units_present =
-            !(self.years() == 0.0 && self.months() == 0.0 && self.weeks() == 0.0);
-
-        // 31. If roundingGranularityIsNoop is true, and largestUnit is existingLargestUnit, and calendarUnitsPresent is false,
-        // and hoursToDaysConversionMayOccur is false, and abs(duration.[[Minutes]]) < 60, and abs(duration.[[Seconds]]) < 60,
-        // and abs(duration.[[Milliseconds]]) < 1000, and abs(duration.[[Microseconds]]) < 1000, and abs(duration.[[Nanoseconds]]) < 1000, then
-        if is_noop
-            && largest_unit == existing_largest_unit
-            && !calendar_units_present
-            && !hours_to_days_may_occur
-            && self.minutes().abs() < 60.0
-            && self.seconds().abs() < 60.0
-            && self.milliseconds() < 1000.0
-            && self.microseconds() < 1000.0
-            && self.nanoseconds() < 1000.0
-        {
-            // a. NOTE: The above conditions mean that the operation will have no effect: the
-            // smallest unit and rounding increment will leave the total duration unchanged,
-            // and it can be determined without calling a calendar or time zone method that
-            // no balancing will take place.
-            // b. Return ! CreateTemporalDuration(duration.[[Years]], duration.[[Months]],
-            // duration.[[Weeks]], duration.[[Days]], duration.[[Hours]], duration.[[Minutes]],
-            // duration.[[Seconds]], duration.[[Milliseconds]], duration.[[Microseconds]],
-            // duration.[[Nanoseconds]]).
-            return Ok(*self);
-        }
-
-        // 32. Let precalculatedPlainDateTime be undefined.
-        // 33. If roundingGranularityIsNoop is false, or IsCalendarUnit(largestUnit) is true, or largestUnit is "day",
-        // or calendarUnitsPresent is true, or duration.[[Days]] ≠ 0, let plainDateTimeOrRelativeToWillBeUsed be true;
-        // else let plainDateTimeOrRelativeToWillBeUsed be false.
-        let pdtr_will_be_used = !is_noop
-            || largest_unit.is_calendar_unit()
-            || largest_unit == TemporalUnit::Day
-            || calendar_units_present
-            || self.days() == 0.0;
-
-        // 34. If zonedRelativeTo is not undefined and plainDateTimeOrRelativeToWillBeUsed is true, then
-        let precalculated = if relative_to.zdt.is_some() && pdtr_will_be_used {
-            return Err(TemporalError::general("Not yet implemented."));
-            // a. NOTE: The above conditions mean that the corresponding Temporal.PlainDateTime or
-            // Temporal.PlainDate for zonedRelativeTo will be used in one of the operations below.
-            // b. Let instant be ! CreateTemporalInstant(zonedRelativeTo.[[Nanoseconds]]).
-            // c. Set precalculatedPlainDateTime to ? GetPlainDateTimeFor(timeZoneRec, instant, zonedRelativeTo.[[Calendar]]).
-            // d. Set plainRelativeTo to ! CreateTemporalDate(precalculatedPlainDateTime.[[ISOYear]],
-            // precalculatedPlainDateTime.[[ISOMonth]], precalculatedPlainDateTime.[[ISODay]], zonedRelativeTo.[[Calendar]]).
-        } else {
-            None
-        };
-        // 35. Let calendarRec be ? CreateCalendarMethodsRecordFromRelativeTo(plainRelativeTo, zonedRelativeTo, « DATE-ADD, DATE-UNTIL »).
-
-        // TODO: relativeTo will need to be removed soon.
-        let relative_to_date = relative_to.date;
-
-        // 36. Let unbalanceResult be ? UnbalanceDateDurationRelative(duration.[[Years]], duration.[[Months]], duration.[[Weeks]], duration.[[Days]], largestUnit, plainRelativeTo, calendarRec).
-        let unbalanced = self
-            .date()
-            .unbalance_relative(largest_unit, relative_to_date)?;
-
-        // NOTE: Step 37 handled in round duration
-        // 37. Let norm be NormalizeTimeDuration(duration.[[Hours]], duration.[[Minutes]], duration.[[Seconds]],
-        // duration.[[Milliseconds]], duration.[[Microseconds]], duration.[[Nanoseconds]]).
-        // 38. Let roundRecord be ? RoundDuration(unbalanceResult.[[Years]], unbalanceResult.[[Months]],
-        // unbalanceResult.[[Weeks]], unbalanceResult.[[Days]], norm, roundingIncrement, smallestUnit,
-        // roundingMode, plainRelativeTo, calendarRec, zonedRelativeTo, timeZoneRec, precalculatedPlainDateTime).
-        let (round_result, _) = Self::new_unchecked(unbalanced, *self.time()).round_internal(
-            increment,
-            smallest_unit,
-            mode,
-            relative_to,
-            precalculated,
-        )?;
-
-        // 39. Let roundResult be roundRecord.[[NormalizedDuration]].
-        // 40. If zonedRelativeTo is not undefined, then
-        let balance_result = if relative_to.zdt.is_some() {
-            return Err(TemporalError::general("Not yet implemented."));
-            // a. Set roundResult to ? AdjustRoundedDurationDays(roundResult.[[Years]], roundResult.[[Months]],
-            // roundResult.[[Weeks]], roundResult.[[Days]], roundResult.[[NormalizedTime]], roundingIncrement,
-            // smallestUnit, roundingMode, zonedRelativeTo, calendarRec, timeZoneRec, precalculatedPlainDateTime).
-            // b. Let balanceResult be ? BalanceTimeDurationRelative(roundResult.[[Days]],
-            // roundResult.[[NormalizedTime]], largestUnit, zonedRelativeTo, timeZoneRec, precalculatedPlainDateTime).
-            // 41. Else,
-        } else {
-            // NOTE: DateDuration::round will always return a NormalizedTime::default as per spec.
-            // a. Let normWithDays be ? Add24HourDaysToNormalizedTimeDuration(roundResult.[[NormalizedTime]], roundResult.[[Days]]).
-            let norm_with_days = round_result.0 .1.add_days(round_result.0 .0.days as i64)?;
-            // b. Let balanceResult be BalanceTimeDuration(normWithDays, largestUnit).
-            TimeDuration::from_normalized(norm_with_days, largest_unit)?
-        };
-
-        // 42. Let result be ? BalanceDateDurationRelative(roundResult.[[Years]],
-        // roundResult.[[Months]], roundResult.[[Weeks]], balanceResult.[[Days]],
-        // largestUnit, smallestUnit, plainRelativeTo, calendarRec).
-        let intermediate = DateDuration::new_unchecked(
-            round_result.0 .0.years,
-            round_result.0 .0.months,
-            round_result.0 .0.weeks,
-            balance_result.0,
-        );
-        let result =
-            intermediate.balance_relative(largest_unit, smallest_unit, relative_to_date)?;
-
-        // 43. Return ! CreateTemporalDuration(result.[[Years]], result.[[Months]],
-        // result.[[Weeks]], result.[[Days]], balanceResult.[[Hours]], balanceResult.[[Minutes]],
-        // balanceResult.[[Seconds]], balanceResult.[[Milliseconds]], balanceResult.[[Microseconds]],
-        // balanceResult.[[Nanoseconds]]).
-        Self::new(
-            result.years,
-            result.months,
-            result.weeks,
-            result.days,
-            balance_result.1.hours,
-            balance_result.1.minutes,
-            balance_result.1.seconds,
-            balance_result.1.milliseconds,
-            balance_result.1.microseconds,
-            balance_result.1.nanoseconds,
-        )
-    }
 }
 
 // TODO: Update, optimize, and fix the below. is_valid_duration should probably be generic over a T.