Cleanup utils module

Author: jedel1043

src/builtins/core/year_month.rs

@@ -1,6 +1,6 @@
 //! This module implements `YearMonth` and any directly related algorithms.
 
-use alloc::string::String;
+use alloc::{format, string::String};
 use core::{cmp::Ordering, str::FromStr};
 
 use tinystr::TinyAsciiStr;
@@ -9,7 +9,6 @@ use crate::{
     iso::{year_month_within_limits, IsoDate},
     options::{ArithmeticOverflow, DifferenceOperation, DifferenceSettings, DisplayCalendar},
     parsers::{FormattableCalendar, FormattableDate, FormattableYearMonth},
-    utils::pad_iso_year,
     Calendar, MonthCode, TemporalError, TemporalResult, TemporalUnwrap,
 };
 
@@ -103,11 +102,19 @@ impl PlainYearMonth {
         self.iso.year
     }
 
-    /// Returns the padded ISO year string
+    /// 3.5.11 PadISOYear ( y )
+    ///
+    /// Returns a String representation of y suitable for inclusion in an ISO 8601 string.
     #[inline]
     #[must_use]
     pub fn padded_iso_year_string(&self) -> String {
-        pad_iso_year(self.iso.year)
+        let year = self.iso.year;
+        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}",)
     }
 
     /// Returns the iso month value for this `YearMonth`.

src/iso.rs

@@ -91,7 +91,7 @@ impl IsoDateTime {
         // 3. Let epochMilliseconds be 𝔽((epochNanoseconds - remainderNs) / 10^6).
         let epoch_millis = (mathematical_nanos - remainder_nanos) / 1_000_000;
 
-        let (year, month, day) = utils::ymd_from_epoch_milliseconds(epoch_millis);
+        let (year, month, day) = utils::Epoch::new(epoch_millis).ymd();
 
         // 7. Let hour be ℝ(! HourFromTime(epochMilliseconds)).
         let hour = epoch_millis.div_euclid(3_600_000).rem_euclid(24);
@@ -344,8 +344,7 @@ impl IsoDate {
     /// Equivalent to `BalanceISODate`.
     pub(crate) fn balance(year: i32, month: i32, day: i32) -> Self {
         let epoch_days = iso_date_to_epoch_days(year, month, day);
-        let ms = utils::epoch_days_to_epoch_ms(epoch_days, 0);
-        let (year, month, day) = utils::ymd_from_epoch_milliseconds(ms);
+        let (year, month, day) = utils::Epoch::from_days(epoch_days).ymd();
         Self::new_unchecked(year, month, day)
     }
 
@@ -367,7 +366,7 @@ impl IsoDate {
     /// Equivalent to `IsoDateToEpochDays`
     #[inline]
     pub(crate) fn to_epoch_days(self) -> i32 {
-        utils::epoch_days_from_gregorian_date(self.year, self.month, self.day)
+        utils::Epoch::from_gregorian_date(self.year, self.month, self.day).days()
     }
 
     /// Returns if the current `IsoDate` is valid.
@@ -488,12 +487,13 @@ impl IsoDate {
 
         // NOTE: Below is adapted from the polyfill. Preferring this as it avoids looping.
         // 11. Let weeks be 0.
-        let days = utils::epoch_days_from_gregorian_date(other.year, other.month, other.day)
-            - utils::epoch_days_from_gregorian_date(
+        let days = utils::Epoch::from_gregorian_date(other.year, other.month, other.day).days()
+            - utils::Epoch::from_gregorian_date(
                 constrained.year,
                 constrained.month,
                 constrained.day,
-            );
+            )
+            .days();
 
         let (weeks, days) = if largest_unit == TemporalUnit::Week {
             (days / 7, days % 7)
@@ -905,8 +905,7 @@ const MAX_EPOCH_DAYS: i32 = 10i32.pow(8) + 1;
 #[inline]
 /// Utility function to determine if a `DateTime`'s components create a `DateTime` within valid limits
 fn iso_dt_within_valid_limits(date: IsoDate, time: &IsoTime) -> bool {
-    if utils::epoch_days_from_gregorian_date(date.year, date.month, date.day).abs() > MAX_EPOCH_DAYS
-    {
+    if utils::Epoch::from_gregorian_date(date.year, date.month, date.day).days() > MAX_EPOCH_DAYS {
         return false;
     }
 
@@ -927,7 +926,7 @@ fn utc_epoch_nanos(date: IsoDate, time: &IsoTime) -> TemporalResult<EpochNanosec
 #[inline]
 fn to_unchecked_epoch_nanoseconds(date: IsoDate, time: &IsoTime) -> i128 {
     let ms = time.to_epoch_ms();
-    let epoch_ms = utils::epoch_days_to_epoch_ms(date.to_epoch_days(), ms);
+    let epoch_ms = utils::Epoch::from_days(date.to_epoch_days()).millis() + ms;
     epoch_ms as i128 * 1_000_000 + time.microsecond as i128 * 1_000 + time.nanosecond as i128
 }
 
@@ -943,10 +942,10 @@ pub(crate) fn iso_date_to_epoch_days(year: i32, month: i32, day: i32) -> i32 {
     let resolved_month = month.rem_euclid(12) as u8;
     // 3. Find a time t such that EpochTimeToEpochYear(t) is resolvedYear,
     // EpochTimeToMonthInYear(t) is resolvedMonth, and EpochTimeToDate(t) is 1.
-    let epoch_days = utils::epoch_days_from_gregorian_date(resolved_year, resolved_month, 1);
+    let epoch_days = utils::Epoch::from_gregorian_date(resolved_year, resolved_month, 1);
 
     // 4. Return EpochTimeToDayNumber(t) + date - 1.
-    epoch_days + day - 1
+    epoch_days.days() + day - 1
 }
 
 #[inline]
@@ -997,13 +996,13 @@ fn balance_iso_year_month(year: i32, month: i32) -> (i32, u8) {
 /// Note: month is 1 based.
 #[inline]
 pub(crate) fn constrain_iso_day(year: i32, month: u8, day: u8) -> u8 {
-    let days_in_month = utils::iso_days_in_month(year, month);
+    let days_in_month = utils::Epoch::from_gregorian_date(year, month, 1).days_in_month();
     day.clamp(1, days_in_month)
 }
 
 #[inline]
 pub(crate) fn is_valid_iso_day(year: i32, month: u8, day: u8) -> bool {
-    let days_in_month = utils::iso_days_in_month(year, month);
+    let days_in_month = utils::Epoch::from_gregorian_date(year, month, 1).days_in_month();
     (1..=days_in_month).contains(&day)
 }
 

src/tzdb.rs

@@ -358,12 +358,11 @@ fn resolve_posix_tz_string_for_epoch_seconds(
     // TODO: Resolve safety issue around utils.
     //   Using f64 is a hold over from early implementation days and should
     //   be moved away from.
+    let epoch = utils::Epoch::from_seconds(seconds);
 
-    let (is_transition_day, transition) =
-        cmp_seconds_to_transitions(&start.day, &end.day, seconds)?;
+    let (is_transition_day, transition) = cmp_seconds_to_transitions(&start.day, &end.day, epoch)?;
 
-    let transition =
-        compute_tz_for_epoch_seconds(is_transition_day, transition, seconds, dst_variant);
+    let transition = compute_tz_for_epoch(is_transition_day, transition, epoch, dst_variant);
     let std_offset = LocalTimeRecord::from_standard_time(&posix_tz_string.std_info).offset;
     let dst_offset = LocalTimeRecord::from_daylight_savings_time(&dst_variant.variant_info).offset;
     let (old_offset, new_offset) = match transition {
@@ -374,23 +373,20 @@ fn resolve_posix_tz_string_for_epoch_seconds(
         TransitionType::Dst => start,
         TransitionType::Std => end,
     };
-    let year = utils::epoch_time_to_epoch_year(seconds * 1000);
-    let year_epoch = utils::epoch_days_for_year(year) * 86400;
-    let leap_day = utils::mathematical_in_leap_year(seconds * 1000) as u16;
+    let year_epoch = epoch.year() * 86400;
+    let leap_day = epoch.in_leap_year();
 
     let days = match transition.day {
-        TransitionDay::NoLeap(day) if day > 59 => day - 1 + leap_day,
+        TransitionDay::NoLeap(day) if day > 59 => day - 1 + u16::from(leap_day),
         TransitionDay::NoLeap(day) => day - 1,
         TransitionDay::WithLeap(day) => day,
         TransitionDay::Mwd(month, week, day) => {
-            let days_to_month = utils::month_to_day((month - 1) as u8, leap_day);
-            let days_in_month = u16::from(utils::iso_days_in_month(year, month as u8) - 1);
+            let transition_epoch = utils::Epoch::from_gregorian_date(year_epoch, month as u8, 1);
+            let days_to_month = transition_epoch.day_of_year_until_start_of_month();
+            let days_in_month = u16::from(transition_epoch.days_in_month());
 
             // Month starts in the day...
-            let day_offset =
-                (u16::from(utils::epoch_seconds_to_day_of_week(i64::from(year_epoch)))
-                    + days_to_month)
-                    .rem_euclid(7);
+            let day_offset = (u16::from(epoch.day_in_week()) + days_to_month).rem_euclid(7);
 
             // EXAMPLE:
             //
@@ -456,10 +452,11 @@ fn resolve_posix_tz_string(
     // NOTE:
     // STD -> DST == start
     // DST -> STD == end
+    let epoch = utils::Epoch::from_seconds(seconds);
     let (is_transition_day, is_dst) =
-        cmp_seconds_to_transitions(&dst.start_date.day, &dst.end_date.day, seconds)?;
+        cmp_seconds_to_transitions(&dst.start_date.day, &dst.end_date.day, epoch)?;
     if is_transition_day {
-        let time = utils::epoch_ms_to_ms_in_day(seconds * 1_000) as i64 / 1_000;
+        let time = epoch.millis_since_start_of_day() as i64 / 1_000;
         let transition_time = if is_dst == TransitionType::Dst {
             dst.start_date.time.0
         } else {
@@ -493,20 +490,19 @@ fn resolve_posix_tz_string(
     }
 }
 
-fn compute_tz_for_epoch_seconds(
+fn compute_tz_for_epoch(
     is_transition_day: bool,
     transition: TransitionType,
-    seconds: i64,
+    epoch: utils::Epoch,
     dst_variant: &DstTransitionInfo,
 ) -> TransitionType {
+    let time = epoch.millis_since_start_of_day() / 1000;
     if is_transition_day && transition == TransitionType::Dst {
-        let time = utils::epoch_ms_to_ms_in_day(seconds * 1_000) / 1_000;
         let transition_time = dst_variant.start_date.time.0 - dst_variant.variant_info.offset.0;
         if i64::from(time) < transition_time {
             return TransitionType::Std;
         }
     } else if is_transition_day {
-        let time = utils::epoch_ms_to_ms_in_day(seconds * 1_000) / 1_000;
         let transition_time = dst_variant.end_date.time.0 - dst_variant.variant_info.offset.0;
         if i64::from(time) < transition_time {
             return TransitionType::Dst;
@@ -523,26 +519,26 @@ fn compute_tz_for_epoch_seconds(
 struct Mwd(u16, u16, u16);
 
 impl Mwd {
-    fn from_seconds(seconds: i64) -> Self {
-        let month = utils::epoch_ms_to_month_in_year(seconds * 1_000) as u16;
-        let day_of_month = utils::epoch_seconds_to_day_of_month(seconds);
+    fn from_epoch(epoch: utils::Epoch) -> Self {
+        let month = epoch.month_in_year();
+        let day_of_month = epoch.day_of_month();
         let week_of_month = day_of_month / 7 + 1;
-        let day_of_week = utils::epoch_seconds_to_day_of_week(seconds);
-        Self(month, week_of_month, u16::from(day_of_week))
+        let day_in_week = epoch.day_in_week();
+        Self(u16::from(month), week_of_month, u16::from(day_in_week))
     }
 }
 
 fn cmp_seconds_to_transitions(
     start: &TransitionDay,
     end: &TransitionDay,
-    seconds: i64,
+    epoch: utils::Epoch,
 ) -> TemporalResult<(bool, TransitionType)> {
     let cmp_result = match (start, end) {
         (
             TransitionDay::Mwd(start_month, start_week, start_day),
             TransitionDay::Mwd(end_month, end_week, end_day),
         ) => {
-            let mwd = Mwd::from_seconds(seconds);
+            let mwd = Mwd::from_epoch(epoch);
             let start = Mwd(*start_month, *start_week, *start_day);
             let end = Mwd(*end_month, *end_week, *end_day);
 
@@ -556,7 +552,7 @@ fn cmp_seconds_to_transitions(
             (is_transition, is_dst)
         }
         (TransitionDay::WithLeap(start), TransitionDay::WithLeap(end)) => {
-            let day_in_year = utils::epoch_time_to_day_in_year(seconds * 1_000) as u16;
+            let day_in_year = epoch.days_in_year();
             let is_transition = *start == day_in_year || *end == day_in_year;
             let is_dst = if start > end {
                 day_in_year < *end || *start <= day_in_year
@@ -567,7 +563,7 @@ fn cmp_seconds_to_transitions(
         }
         // TODO: do we need to modify the logic for leap years?
         (TransitionDay::NoLeap(start), TransitionDay::NoLeap(end)) => {
-            let day_in_year = utils::epoch_time_to_day_in_year(seconds * 1_000) as u16;
+            let day_in_year = epoch.days_in_year();
             let is_transition = *start == day_in_year || *end == day_in_year;
             let is_dst = if start > end {
                 day_in_year < *end || *start <= day_in_year
@@ -1082,10 +1078,7 @@ mod tests {
     }
 
     #[test]
-    fn mwd_transition_epoch() {
-        #[cfg(not(target_os = "windows"))]
-        let tzif = Tzif::read_tzif("Europe/Berlin").unwrap();
-        #[cfg(target_os = "windows")]
+    fn mwd_transition_epoch_with_slim_format() {
         let tzif = Tzif::from_bytes(jiff_tzdb::get("Europe/Berlin").unwrap().1).unwrap();
 
         let start_date = crate::iso::IsoDate {