Bump ixdtf to revision + Implement to_string methods for Duration, PlainYearMonth, and PlainMonthDay

Author: nekevss

Cargo.lock

@@ -24,7 +24,7 @@ icu_calendar = { version = "2.0.0-beta1", default-features = false}
 rustc-hash = "2.1.0"
 bitflags = "2.7.0"
 num-traits = "0.2.19"
-ixdtf = "0.3.0"
+ixdtf = { git = "https://github.com/unicode-org/icu4x.git", rev = "3d187da4d3f05b7e37603c4be3f2c1ce45100e03" }
 iana-time-zone = "0.1.61"
 log = "0.4.0"
 tzif = "0.3.0"

Cargo.toml

@@ -687,13 +687,14 @@ pub fn duration_to_formattable(
     } else {
         IxdtfSign::Positive
     };
+    let duration = duration.abs();
     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,
+            days: duration.days().0 as u64,
         })
     } else {
         None
@@ -711,12 +712,12 @@ pub fn duration_to_formattable(
         duration.nanoseconds(),
     ));
 
-    let seconds = time.seconds().unsigned_abs() as u32;
+    let seconds = time.seconds().unsigned_abs() as u64;
     let subseconds = time.subseconds().unsigned_abs();
 
     let time = Some(TimeDurationRecord::Seconds {
-        hours: hours.0 as u32,
-        minutes: minutes.0 as u32,
+        hours: hours.0 as u64,
+        minutes: minutes.0 as u64,
         seconds,
         fraction: subseconds,
     });
@@ -893,7 +894,7 @@ impl FromStr for Duration {
                 let nanoseconds = rem.rem_euclid(1_000);
 
                 (
-                    f64::from(hours),
+                    hours as f64,
                     minutes as f64,
                     seconds as f64,
                     milliseconds as f64,
@@ -917,8 +918,8 @@ impl FromStr for Duration {
                 let nanoseconds = rem.rem_euclid(1_000);
 
                 (
-                    f64::from(hours),
-                    f64::from(minutes),
+                    hours as f64,
+                    minutes as f64,
                     seconds as f64,
                     milliseconds as f64,
                     microseconds as f64,
@@ -939,9 +940,9 @@ impl FromStr for Duration {
                 let nanoseconds = rem.rem_euclid(1_000);
 
                 (
-                    f64::from(hours),
-                    f64::from(minutes),
-                    f64::from(seconds),
+                    hours as f64,
+                    minutes as f64,
+                    seconds as f64,
                     milliseconds as f64,
                     microseconds as f64,
                     nanoseconds as f64,
@@ -962,7 +963,7 @@ impl FromStr for Duration {
             FiniteF64::from(years).copysign(sign),
             FiniteF64::from(months).copysign(sign),
             FiniteF64::from(weeks).copysign(sign),
-            FiniteF64::from(days).copysign(sign),
+            FiniteF64::try_from(days)?.copysign(sign),
             FiniteF64::try_from(hours)?.copysign(sign),
             FiniteF64::try_from(minutes)?.copysign(sign),
             FiniteF64::try_from(seconds)?.copysign(sign),

src/components/duration.rs

@@ -688,3 +688,44 @@ fn default_duration_string() {
     let result = duration.to_temporal_string(options).unwrap();
     assert_eq!(&result, "PT0.000S");
 }
+
+#[test]
+fn duration_to_string_auto_precision() {
+    let duration = Duration::new(1.into(), 2.into(), 3.into(), 4.into(), 5.into(), 6.into(), 7.into(), FiniteF64::default(), FiniteF64::default(), FiniteF64::default()).unwrap();
+    let result = duration.to_temporal_string(ToStringRoundingOptions::default()).unwrap();
+    assert_eq!(&result, "P1Y2M3W4DT5H6M7S");
+
+    let duration = Duration::new(1.into(), 2.into(), 3.into(), 4.into(), 5.into(), 6.into(), 7.into(), 987.into(), 650.into(), FiniteF64::default()).unwrap();
+    let result = duration.to_temporal_string(ToStringRoundingOptions::default()).unwrap();
+    assert_eq!(&result, "P1Y2M3W4DT5H6M7.98765S");
+}
+
+#[test]
+fn empty_date_duration() {
+    let duration = Duration::from_partial_duration(PartialDuration {
+        hours: Some(1.into()),
+        ..Default::default()
+    }).unwrap();
+    let result = duration.to_temporal_string(ToStringRoundingOptions::default()).unwrap();
+    assert_eq!(&result, "PT1H");
+}
+
+#[test]
+fn negative_fields_to_string() {
+    let duration = Duration::from_partial_duration(PartialDuration {
+        years: Some(FiniteF64::from(-1)),
+        months: Some(FiniteF64::from(-1)),
+        weeks: Some(FiniteF64::from(-1)),
+        days: Some(FiniteF64::from(-1)),
+        hours: Some(FiniteF64::from(-1)),
+        minutes: Some(FiniteF64::from(-1)),
+        seconds: Some(FiniteF64::from(-1)),
+        milliseconds: Some(FiniteF64::from(-1)),
+        microseconds: Some(FiniteF64::from(-1)),
+        nanoseconds: Some(FiniteF64::from(-1)),
+    }).unwrap();
+    let result = duration.to_temporal_string(ToStringRoundingOptions::default()).unwrap();
+    assert_eq!(&result, "-P1Y1M1W1DT1H1M1.001001001S");
+
+
+}

src/components/duration/tests.rs

@@ -377,7 +377,7 @@ impl Writeable for FormattableMonthDay<'_> {
     fn write_to<W: core::fmt::Write + ?Sized>(&self, sink: &mut W) -> core::fmt::Result {
         if self.calendar.show == DisplayCalendar::Always
             || self.calendar.show == DisplayCalendar::Critical
-            || self.calendar.calendar == "iso8601"
+            || self.calendar.calendar != "iso8601"
         {
             write_year(self.date.0, sink)?;
             sink.write_char('-')?;
@@ -392,7 +392,7 @@ impl Writeable for FormattableMonthDay<'_> {
         let base_length = self.calendar.writeable_length_hint() + LengthHint::exact(5);
         if self.calendar.show == DisplayCalendar::Always
             || self.calendar.show == DisplayCalendar::Critical
-            || self.calendar.calendar == "iso8601"
+            || self.calendar.calendar != "iso8601"
         {
             let year_length = if (0..=9999).contains(&self.date.0) {
                 4
@@ -418,7 +418,7 @@ impl Writeable for FormattableYearMonth<'_> {
         write_padded_u8(self.date.1, sink)?;
         if self.calendar.show == DisplayCalendar::Always
             || self.calendar.show == DisplayCalendar::Critical
-            || self.calendar.calendar == "iso8601"
+            || self.calendar.calendar != "iso8601"
         {
             sink.write_char('-')?;
             write_padded_u8(self.date.2, sink)?;
@@ -437,7 +437,7 @@ impl Writeable for FormattableYearMonth<'_> {
             self.calendar.writeable_length_hint() + LengthHint::exact(year_length + 3);
         if self.calendar.show == DisplayCalendar::Always
             || self.calendar.show == DisplayCalendar::Critical
-            || self.calendar.calendar == "iso8601"
+            || self.calendar.calendar != "iso8601"
         {
             return base_length + LengthHint::exact(3);
         }
@@ -524,10 +524,10 @@ impl Writeable for FormattableDuration {
         }
         sink.write_char('P')?;
         if let Some(date) = self.duration.date {
-            checked_write_with_suffix(date.years, 'Y', sink)?;
-            checked_write_with_suffix(date.months, 'M', sink)?;
-            checked_write_with_suffix(date.weeks, 'W', sink)?;
-            checked_write_with_suffix(date.days, 'D', sink)?;
+            checked_write_u32_with_suffix(date.years, 'Y', sink)?;
+            checked_write_u32_with_suffix(date.months, 'M', sink)?;
+            checked_write_u32_with_suffix(date.weeks, 'W', sink)?;
+            checked_write_u64_with_suffix(date.days, 'D', sink)?;
         }
         if let Some(time) = self.duration.time {
             sink.write_char('T')?;
@@ -548,7 +548,7 @@ impl Writeable for FormattableDuration {
                     minutes,
                     fraction,
                 } => {
-                    checked_write_with_suffix(hours, 'H', sink)?;
+                    checked_write_u64_with_suffix(hours, 'H', sink)?;
                     if minutes == 0 {
                         return Ok(());
                     }
@@ -565,18 +565,17 @@ impl Writeable for FormattableDuration {
                     seconds,
                     fraction,
                 } => {
-                    checked_write_with_suffix(hours, 'H', sink)?;
-                    checked_write_with_suffix(minutes, 'M', sink)?;
+                    checked_write_u64_with_suffix(hours, 'H', sink)?;
+                    checked_write_u64_with_suffix(minutes, 'M', sink)?;
                     let unit_below_minute =
-                        self.duration.date.is_none() || hours != 0 || minutes != 0;
+                        self.duration.date.is_none() && hours == 0 && minutes == 0;
                     if seconds != 0
                         || unit_below_minute
                         || matches!(self.precision, Precision::Digit(_))
                     {
                         seconds.write_to(sink)?;
-                        if self.precision == Precision::Auto
-                            || self.precision == Precision::Digit(0)
-                        {
+                        if self.precision == Precision::Digit(0)
+                            || (self.precision == Precision::Auto && fraction == 0) {
                             sink.write_char('S')?;
                             return Ok(());
                         }
@@ -591,7 +590,7 @@ impl Writeable for FormattableDuration {
     }
 }
 
-fn checked_write_with_suffix<W: core::fmt::Write + ?Sized>(
+fn checked_write_u32_with_suffix<W: core::fmt::Write + ?Sized>(
     val: u32,
     suffix: char,
     sink: &mut W,
@@ -603,6 +602,18 @@ fn checked_write_with_suffix<W: core::fmt::Write + ?Sized>(
     sink.write_char(suffix)
 }
 
+fn checked_write_u64_with_suffix<W: core::fmt::Write + ?Sized>(
+    val: u64,
+    suffix: char,
+    sink: &mut W,
+) -> core::fmt::Result {
+    if val == 0 {
+        return Ok(());
+    }
+    val.write_to(sink)?;
+    sink.write_char(suffix)
+}
+
 // TODO: Determine if these should be separate structs, i.e. TemporalDateTimeParser/TemporalInstantParser, or
 // maybe on global `TemporalParser` around `IxdtfParser` that handles the Temporal idiosyncracies.
 enum ParseVariant {