Add suffix parsing

Author: soulstompp

crates/winnow-datetime-assert/CHANGELOG.md

@@ -1,3 +1,7 @@
+## 0.3.0 - 2015-05-14
+* Added support for winnow-datetime 0.3.0 objects
+* Added assersions for Calendar and TimeZone
+
 ## 0.2.0 - 2024-05-04
 * Changed parser signatures to meet winnow 0.7 standards
 * Removed dependency on galvanic-test which was accidentally left over from some initial design experiments.

crates/winnow-datetime-assert/Cargo.toml

@@ -1,8 +1,8 @@
 [package]
 name = "winnow_datetime_assert"
-version = "0.2.0"
+version = "0.3.0"
 description = "Testing/Benchmarking winnow-datetime parsers"
-keywords = [ "iso8601", "date-time", "parser", "winnow" ]
+keywords = [ "date-time", "parser", "winnow" ]
 categories = [ "parser-implementations", "date-and-time" ]
 
 repository = "https://github.com/soulstompp/winnow-datetime"
@@ -13,7 +13,7 @@ readme = "README.md"
 edition = "2021"
 
 [dependencies]
-winnow_datetime = { path = "../winnow-datetime", version = "0.2",  features = ["serde"] }
+winnow_datetime = { path = "../winnow-datetime", version = "0.3",  features = ["serde"] }
 libtest-mimic = "0.8.1"
 winnow = "0.7"
 serde = { version = "1.0", features = ["derive"] }

crates/winnow-datetime-assert/data/assertions/calendar.yaml

@@ -0,0 +1,11 @@
+assertions:
+  - format: "gregory"
+    input: "gregory"
+    expected:
+     identifier: "gregory"
+     critical: false
+  - format: "islamic-umalqura"
+    input: "islamic-umalqura"
+    expected:
+      identifier: "islamic-umalqura"
+      critical: false

crates/winnow-datetime-assert/data/assertions/time_zone.yaml

@@ -52,3 +52,10 @@ assertions:
             hours: -8
             minutes: 0
             critical: false
+  - format: "America/Los_Angeles"
+    input: "America/Los_Angeles"
+    expected:
+      !Named
+        zone:
+          identifier: "America/Los_Angeles"
+          critical: false

crates/winnow-datetime-assert/src/calendar.rs

@@ -0,0 +1,40 @@
+use crate::{FormatAssertion, FormatAssertionBuilder, FormatCoverage, FormatCoverageBuilder};
+use serde::Deserialize;
+use winnow_datetime::types::Calendar;
+
+#[derive(Debug, Deserialize)]
+pub struct CalendarAssertion {
+    assertions: Vec<FormatAssertion<Calendar>>,
+}
+
+impl FormatAssertionBuilder<Calendar> for CalendarAssertion {
+    fn piece() -> &'static str {
+        "calendar"
+    }
+
+    fn base_assertions(&self) -> Vec<FormatAssertion<Calendar>> {
+        self.assertions.clone()
+    }
+
+    fn assertions(&self) -> Vec<FormatAssertion<Calendar>> {
+        self.base_assertions()
+    }
+}
+
+#[derive(Clone, Debug, PartialEq, Deserialize)]
+pub struct CalendarCoverage {
+    pub coverage: Vec<FormatCoverage<Calendar>>,
+}
+
+impl FormatCoverageBuilder<Calendar> for CalendarCoverage {
+    fn piece() -> &'static str {
+        "calendar"
+    }
+    fn base_coverage(&self) -> Vec<FormatCoverage<Calendar>> {
+        self.coverage.clone()
+    }
+
+    fn coverage(&self) -> Vec<FormatCoverage<Calendar>> {
+        vec![]
+    }
+}

crates/winnow-datetime-assert/src/lib.rs

@@ -22,9 +22,13 @@ pub use offset::{OffsetAssertion, OffsetCoverage};
 pub mod time;
 pub use time::{TimeAssertion, TimeCoverage};
 
+pub mod calendar;
 pub mod time_zone;
+
 pub use time_zone::{TimeZoneAssertion, TimeZoneCoverage};
 
+pub use calendar::{CalendarAssertion, CalendarCoverage};
+
 #[derive(Clone, Debug, PartialEq, Deserialize)]
 pub struct FormatAssertion<T> {
     pub format: String,

crates/winnow-datetime-assert/src/time.rs

@@ -88,7 +88,10 @@ impl FormatCoverageBuilder<Time> for TimeCoverage {
                     );
                     let exception = match (t.exception.clone(), offset.exception.clone()) {
                         (Exception::Unspecified, Exception::Unspecified) => Exception::Unspecified,
-                        (Exception::Specific {value: mut t}, Exception::Specific { value: o }) => match o {
+                        (
+                            Exception::Specific { value: mut t },
+                            Exception::Specific { value: o },
+                        ) => match o {
                             Offset::Fixed {
                                 hours,
                                 minutes,
@@ -106,7 +109,9 @@ impl FormatCoverageBuilder<Time> for TimeCoverage {
                                 Exception::Specific { value: t }
                             }
                         },
-                        (Exception::Specific { value: t }, Exception::Unspecified) => Exception::Specific { value: t },
+                        (Exception::Specific { value: t }, Exception::Unspecified) => {
+                            Exception::Specific { value: t }
+                        }
                         (Exception::Unspecified, Exception::Specific { value: o }) => {
                             let mut default_t = assertions
                                 .get(&t.format)

crates/winnow-datetime/CHANGELOG.md

@@ -1,3 +1,10 @@
+## 0.3.0 - 2015-05-30
+* Addition of TimeZone enum to support new information from RFC9557
+* Addition of Calendar struct to support new information from RFC9557
+* Changed Offset to not rely on Option, which caused problems with test suite YAML
+* Added critical value to Offset for RFC9557 support
+* Added support for setting named time zones for jiff exports
+
 ## 0.2.3 - 2015-05-14
 * Support for `Date::Ordinal` conversions to `jiff::civil::Date`
 

crates/winnow-datetime/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "winnow_datetime"
-version = "0.2.3"
+version = "0.3.0"
 description = "Parsing dates using winnow"
 keywords = [ "iso8601", "date-time", "parser", "winnow" ]
 categories = [ "parser-implementations", "date-and-time" ]

crates/winnow-datetime/src/convert/jiff.rs

@@ -19,6 +19,25 @@ impl crate::Time {
     pub fn into_civil_time(self) -> Option<jiff::civil::Time> {
         jiff::civil::Time::try_from(self).ok()
     }
+
+    pub fn jiff_fixed_tz(o: Option<crate::Offset>) -> Result<jiff::tz::TimeZone, jiff::Error> {
+        let o_seconds = if let Some(o) = o {
+            match o {
+                Offset::Fixed {
+                    hours,
+                    minutes,
+                    critical: _,
+                } => hours * 3600 + minutes * 60,
+                Offset::LocalUnknown { critical: _ } => 0,
+            }
+        } else {
+            0
+        };
+
+        Ok(jiff::tz::TimeZone::fixed(jiff::tz::Offset::from_seconds(
+            o_seconds.try_into().unwrap(),
+        )?))
+    }
 }
 
 impl TryFrom<crate::Date> for jiff::civil::Date {
@@ -86,21 +105,19 @@ impl TryFrom<crate::DateTime> for jiff::Zoned {
         let naive_time = jiff::civil::Time::try_from(dt.time.clone())?;
         let naive_datetime = naive_date.to_datetime(naive_time);
 
-        let o_seconds = match dt.time.offset {
-            Some(o) => match o {
-                Offset::Fixed {
-                    hours,
-                    minutes,
-                    critical: _,
-                } => hours * 3600 + minutes * 60,
-                Offset::LocalUnknown { critical: _ } => 0,
-            },
-            None => 0,
-        };
+        let mut tz = crate::Time::jiff_fixed_tz(dt.time.offset)?;
 
-        let offset = jiff::tz::Offset::from_seconds(o_seconds.try_into().unwrap())?;
+        if let Some(z) = dt.time.time_zone {
+            match z {
+                crate::TimeZone::Named { zone } => {
+                    tz = jiff::tz::TimeZone::get(&zone.identifier)?;
+                }
+                crate::TimeZone::Fixed { offset } => {
+                    tz = crate::Time::jiff_fixed_tz(Some(offset))?;
+                }
+            }
+        }
 
-        let tz = jiff::tz::TimeZone::fixed(offset);
         naive_datetime.to_zoned(tz)
     }
 }
@@ -138,6 +155,8 @@ impl TryFrom<crate::Duration> for jiff::Span {
 
 #[cfg(test)]
 mod date_and_time {
+    use crate::Offset;
+    use crate::TimeZone;
     use core::convert::TryFrom;
 
     #[test]
@@ -190,13 +209,129 @@ mod date_and_time {
             },
         };
 
-        let datetime = time::PrimitiveDateTime::try_from(dt).unwrap();
+        let datetime = jiff::Zoned::try_from(dt).unwrap();
+        assert_eq!(datetime.year(), 2024);
+        assert_eq!(datetime.month() as u8, 3);
+        assert_eq!(datetime.day(), 9);
+        assert_eq!(datetime.hour(), 23);
+        assert_eq!(datetime.minute(), 40);
+        assert_eq!(datetime.second(), 0);
+    }
+
+    #[test]
+    fn datetime_from_ymd_hms_with_offset() {
+        let dt = crate::DateTime {
+            date: crate::Date::YMD {
+                year: 2024,
+                month: 3,
+                day: 9,
+            },
+            time: crate::Time {
+                hour: 23,
+                minute: 40,
+                second: 0,
+                millisecond: 0,
+                offset: Some(Offset::Fixed {
+                    hours: 2,
+                    minutes: 0,
+                    critical: false,
+                }),
+                time_zone: None,
+                calendar: None,
+            },
+        };
+
+        let datetime = jiff::Zoned::try_from(dt).unwrap();
+        assert_eq!(datetime.year(), 2024);
+        assert_eq!(datetime.month() as u8, 3);
+        assert_eq!(datetime.day(), 9);
+        assert_eq!(datetime.hour(), 23);
+        assert_eq!(datetime.minute(), 40);
+        assert_eq!(datetime.second(), 0);
+        assert_eq!(
+            datetime.time_zone().to_fixed_offset().unwrap().seconds(),
+            2 * 3600
+        );
+    }
+
+    #[test]
+    fn datetime_from_ymd_hms_with_matching_offset() {
+        let dt = crate::DateTime {
+            date: crate::Date::YMD {
+                year: 2024,
+                month: 3,
+                day: 9,
+            },
+            time: crate::Time {
+                hour: 23,
+                minute: 40,
+                second: 0,
+                millisecond: 0,
+                offset: Some(Offset::Fixed {
+                    hours: 2,
+                    minutes: 0,
+                    critical: false,
+                }),
+                time_zone: Some(TimeZone::Fixed {
+                    offset: Offset::Fixed {
+                        hours: 3,
+                        minutes: 0,
+                        critical: false,
+                    },
+                }),
+                calendar: None,
+            },
+        };
+
+        let datetime = jiff::Zoned::try_from(dt).unwrap();
+        assert_eq!(datetime.year(), 2024);
+        assert_eq!(datetime.month() as u8, 3);
+        assert_eq!(datetime.day(), 9);
+        assert_eq!(datetime.hour(), 23);
+        assert_eq!(datetime.minute(), 40);
+        assert_eq!(datetime.second(), 0);
+        assert_eq!(
+            datetime.time_zone().to_fixed_offset().unwrap().seconds(),
+            3 * 3600
+        );
+    }
+
+    #[test]
+    fn datetime_from_ymd_hms_with_named_zone() {
+        let dt = crate::DateTime {
+            date: crate::Date::YMD {
+                year: 2024,
+                month: 3,
+                day: 9,
+            },
+            time: crate::Time {
+                hour: 23,
+                minute: 40,
+                second: 0,
+                millisecond: 0,
+                offset: Some(Offset::Fixed {
+                    hours: 2,
+                    minutes: 0,
+                    critical: false,
+                }),
+                time_zone: Some(TimeZone::Named {
+                    zone: crate::NamedTimeZone {
+                        identifier: "Europe/Berlin".to_string(),
+                        critical: false,
+                    },
+                }),
+                calendar: None,
+            },
+        };
+
+        let datetime = jiff::Zoned::try_from(dt).unwrap();
         assert_eq!(datetime.year(), 2024);
         assert_eq!(datetime.month() as u8, 3);
         assert_eq!(datetime.day(), 9);
         assert_eq!(datetime.hour(), 23);
         assert_eq!(datetime.minute(), 40);
         assert_eq!(datetime.second(), 0);
+        assert_eq!(datetime.time_zone().iana_name().unwrap(), "Europe/Berlin");
     }
 
     #[test]