Add PartialTime and PartialDateTime with corresponding with methods. (#92)

This continues the work on implementing `with` methods with the approach
from #89 by adding the same type of records to `DateTime` and `Time`.

Author: nekevss

src/components/date.rs

@@ -28,40 +28,18 @@ use super::{
 /// A partial Date that may or may not be complete.
 #[derive(Debug, Default, Clone, Copy)]
 pub struct PartialDate {
-    pub(crate) year: Option<i32>,
-    pub(crate) month: Option<i32>,
-    pub(crate) month_code: Option<MonthCode>,
-    pub(crate) day: Option<i32>,
-    pub(crate) era: Option<TinyAsciiStr<16>>,
-    pub(crate) era_year: Option<i32>,
-}
-
-impl PartialDate {
-    /// Create a new `PartialDate`
-    pub fn new(
-        year: Option<i32>,
-        month: Option<i32>,
-        month_code: Option<MonthCode>,
-        day: Option<i32>,
-        era: Option<TinyAsciiStr<16>>,
-        era_year: Option<i32>,
-    ) -> TemporalResult<Self> {
-        if !(day.is_some()
-            && (month.is_some() || month_code.is_some())
-            && (year.is_some() || (era.is_some() && era_year.is_some())))
-        {
-            return Err(TemporalError::r#type()
-                .with_message("A partial date must have at least one defined field."));
-        }
-        Ok(Self {
-            year,
-            month,
-            month_code,
-            day,
-            era,
-            era_year,
-        })
-    }
+    // A potentially set `year` field.
+    pub year: Option<i32>,
+    // A potentially set `month` field.
+    pub month: Option<i32>,
+    // A potentially set `month_code` field.
+    pub month_code: Option<MonthCode>,
+    // A potentially set `day` field.
+    pub day: Option<i32>,
+    // A potentially set `era` field.
+    pub era: Option<TinyAsciiStr<16>>,
+    // A potentially set `era_year` field.
+    pub era_year: Option<i32>,
 }
 
 /// The native Rust implementation of `Temporal.PlainDate`.

src/components/datetime.rs

@@ -8,7 +8,7 @@ use crate::{
         RoundingOptions, TemporalUnit,
     },
     parsers::parse_date_time,
-    temporal_assert, Sign, TemporalError, TemporalResult, TemporalUnwrap,
+    temporal_assert, Sign, TemporalError, TemporalFields, TemporalResult, TemporalUnwrap,
 };
 
 use num_traits::AsPrimitive;
@@ -18,9 +18,16 @@ use tinystr::TinyAsciiStr;
 use super::{
     calendar::{CalendarDateLike, GetTemporalCalendar},
     duration::normalized::{NormalizedTimeDuration, RelativeRoundResult},
-    Date, Duration, Time,
+    Date, Duration, PartialDate, PartialTime, Time,
 };
 
+/// A partial DateTime record
+#[derive(Debug, Default, Copy, Clone)]
+pub struct PartialDateTime {
+    date: PartialDate,
+    time: PartialTime,
+}
+
 /// The native Rust implementation of `Temporal.PlainDateTime`
 #[non_exhaustive]
 #[derive(Debug, Default, Clone, PartialEq, Eq)]
@@ -243,6 +250,35 @@ impl DateTime {
         ))
     }
 
+    /// Creates a new `DateTime` with the fields of a `PartialDateTime`.
+    #[inline]
+    pub fn with(
+        &self,
+        partial_datetime: PartialDateTime,
+        overflow: Option<ArithmeticOverflow>,
+    ) -> TemporalResult<Self> {
+        // Determine the Date from the provided fields.
+        let fields = TemporalFields::from(self);
+        let partial_fields = TemporalFields::from(partial_datetime.date);
+
+        let mut merge_result = fields.merge_fields(&partial_fields, self.calendar())?;
+
+        let result_date = self.calendar.date_from_fields(
+            &mut merge_result,
+            overflow.unwrap_or(ArithmeticOverflow::Constrain),
+        )?;
+
+        // Determine the `Time` based off the partial values.
+        let time = self.iso.time.with(
+            partial_datetime.time,
+            overflow.unwrap_or(ArithmeticOverflow::Constrain),
+        )?;
+
+        let iso_datetime = IsoDateTime::new(result_date.iso, time)?;
+
+        Ok(Self::new_unchecked(iso_datetime, self.calendar().clone()))
+    }
+
     /// Creates a new `DateTime` from the current `DateTime` and the provided `Time`.
     pub fn with_time(&self, time: Time) -> TemporalResult<Self> {
         Self::new(
@@ -540,17 +576,35 @@ impl FromStr for DateTime {
 mod tests {
     use std::str::FromStr;
 
+    use tinystr::{tinystr, TinyAsciiStr};
+
     use crate::{
-        components::{calendar::Calendar, duration::DateDuration, Duration},
-        iso::{IsoDate, IsoTime},
+        components::{
+            calendar::Calendar, duration::DateDuration, DateTime, Duration, MonthCode, PartialDate,
+            PartialDateTime, PartialTime,
+        },
         options::{
             DifferenceSettings, RoundingIncrement, RoundingOptions, TemporalRoundingMode,
             TemporalUnit,
         },
         primitive::FiniteF64,
     };
 
-    use super::DateTime;
+    fn assert_datetime(
+        dt: DateTime,
+        fields: (i32, u8, TinyAsciiStr<4>, u8, u8, u8, u8, u16, u16, u16),
+    ) {
+        assert_eq!(dt.year().unwrap(), fields.0);
+        assert_eq!(dt.month().unwrap(), fields.1);
+        assert_eq!(dt.month_code().unwrap(), fields.2);
+        assert_eq!(dt.day().unwrap(), fields.3);
+        assert_eq!(dt.hour(), fields.4);
+        assert_eq!(dt.minute(), fields.5);
+        assert_eq!(dt.second(), fields.6);
+        assert_eq!(dt.millisecond(), fields.7);
+        assert_eq!(dt.microsecond(), fields.8);
+        assert_eq!(dt.nanosecond(), fields.9);
+    }
 
     #[test]
     #[allow(clippy::float_cmp)]
@@ -575,6 +629,152 @@ mod tests {
         assert!(positive_limit.is_err());
     }
 
+    #[test]
+    fn basic_with_test() {
+        let pdt =
+            DateTime::new(1976, 11, 18, 15, 23, 30, 123, 456, 789, Calendar::default()).unwrap();
+
+        // Test year
+        let partial = PartialDateTime {
+            date: PartialDate {
+                year: Some(2019),
+                ..Default::default()
+            },
+            time: PartialTime::default(),
+        };
+        let result = pdt.with(partial, None).unwrap();
+        assert_datetime(
+            result,
+            (2019, 11, tinystr!(4, "M11"), 18, 15, 23, 30, 123, 456, 789),
+        );
+
+        // Test month
+        let partial = PartialDateTime {
+            date: PartialDate {
+                month: Some(5),
+                ..Default::default()
+            },
+            time: PartialTime::default(),
+        };
+        let result = pdt.with(partial, None).unwrap();
+        assert_datetime(
+            result,
+            (1976, 5, tinystr!(4, "M05"), 18, 15, 23, 30, 123, 456, 789),
+        );
+
+        // Test monthCode
+        let partial = PartialDateTime {
+            date: PartialDate {
+                month_code: Some(MonthCode::Five),
+                ..Default::default()
+            },
+            time: PartialTime::default(),
+        };
+        let result = pdt.with(partial, None).unwrap();
+        assert_datetime(
+            result,
+            (1976, 5, tinystr!(4, "M05"), 18, 15, 23, 30, 123, 456, 789),
+        );
+
+        // Test day
+        let partial = PartialDateTime {
+            date: PartialDate {
+                day: Some(5),
+                ..Default::default()
+            },
+            time: PartialTime::default(),
+        };
+        let result = pdt.with(partial, None).unwrap();
+        assert_datetime(
+            result,
+            (1976, 11, tinystr!(4, "M11"), 5, 15, 23, 30, 123, 456, 789),
+        );
+
+        // Test hour
+        let partial = PartialDateTime {
+            date: PartialDate::default(),
+            time: PartialTime {
+                hour: Some(5),
+                ..Default::default()
+            },
+        };
+        let result = pdt.with(partial, None).unwrap();
+        assert_datetime(
+            result,
+            (1976, 11, tinystr!(4, "M11"), 18, 5, 23, 30, 123, 456, 789),
+        );
+
+        // Test minute
+        let partial = PartialDateTime {
+            date: PartialDate::default(),
+            time: PartialTime {
+                minute: Some(5),
+                ..Default::default()
+            },
+        };
+        let result = pdt.with(partial, None).unwrap();
+        assert_datetime(
+            result,
+            (1976, 11, tinystr!(4, "M11"), 18, 15, 5, 30, 123, 456, 789),
+        );
+
+        // Test second
+        let partial = PartialDateTime {
+            date: PartialDate::default(),
+            time: PartialTime {
+                second: Some(5),
+                ..Default::default()
+            },
+        };
+        let result = pdt.with(partial, None).unwrap();
+        assert_datetime(
+            result,
+            (1976, 11, tinystr!(4, "M11"), 18, 15, 23, 5, 123, 456, 789),
+        );
+
+        // Test second
+        let partial = PartialDateTime {
+            date: PartialDate::default(),
+            time: PartialTime {
+                millisecond: Some(5),
+                ..Default::default()
+            },
+        };
+        let result = pdt.with(partial, None).unwrap();
+        assert_datetime(
+            result,
+            (1976, 11, tinystr!(4, "M11"), 18, 15, 23, 30, 5, 456, 789),
+        );
+
+        // Test second
+        let partial = PartialDateTime {
+            date: PartialDate::default(),
+            time: PartialTime {
+                microsecond: Some(5),
+                ..Default::default()
+            },
+        };
+        let result = pdt.with(partial, None).unwrap();
+        assert_datetime(
+            result,
+            (1976, 11, tinystr!(4, "M11"), 18, 15, 23, 30, 123, 5, 789),
+        );
+
+        // Test second
+        let partial = PartialDateTime {
+            date: PartialDate::default(),
+            time: PartialTime {
+                nanosecond: Some(5),
+                ..Default::default()
+            },
+        };
+        let result = pdt.with(partial, None).unwrap();
+        assert_datetime(
+            result,
+            (1976, 11, tinystr!(4, "M11"), 18, 15, 23, 30, 123, 456, 5),
+        );
+    }
+
     // options-undefined.js
     #[test]
     fn datetime_add_test() {
@@ -632,47 +832,15 @@ mod tests {
             DateTime::new(2019, 10, 29, 10, 46, 38, 271, 986, 102, Calendar::default()).unwrap();
 
         let result = dt.subtract(&Duration::hour(FiniteF64(12.0)), None).unwrap();
-
-        assert_eq!(
-            result.iso.date,
-            IsoDate {
-                year: 2019,
-                month: 10,
-                day: 28
-            }
-        );
-        assert_eq!(
-            result.iso.time,
-            IsoTime {
-                hour: 22,
-                minute: 46,
-                second: 38,
-                millisecond: 271,
-                microsecond: 986,
-                nanosecond: 102
-            }
+        assert_datetime(
+            result,
+            (2019, 10, tinystr!(4, "M10"), 28, 22, 46, 38, 271, 986, 102),
         );
 
         let result = dt.add(&Duration::hour(FiniteF64(-12.0)), None).unwrap();
-
-        assert_eq!(
-            result.iso.date,
-            IsoDate {
-                year: 2019,
-                month: 10,
-                day: 28
-            }
-        );
-        assert_eq!(
-            result.iso.time,
-            IsoTime {
-                hour: 22,
-                minute: 46,
-                second: 38,
-                millisecond: 271,
-                microsecond: 986,
-                nanosecond: 102
-            }
+        assert_datetime(
+            result,
+            (2019, 10, tinystr!(4, "M10"), 28, 22, 46, 38, 271, 986, 102),
         );
     }
 

src/components/mod.rs

@@ -33,15 +33,15 @@ use std::str::FromStr;
 #[doc(inline)]
 pub use date::{Date, PartialDate};
 #[doc(inline)]
-pub use datetime::DateTime;
+pub use datetime::{DateTime, PartialDateTime};
 #[doc(inline)]
 pub use duration::Duration;
 #[doc(inline)]
 pub use instant::Instant;
 #[doc(inline)]
 pub use month_day::MonthDay;
 #[doc(inline)]
-pub use time::Time;
+pub use time::{PartialTime, Time};
 #[doc(inline)]
 pub use year_month::YearMonth;
 pub use year_month::YearMonthFields;