Add initial implementation of to_string methods for Duration, PlainMonthDay, and PlainYearMonth

Author: nekevss

src/components/duration.rs

@@ -4,16 +4,22 @@ use crate::{
     components::{timezone::TzProvider, PlainDateTime, PlainTime},
     iso::{IsoDateTime, IsoTime},
     options::{
-        ArithmeticOverflow, RelativeTo, ResolvedRoundingOptions, RoundingOptions, TemporalUnit,
+        ArithmeticOverflow, RelativeTo, ResolvedRoundingOptions, RoundingIncrement,
+        RoundingOptions, TemporalUnit, ToStringRoundingOptions,
     },
+    parsers::{FormattableDuration, Precision},
     primitive::FiniteF64,
     temporal_assert, Sign, TemporalError, TemporalResult,
 };
 use alloc::format;
+use alloc::string::String;
 use alloc::vec;
 use alloc::vec::Vec;
 use core::str::FromStr;
-use ixdtf::parsers::{records::TimeDurationRecord, IsoDurationParser};
+use ixdtf::parsers::{
+    records::{DateDurationRecord, DurationParseRecord, Sign as IxdtfSign, TimeDurationRecord},
+    IsoDurationParser,
+};
 use normalized::NormalizedDurationRecord;
 use num_traits::AsPrimitive;
 
@@ -26,7 +32,6 @@ mod date;
 pub(crate) mod normalized;
 mod time;
 
-#[cfg(feature = "experimental")]
 #[cfg(test)]
 mod tests;
 
@@ -83,6 +88,16 @@ pub struct Duration {
     time: TimeDuration,
 }
 
+impl core::fmt::Display for Duration {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        f.write_str(
+            &self
+                .to_temporal_string(ToStringRoundingOptions::default())
+                .expect("Duration must return a valid string with default options."),
+        )
+    }
+}
+
 // NOTE(nekevss): Structure of the below is going to be a little convoluted,
 // but intended to section everything based on the below
 //
@@ -619,6 +634,97 @@ impl Duration {
             }
         }
     }
+
+    pub fn to_temporal_string(&self, options: ToStringRoundingOptions) -> TemporalResult<String> {
+        if options.smallest_unit == Some(TemporalUnit::Hour)
+            || options.smallest_unit == Some(TemporalUnit::Minute)
+        {
+            return Err(TemporalError::range().with_message(
+                "string rounding options cannot have hour or minute smallest unit.",
+            ));
+        }
+
+        let resolved_options = options.resolve()?;
+        if resolved_options.smallest_unit == TemporalUnit::Nanosecond
+            && resolved_options.increment == RoundingIncrement::ONE
+        {
+            let duration = duration_to_formattable(self, resolved_options.precision)?;
+            return Ok(duration.to_string());
+        }
+
+        let rounding_options = ResolvedRoundingOptions::from_to_string_options(&resolved_options);
+
+        // 11. Let largestUnit be DefaultTemporalLargestUnit(duration).
+        let largest = self.default_largest_unit();
+        // 12. Let internalDuration be ToInternalDurationRecord(duration).
+        let norm = NormalizedDurationRecord::new(
+            self.date,
+            NormalizedTimeDuration::from_time_duration(&self.time),
+        )?;
+        // 13. Let timeDuration be ? RoundTimeDuration(internalDuration.[[Time]], precision.[[Increment]], precision.[[Unit]], roundingMode).
+        let (rounded, _) = norm
+            .normalized_time_duration()
+            .round(FiniteF64::default(), rounding_options)?;
+        // 14. Set internalDuration to CombineDateAndTimeDuration(internalDuration.[[Date]], timeDuration).
+        let norm = NormalizedDurationRecord::new(norm.date(), rounded.normalized_time_duration())?;
+        // 15. Let roundedLargestUnit be LargerOfTwoTemporalUnits(largestUnit, second).
+        let rounded_largest = largest.max(TemporalUnit::Second);
+        // 16. Let roundedDuration be ? TemporalDurationFromInternal(internalDuration, roundedLargestUnit).
+        let rounded = Self::from_normalized(norm, rounded_largest)?;
+
+        // 17. Return TemporalDurationToString(roundedDuration, precision.[[Precision]]).
+        Ok(duration_to_formattable(&rounded, resolved_options.precision)?.to_string())
+    }
+}
+
+pub fn duration_to_formattable(
+    duration: &Duration,
+    precision: Precision,
+) -> TemporalResult<FormattableDuration> {
+    let sign = duration.sign();
+    let sign = if sign == Sign::Negative {
+        IxdtfSign::Negative
+    } else {
+        IxdtfSign::Positive
+    };
+    let date = duration.years().0 + duration.months().0 + duration.weeks().0 + duration.days().0;
+    let date = if date != 0.0 {
+        Some(DateDurationRecord {
+            years: duration.years().0 as u32,
+            months: duration.months().0 as u32,
+            weeks: duration.weeks().0 as u32,
+            days: duration.days().0 as u32,
+        })
+    } else {
+        None
+    };
+
+    let hours = duration.hours().abs();
+    let minutes = duration.minutes().abs();
+
+    let time = NormalizedTimeDuration::from_time_duration(&TimeDuration::new_unchecked(
+        FiniteF64::default(),
+        FiniteF64::default(),
+        duration.seconds(),
+        duration.milliseconds(),
+        duration.microseconds(),
+        duration.nanoseconds(),
+    ));
+
+    let seconds = time.seconds().unsigned_abs() as u32;
+    let subseconds = time.subseconds().unsigned_abs();
+
+    let time = Some(TimeDurationRecord::Seconds {
+        hours: hours.0 as u32,
+        minutes: minutes.0 as u32,
+        seconds,
+        fraction: subseconds,
+    });
+
+    Ok(FormattableDuration {
+        precision,
+        duration: DurationParseRecord { sign, date, time },
+    })
 }
 
 #[cfg(feature = "experimental")]

src/components/duration/tests.rs

@@ -1,3 +1,4 @@
+#[cfg(feature = "experimental")]
 use crate::{
     components::{calendar::Calendar, PlainDate},
     options::{RoundingIncrement, TemporalRoundingMode},
@@ -6,6 +7,7 @@ use crate::{
 
 use super::*;
 
+#[cfg(feature = "experimental")]
 fn get_round_result(
     test_duration: &Duration,
     relative_to: RelativeTo,
@@ -21,6 +23,7 @@ fn get_round_result(
 }
 
 // roundingmode-floor.js
+#[cfg(feature = "experimental")]
 #[test]
 fn basic_positive_floor_rounding_v2() {
     let test_duration = Duration::new(
@@ -89,6 +92,7 @@ fn basic_positive_floor_rounding_v2() {
 }
 
 #[test]
+#[cfg(feature = "experimental")]
 fn basic_negative_floor_rounding_v2() {
     // Test setup
     let test_duration = Duration::new(
@@ -158,6 +162,7 @@ fn basic_negative_floor_rounding_v2() {
 }
 
 // roundingmode-ceil.js
+#[cfg(feature = "experimental")]
 #[test]
 fn basic_positive_ceil_rounding() {
     let test_duration = Duration::new(
@@ -225,6 +230,7 @@ fn basic_positive_ceil_rounding() {
     assert_eq!(&result, &[5, 7, 0, 27, 16, 30, 20, 123, 987, 500],);
 }
 
+#[cfg(feature = "experimental")]
 #[test]
 fn basic_negative_ceil_rounding() {
     let test_duration = Duration::new(
@@ -293,6 +299,7 @@ fn basic_negative_ceil_rounding() {
 }
 
 // roundingmode-expand.js
+#[cfg(feature = "experimental")]
 #[test]
 fn basic_positive_expand_rounding() {
     let test_duration = Duration::new(
@@ -359,6 +366,7 @@ fn basic_positive_expand_rounding() {
     assert_eq!(&result, &[5, 7, 0, 27, 16, 30, 20, 123, 987, 500],);
 }
 
+#[cfg(feature = "experimental")]
 #[test]
 fn basic_negative_expand_rounding() {
     let test_duration = Duration::new(
@@ -429,6 +437,7 @@ fn basic_negative_expand_rounding() {
 }
 
 // test262/test/built-ins/Temporal/Duration/prototype/round/roundingincrement-non-integer.js
+#[cfg(feature = "experimental")]
 #[test]
 fn rounding_increment_non_integer() {
     let test_duration = Duration::from(
@@ -609,6 +618,7 @@ fn partial_duration_values() {
 }
 
 // days-24-hours-relative-to-zoned-date-time.js
+#[cfg(feature = "experimental")]
 #[test]
 fn round_relative_to_zoned_datetime() {
     let duration = Duration::from(
@@ -641,3 +651,40 @@ fn round_relative_to_zoned_datetime() {
     assert_eq!(result.days(), 1.0);
     assert_eq!(result.hours(), 1.0);
 }
+
+#[test]
+fn default_duration_string() {
+    let duration = Duration::default();
+
+    let options = ToStringRoundingOptions {
+        precision: Precision::Auto,
+        smallest_unit: None,
+        rounding_mode: None,
+    };
+    let result = duration.to_temporal_string(options).unwrap();
+    assert_eq!(&result, "PT0S");
+
+    let options = ToStringRoundingOptions {
+        precision: Precision::Digit(0),
+        smallest_unit: None,
+        rounding_mode: None,
+    };
+    let result = duration.to_temporal_string(options).unwrap();
+    assert_eq!(&result, "PT0S");
+
+    let options = ToStringRoundingOptions {
+        precision: Precision::Digit(1),
+        smallest_unit: None,
+        rounding_mode: None,
+    };
+    let result = duration.to_temporal_string(options).unwrap();
+    assert_eq!(&result, "PT0.0S");
+
+    let options = ToStringRoundingOptions {
+        precision: Precision::Digit(3),
+        smallest_unit: None,
+        rounding_mode: None,
+    };
+    let result = duration.to_temporal_string(options).unwrap();
+    assert_eq!(&result, "PT0.000S");
+}

src/components/month_day.rs

@@ -1,12 +1,16 @@
 //! This module implements `MonthDay` and any directly related algorithms.
 
+use alloc::string::String;
 use core::str::FromStr;
 
 use tinystr::TinyAsciiStr;
 
 use crate::{
-    components::calendar::Calendar, iso::IsoDate, options::ArithmeticOverflow, TemporalError,
-    TemporalResult, TemporalUnwrap,
+    components::calendar::Calendar,
+    iso::IsoDate,
+    options::{ArithmeticOverflow, DisplayCalendar},
+    parsers::{FormattableCalendar, FormattableDate, FormattableMonthDay},
+    TemporalError, TemporalResult, TemporalUnwrap,
 };
 
 use super::calendar::{CalendarDateLike, GetTemporalCalendar};
@@ -19,6 +23,12 @@ pub struct PlainMonthDay {
     calendar: Calendar,
 }
 
+impl core::fmt::Display for PlainMonthDay {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        f.write_str(&self.to_ixdtf_string(DisplayCalendar::Auto))
+    }
+}
+
 impl PlainMonthDay {
     /// Creates a new unchecked `MonthDay`
     #[inline]
@@ -82,6 +92,17 @@ impl PlainMonthDay {
     pub fn month_code(&self) -> TemporalResult<TinyAsciiStr<4>> {
         self.calendar.month_code(&CalendarDateLike::MonthDay(self))
     }
+
+    pub fn to_ixdtf_string(&self, display_calendar: DisplayCalendar) -> String {
+        let ixdtf = FormattableMonthDay {
+            date: FormattableDate(self.iso_year(), self.iso_month(), self.iso.day),
+            calendar: FormattableCalendar {
+                show: display_calendar,
+                calendar: self.calendar().identifier(),
+            },
+        };
+        ixdtf.to_string()
+    }
 }
 
 impl GetTemporalCalendar for PlainMonthDay {

src/components/timezone.rs

@@ -74,6 +74,9 @@ impl TzProvider for NeverProvider {
     }
 }
 
+// TODO: There may be an argument to have Offset minutes be a (Cow<'a, str>,, i16) to
+// prevent allocations / writing, TBD
+// TODO: Potentially use Cow?
 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
 pub enum TimeZone {
     IanaIdentifier(String),

src/components/year_month.rs

@@ -6,7 +6,11 @@ use core::str::FromStr;
 use tinystr::TinyAsciiStr;
 
 use crate::{
-    components::calendar::Calendar, iso::IsoDate, options::ArithmeticOverflow, utils::pad_iso_year,
+    components::calendar::Calendar,
+    iso::IsoDate,
+    options::{ArithmeticOverflow, DisplayCalendar},
+    parsers::{FormattableCalendar, FormattableDate, FormattableYearMonth},
+    utils::pad_iso_year,
     TemporalError, TemporalResult, TemporalUnwrap,
 };
 
@@ -23,6 +27,12 @@ pub struct PlainYearMonth {
     calendar: Calendar,
 }
 
+impl core::fmt::Display for PlainYearMonth {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        f.write_str(&self.to_ixdtf_string(DisplayCalendar::Auto))
+    }
+}
+
 impl PlainYearMonth {
     /// Creates an unvalidated `YearMonth`.
     #[inline]
@@ -158,6 +168,17 @@ impl PlainYearMonth {
         self.get_calendar()
             .year_month_from_partial(&result_fields, overflow)
     }
+
+    pub fn to_ixdtf_string(&self, display_calendar: DisplayCalendar) -> String {
+        let ixdtf = FormattableYearMonth {
+            date: FormattableDate(self.iso_year(), self.iso_month(), self.iso.day),
+            calendar: FormattableCalendar {
+                show: display_calendar,
+                calendar: self.calendar().identifier(),
+            },
+        };
+        ixdtf.to_string()
+    }
 }
 
 impl GetTemporalCalendar for PlainYearMonth {