adding methods for yearMonth and MonthDay

src/components/calendar.rs

@@ -253,6 +253,10 @@ pub enum CalendarDateLike {
     DateTime(DateTime),
     /// Represents a `Date`.
     Date(Date),
+    /// Represents a `YearMonth`.
+    YearMonth(YearMonth),
+    /// Represents a `MonthDay`.
+    MonthDay(MonthDay),
 }
 
 impl CalendarDateLike {
@@ -263,6 +267,8 @@ impl CalendarDateLike {
         match self {
             CalendarDateLike::DateTime(dt) => dt.iso_date(),
             CalendarDateLike::Date(d) => d.iso_date(),
+            CalendarDateLike::YearMonth(ym) => ym.iso_date(),
+            CalendarDateLike::MonthDay(md) => md.iso_date(),
         }
     }
 }

src/components/mod.rs

@@ -42,5 +42,6 @@ pub use month_day::MonthDay;
 pub use time::Time;
 #[doc(inline)]
 pub use year_month::YearMonth;
+pub use year_month::YearMonthFields;
 #[doc(inline)]
 pub use zoneddatetime::ZonedDateTime;

src/components/month_day.rs

@@ -2,14 +2,16 @@
 
 use std::str::FromStr;
 
+use tinystr::TinyAsciiStr;
+
 use crate::{
     components::calendar::Calendar,
     iso::{IsoDate, IsoDateSlots},
     options::ArithmeticOverflow,
     TemporalError, TemporalResult, TemporalUnwrap,
 };
 
-use super::calendar::GetTemporalCalendar;
+use super::calendar::{CalendarDateLike, GetTemporalCalendar};
 
 /// The native Rust implementation of `Temporal.PlainMonthDay`
 #[non_exhaustive]
@@ -35,22 +37,30 @@ impl MonthDay {
         calendar: Calendar,
         overflow: ArithmeticOverflow,
     ) -> TemporalResult<Self> {
+        // 1972 is the first leap year in the Unix epoch (needed to cover all dates)
         let iso = IsoDate::new(1972, month, day, overflow)?;
         Ok(Self::new_unchecked(iso, calendar))
     }
 
-    /// Returns the `month` value of `MonthDay`.
+    /// Returns the `day` value of `MonthDay`.
+    #[inline]
+    #[must_use]
+    pub fn day(&self) -> u8 {
+        self.iso.day
+    }
+
+    // returns the `month` value of `MonthDay`.
     #[inline]
     #[must_use]
     pub fn month(&self) -> u8 {
         self.iso.month
     }
 
-    /// Returns the `day` value of `MonthDay`.
+    /// Returns the string identifier for the current calendar used.
     #[inline]
     #[must_use]
-    pub fn day(&self) -> u8 {
-        self.iso.day
+    pub fn calendar_id(&self) -> String {
+        self.calendar.identifier()
     }
 
     /// Returns a reference to `MonthDay`'s `CalendarSlot`
@@ -59,6 +69,13 @@ impl MonthDay {
     pub fn calendar(&self) -> &Calendar {
         &self.calendar
     }
+
+    /// Returns the `monthCode` value of `MonthDay`.
+    #[inline]
+    pub fn month_code(&self) -> TemporalResult<TinyAsciiStr<4>> {
+        self.calendar
+            .month_code(&CalendarDateLike::MonthDay(self.clone()))
+    }
 }
 
 impl GetTemporalCalendar for MonthDay {

src/components/year_month.rs

@@ -2,14 +2,23 @@
 
 use std::str::FromStr;
 
+use tinystr::TinyAsciiStr;
+
 use crate::{
     components::calendar::Calendar,
     iso::{IsoDate, IsoDateSlots},
     options::ArithmeticOverflow,
+    utils::{self, pad_iso_year},
     TemporalError, TemporalResult, TemporalUnwrap,
 };
 
-use super::calendar::GetTemporalCalendar;
+use super::{
+    calendar::{CalendarDateLike, GetTemporalCalendar},
+    Duration,
+};
+
+// Subset of `TemporalFields` representing just the  `YearMonthFields`
+pub struct YearMonthFields(pub i32, pub u8);
 
 /// The native Rust implementation of `Temporal.YearMonth`.
 #[non_exhaustive]
@@ -48,19 +57,97 @@ impl YearMonth {
         self.iso.year
     }
 
+    /// Returns the padded ISO year string
+    #[inline]
+    #[must_use]
+    pub fn padded_iso_year_string(&self) -> String {
+        pad_iso_year(self.iso.year)
+    }
+
     /// Returns the `month` value for this `YearMonth`.
     #[inline]
     #[must_use]
     pub fn month(&self) -> u8 {
         self.iso.month
     }
 
+    pub fn month_code(&self) -> TemporalResult<TinyAsciiStr<4>> {
+        self.get_calendar()
+            .month_code(&CalendarDateLike::YearMonth(self.clone()))
+    }
+
+    #[inline]
+    #[must_use]
+    pub fn in_leap_year(&self) -> bool {
+        utils::mathematical_in_leap_year(utils::epoch_time_for_year(self.iso.year)) == 1
+    }
+
+    pub fn get_days_in_year(&self) -> TemporalResult<u16> {
+        self.get_calendar()
+            .days_in_year(&CalendarDateLike::YearMonth(self.clone()))
+    }
+
+    pub fn get_days_in_month(&self) -> TemporalResult<u16> {
+        self.get_calendar()
+            .days_in_month(&CalendarDateLike::YearMonth(self.clone()))
+    }
+
+    pub fn get_months_in_year(&self) -> TemporalResult<u16> {
+        self.get_calendar()
+            .months_in_year(&CalendarDateLike::YearMonth(self.clone()))
+    }
+}
+
+impl YearMonth {
     /// Returns the Calendar value.
     #[inline]
     #[must_use]
     pub fn calendar(&self) -> &Calendar {
         &self.calendar
     }
+
+    /// Returns the string identifier for the current calendar used.
+    #[inline]
+    #[must_use]
+    pub fn calendar_id(&self) -> String {
+        self.calendar.identifier()
+    }
+
+    pub fn add_duration(
+        &self,
+        duration: &Duration,
+        overflow: ArithmeticOverflow,
+    ) -> TemporalResult<YearMonth> {
+        self.add_or_subtract_duration(duration, overflow)
+    }
+
+    pub fn subtract_duration(
+        &self,
+        duration: &Duration,
+        overflow: ArithmeticOverflow,
+    ) -> TemporalResult<YearMonth> {
+        self.add_or_subtract_duration(&duration.negated(), overflow)
+    }
+
+    pub(crate) fn add_or_subtract_duration(
+        &self,
+        duration: &Duration,
+        overflow: ArithmeticOverflow,
+    ) -> TemporalResult<YearMonth> {
+        let mut fields = YearMonthFields(self.iso_date().year, self.iso_date().month).into();
+
+        let mut intermediate_date = self
+            .get_calendar()
+            .date_from_fields(&mut fields, overflow)?;
+
+        intermediate_date = intermediate_date.add_date(duration, Some(overflow))?;
+
+        let mut result_fields =
+            YearMonthFields(intermediate_date.iso_year(), intermediate_date.iso_month()).into();
+
+        self.get_calendar()
+            .year_month_from_fields(&mut result_fields, overflow)
+    }
 }
 
 impl GetTemporalCalendar for YearMonth {

src/fields.rs

@@ -3,7 +3,12 @@
 use core::fmt;
 use std::str::FromStr;
 
-use crate::{components::calendar::Calendar, error::TemporalError, iso::IsoDate, TemporalResult};
+use crate::{
+    components::{calendar::Calendar, YearMonthFields},
+    error::TemporalError,
+    iso::IsoDate,
+    TemporalResult,
+};
 
 use bitflags::bitflags;
 use tinystr::TinyAsciiStr;
@@ -577,3 +582,15 @@ fn month_code_to_integer(mc: TinyAsciiStr<4>) -> TemporalResult<i32> {
         _ => Err(TemporalError::range().with_message("monthCode is not within the valid values.")),
     }
 }
+
+// Conversion to `TemporalFields`
+impl From<YearMonthFields> for TemporalFields {
+    fn from(value: YearMonthFields) -> Self {
+        TemporalFields {
+            bit_map: FieldMap::YEAR | FieldMap::MONTH,
+            year: Some(value.0),
+            month: Some(value.1.into()),
+            ..Default::default()
+        }
+    }
+}

src/options.rs

@@ -689,3 +689,43 @@ impl fmt::Display for TemporalRoundingMode {
         .fmt(f)
     }
 }
+
+/// values for `CalendarName`, whether to show the calendar in toString() methods
+/// <https://tc39.es/proposal-temporal/#sec-temporal-gettemporalshowcalendarnameoption>
+#[derive(Debug, Clone, Copy)]
+pub enum CalendarName {
+    /// `Auto` option
+    Auto,
+    /// `Always` option
+    Always,
+    /// `Never` option
+    Never,
+    // `Critical` option
+    Critical,
+}
+
+impl fmt::Display for CalendarName {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            CalendarName::Auto => "auto",
+            CalendarName::Always => "always",
+            CalendarName::Never => "never",
+            CalendarName::Critical => "critical",
+        }
+        .fmt(f)
+    }
+}
+
+impl FromStr for CalendarName {
+    type Err = TemporalError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s {
+            "auto" => Ok(Self::Auto),
+            "always" => Ok(Self::Always),
+            "never" => Ok(Self::Never),
+            "critical" => Ok(Self::Critical),
+            _ => Err(TemporalError::range().with_message("Invalid CalendarName provided.")),
+        }
+    }
+}

src/utils.rs

@@ -16,6 +16,18 @@ pub(crate) fn epoch_days_to_epoch_ms(day: i32, time: f64) -> f64 {
     f64::from(day).mul_add(f64::from(MS_PER_DAY), time).floor()
 }
 
+/// 3.5.11 PadISOYear ( y )
+///
+/// returns a String representation of y suitable for inclusion in an ISO 8601 string
+pub(crate) fn pad_iso_year(year: i32) -> String {
+    if (0..9999).contains(&year) {
+        return format!("{:04}", year);
+    }
+    let year_sign = if year > 0 { "+" } else { "-" };
+    let year_string = format!("{:06}", year.abs());
+    format!("{year_sign}{year_string}",)
+}
+
 /// `EpochTimeToDayNumber`
 ///
 /// This equation is the equivalent to `ECMAScript`'s `Date(t)`