Extend implementation of to_ixdtf_string to more types (#155)

This PR continues the work on implementing `toString` functionality in
`temporal_rs`.

It completes the following:

- Adds `to_ixdtf_string` functions on `DateTime`, `Time`,
`ZonedDateTime`, and `Instant`.
- Adds `ToStringRoundingOptions` options type.
- Adds an `IxdtfStringBuilder` struct to assist with building `ixdtf`
strings.

So far I have verfied that the PR has a 100% conformance rate for
PlainDateTime. I plan to test the others, but any poentially issues that
may arise with those could always be completed in subsequent PRs.

Author: nekevss

src/components/date.rs

@@ -11,7 +11,7 @@ use crate::{
         ArithmeticOverflow, DifferenceOperation, DifferenceSettings, DisplayCalendar,
         ResolvedRoundingOptions, TemporalUnit,
     },
-    parsers::{parse_date_time, FormattableCalendar, FormattableDate, FormattableIxdtf},
+    parsers::{parse_date_time, IxdtfStringBuilder},
     primitive::FiniteF64,
     Sign, TemporalError, TemporalResult, TemporalUnwrap, TimeZone,
 };
@@ -593,17 +593,10 @@ impl PlainDate {
 
     #[inline]
     pub fn to_ixdtf_string(&self, display_calendar: DisplayCalendar) -> String {
-        let ixdtf = FormattableIxdtf {
-            date: Some(FormattableDate(self.iso.year, self.iso.month, self.iso.day)),
-            time: None,
-            utc_offset: None,
-            timezone: None,
-            calendar: Some(FormattableCalendar {
-                show: display_calendar,
-                calendar: self.calendar.identifier(),
-            }),
-        };
-        ixdtf.to_string()
+        IxdtfStringBuilder::default()
+            .with_date(self.iso)
+            .with_calendar(self.calendar.identifier(), display_calendar)
+            .build()
     }
 }
 

src/components/datetime.rs

@@ -4,22 +4,22 @@ use crate::{
     components::{calendar::Calendar, Instant},
     iso::{IsoDate, IsoDateTime, IsoTime},
     options::{
-        ArithmeticOverflow, DifferenceOperation, DifferenceSettings, ResolvedRoundingOptions,
-        RoundingOptions, TemporalUnit,
+        ArithmeticOverflow, DifferenceOperation, DifferenceSettings, DisplayCalendar,
+        ResolvedRoundingOptions, RoundingOptions, TemporalUnit, ToStringRoundingOptions,
     },
-    parsers::parse_date_time,
+    parsers::{parse_date_time, IxdtfStringBuilder},
     temporal_assert, Sign, TemporalError, TemporalResult, TemporalUnwrap, TimeZone,
 };
-
+use alloc::string::String;
 use core::{cmp::Ordering, str::FromStr};
-use tinystr::TinyAsciiStr;
 
 use super::{
     calendar::{CalendarDateLike, GetTemporalCalendar},
     duration::normalized::{NormalizedDurationRecord, NormalizedTimeDuration},
     timezone::NeverProvider,
     Duration, PartialDate, PartialTime, PlainDate, PlainTime,
 };
+use tinystr::TinyAsciiStr;
 
 /// A partial PlainDateTime record
 #[derive(Debug, Default, Clone)]
@@ -38,6 +38,15 @@ pub struct PlainDateTime {
     calendar: Calendar,
 }
 
+impl core::fmt::Display for PlainDateTime {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        let ixdtf_str = self
+            .to_ixdtf_string(ToStringRoundingOptions::default(), DisplayCalendar::Auto)
+            .expect("ixdtf default configuration should not fail.");
+        f.write_str(&ixdtf_str)
+    }
+}
+
 impl Ord for PlainDateTime {
     fn cmp(&self, other: &Self) -> Ordering {
         self.iso.cmp(&other.iso)
@@ -619,6 +628,28 @@ impl PlainDateTime {
 
         Ok(Self::new_unchecked(result, self.calendar.clone()))
     }
+
+    pub fn to_ixdtf_string(
+        &self,
+        options: ToStringRoundingOptions,
+        display_calendar: DisplayCalendar,
+    ) -> TemporalResult<String> {
+        let resolved_options = options.resolve()?;
+        let result = self
+            .iso
+            .round(ResolvedRoundingOptions::from_to_string_options(
+                &resolved_options,
+            ))?;
+        if !result.is_within_limits() {
+            return Err(TemporalError::range().with_message("DateTime is not within valid limits."));
+        }
+        let ixdtf_string = IxdtfStringBuilder::default()
+            .with_date(result.date)
+            .with_time(result.time, resolved_options.precision)
+            .with_calendar(self.calendar.identifier(), display_calendar)
+            .build();
+        Ok(ixdtf_string)
+    }
 }
 
 // ==== Trait impls ====
@@ -682,9 +713,10 @@ mod tests {
         },
         iso::{IsoDate, IsoDateTime, IsoTime},
         options::{
-            DifferenceSettings, RoundingIncrement, RoundingOptions, TemporalRoundingMode,
-            TemporalUnit,
+            DifferenceSettings, DisplayCalendar, RoundingIncrement, RoundingOptions,
+            TemporalRoundingMode, TemporalUnit, ToStringRoundingOptions,
         },
+        parsers::Precision,
         primitive::FiniteF64,
         TemporalResult,
     };
@@ -1098,4 +1130,156 @@ mod tests {
             .unwrap();
         assert_datetime(result, (1976, 11, 18, 14, 23, 30, 123, 456, 790));
     }
+
+    // Mapped from fractionaldigits-number.js
+    #[test]
+    fn to_string_precision_digits() {
+        let few_seconds =
+            PlainDateTime::try_new(1976, 2, 4, 5, 3, 1, 0, 0, 0, Calendar::default()).unwrap();
+        let zero_seconds =
+            PlainDateTime::try_new(1976, 11, 18, 15, 23, 0, 0, 0, 0, Calendar::default()).unwrap();
+        let whole_seconds =
+            PlainDateTime::try_new(1976, 11, 18, 15, 23, 30, 0, 0, 0, Calendar::default()).unwrap();
+        let subseconds =
+            PlainDateTime::try_new(1976, 11, 18, 15, 23, 30, 123, 400, 0, Calendar::default())
+                .unwrap();
+
+        let options = ToStringRoundingOptions {
+            precision: Precision::Digit(0),
+            smallest_unit: None,
+            rounding_mode: None,
+        };
+        assert_eq!(
+            &few_seconds
+                .to_ixdtf_string(options, DisplayCalendar::Auto)
+                .unwrap(),
+            "1976-02-04T05:03:01",
+            "pads parts with 0"
+        );
+
+        let options = ToStringRoundingOptions {
+            precision: Precision::Digit(0),
+            smallest_unit: None,
+            rounding_mode: None,
+        };
+        assert_eq!(
+            &subseconds
+                .to_ixdtf_string(options, DisplayCalendar::Auto)
+                .unwrap(),
+            "1976-11-18T15:23:30",
+            "truncates 4 decimal places to 0"
+        );
+
+        let options = ToStringRoundingOptions {
+            precision: Precision::Digit(2),
+            smallest_unit: None,
+            rounding_mode: None,
+        };
+        assert_eq!(
+            &zero_seconds
+                .to_ixdtf_string(options, DisplayCalendar::Auto)
+                .unwrap(),
+            "1976-11-18T15:23:00.00",
+            "pads zero seconds to 2 decimal places"
+        );
+        let options = ToStringRoundingOptions {
+            precision: Precision::Digit(2),
+            smallest_unit: None,
+            rounding_mode: None,
+        };
+
+        assert_eq!(
+            &whole_seconds
+                .to_ixdtf_string(options, DisplayCalendar::Auto)
+                .unwrap(),
+            "1976-11-18T15:23:30.00",
+            "pads whole seconds to 2 decimal places"
+        );
+        let options = ToStringRoundingOptions {
+            precision: Precision::Digit(2),
+            smallest_unit: None,
+            rounding_mode: None,
+        };
+        assert_eq!(
+            &subseconds
+                .to_ixdtf_string(options, DisplayCalendar::Auto)
+                .unwrap(),
+            "1976-11-18T15:23:30.12",
+            "truncates 4 decimal places to 2"
+        );
+
+        let options = ToStringRoundingOptions {
+            precision: Precision::Digit(3),
+            smallest_unit: None,
+            rounding_mode: None,
+        };
+        assert_eq!(
+            &subseconds
+                .to_ixdtf_string(options, DisplayCalendar::Auto)
+                .unwrap(),
+            "1976-11-18T15:23:30.123",
+            "truncates 4 decimal places to 3"
+        );
+
+        let options = ToStringRoundingOptions {
+            precision: Precision::Digit(6),
+            smallest_unit: None,
+            rounding_mode: None,
+        };
+        assert_eq!(
+            &subseconds
+                .to_ixdtf_string(options, DisplayCalendar::Auto)
+                .unwrap(),
+            "1976-11-18T15:23:30.123400",
+            "pads 4 decimal places to 6"
+        );
+        let options = ToStringRoundingOptions {
+            precision: Precision::Digit(7),
+            smallest_unit: None,
+            rounding_mode: None,
+        };
+        assert_eq!(
+            &zero_seconds
+                .to_ixdtf_string(options, DisplayCalendar::Auto)
+                .unwrap(),
+            "1976-11-18T15:23:00.0000000",
+            "pads zero seconds to 7 decimal places"
+        );
+        let options = ToStringRoundingOptions {
+            precision: Precision::Digit(7),
+            smallest_unit: None,
+            rounding_mode: None,
+        };
+        assert_eq!(
+            &whole_seconds
+                .to_ixdtf_string(options, DisplayCalendar::Auto)
+                .unwrap(),
+            "1976-11-18T15:23:30.0000000",
+            "pads whole seconds to 7 decimal places"
+        );
+        let options = ToStringRoundingOptions {
+            precision: Precision::Digit(7),
+            smallest_unit: None,
+            rounding_mode: None,
+        };
+        assert_eq!(
+            &subseconds
+                .to_ixdtf_string(options, DisplayCalendar::Auto)
+                .unwrap(),
+            "1976-11-18T15:23:30.1234000",
+            "pads 4 decimal places to 7"
+        );
+        let options = ToStringRoundingOptions {
+            precision: Precision::Digit(9),
+            smallest_unit: None,
+            rounding_mode: None,
+        };
+        assert_eq!(
+            &subseconds
+                .to_ixdtf_string(options, DisplayCalendar::Auto)
+                .unwrap(),
+            "1976-11-18T15:23:30.123400000",
+            "pads 4 decimal places to 9"
+        );
+    }
 }

src/components/instant.rs

@@ -1,24 +1,30 @@
 //! An implementation of the Temporal Instant.
 
+use alloc::string::String;
 use core::{num::NonZeroU128, str::FromStr};
 
 use crate::{
-    components::{duration::TimeDuration, Duration},
+    components::{
+        duration::TimeDuration, zoneddatetime::nanoseconds_to_formattable_offset_minutes, Duration,
+    },
     iso::{IsoDate, IsoDateTime, IsoTime},
     options::{
-        ArithmeticOverflow, DifferenceOperation, DifferenceSettings, ResolvedRoundingOptions,
-        RoundingOptions, TemporalUnit,
+        ArithmeticOverflow, DifferenceOperation, DifferenceSettings, DisplayOffset,
+        ResolvedRoundingOptions, RoundingOptions, TemporalUnit, ToStringRoundingOptions,
     },
-    parsers::parse_instant,
+    parsers::{parse_instant, IxdtfStringBuilder},
     primitive::FiniteF64,
     rounding::{IncrementRounder, Round},
-    Sign, TemporalError, TemporalResult, TemporalUnwrap, NS_MAX_INSTANT,
+    Sign, TemporalError, TemporalResult, TemporalUnwrap, TimeZone, NS_MAX_INSTANT,
 };
 
 use ixdtf::parsers::records::UtcOffsetRecordOrZ;
 use num_traits::FromPrimitive;
 
-use super::duration::normalized::{NormalizedDurationRecord, NormalizedTimeDuration};
+use super::{
+    duration::normalized::{NormalizedDurationRecord, NormalizedTimeDuration},
+    timezone::TzProvider,
+};
 
 const NANOSECONDS_PER_SECOND: f64 = 1e9;
 const NANOSECONDS_PER_MINUTE: f64 = 60f64 * NANOSECONDS_PER_SECOND;
@@ -264,6 +270,41 @@ impl Instant {
     }
 }
 
+// ==== Instant Provider API ====
+
+impl Instant {
+    pub fn to_ixdtf_string_with_provider(
+        &self,
+        timezone: Option<&TimeZone>,
+        options: ToStringRoundingOptions,
+        provider: &impl TzProvider,
+    ) -> TemporalResult<String> {
+        let resolved_options = options.resolve()?;
+        let round = self.round_instant(ResolvedRoundingOptions::from_to_string_options(
+            &resolved_options,
+        ))?;
+        let rounded_instant = Instant::try_new(round)?;
+
+        let mut ixdtf = IxdtfStringBuilder::default();
+        let datetime = if let Some(timezone) = timezone {
+            let datetime = timezone.get_iso_datetime_for(&rounded_instant, provider)?;
+            let nanoseconds = timezone.get_offset_nanos_for(rounded_instant.as_i128(), provider)?;
+            let (sign, hour, minute) = nanoseconds_to_formattable_offset_minutes(nanoseconds)?;
+            ixdtf = ixdtf.with_minute_offset(sign, hour, minute, DisplayOffset::Auto);
+            datetime
+        } else {
+            ixdtf = ixdtf.with_z(DisplayOffset::Auto);
+            TimeZone::default().get_iso_datetime_for(&rounded_instant, provider)?
+        };
+        let ixdtf_string = ixdtf
+            .with_date(datetime.date)
+            .with_time(datetime.time, resolved_options.precision)
+            .build();
+
+        Ok(ixdtf_string)
+    }
+}
+
 // ==== Utility Functions ====
 
 /// Utility for determining if the nanos are within a valid range.

src/components/time.rs

@@ -1,23 +1,22 @@
 //! This module implements `Time` and any directly related algorithms.
 
-use num_traits::AsPrimitive;
-
 use crate::{
     components::{duration::TimeDuration, Duration},
     iso::IsoTime,
     options::{
         ArithmeticOverflow, DifferenceOperation, DifferenceSettings, ResolvedRoundingOptions,
-        RoundingIncrement, TemporalRoundingMode, TemporalUnit,
+        RoundingIncrement, TemporalRoundingMode, TemporalUnit, ToStringRoundingOptions,
     },
-    parsers::parse_time,
+    parsers::{parse_time, IxdtfStringBuilder},
     primitive::FiniteF64,
     Sign, TemporalError, TemporalResult,
 };
+use alloc::string::String;
+use core::str::FromStr;
+use num_traits::AsPrimitive;
 
 use super::{duration::normalized::NormalizedTimeDuration, PlainDateTime};
 
-use core::str::FromStr;
-
 /// A `PartialTime` represents partially filled `Time` fields.
 #[derive(Debug, Default, Clone, Copy, PartialEq)]
 pub struct PartialTime {
@@ -434,6 +433,17 @@ impl PlainTime {
 
         Ok(Self::new_unchecked(result))
     }
+
+    pub fn to_ixdtf_string(&self, options: ToStringRoundingOptions) -> TemporalResult<String> {
+        let resolved = options.resolve()?;
+        let (_, result) = self
+            .iso
+            .round(ResolvedRoundingOptions::from_to_string_options(&resolved))?;
+        let ixdtf_string = IxdtfStringBuilder::default()
+            .with_time(result, resolved.precision)
+            .build();
+        Ok(ixdtf_string)
+    }
 }
 
 impl From<PlainDateTime> for PlainTime {