Add named timezone support

Author: bezmuth

Cargo.lock

@@ -13,6 +13,7 @@ regex = "1.10.4"
 chrono = { version="0.4.38", default-features=false, features=["std", "alloc", "clock"] }
 winnow = "0.7.10"
 num-traits = "0.2.19"
+chrono-tz = { version = "0.10.4", features=["case-insensitive"] }
 
 [dev-dependencies]
 rstest = "0.26"

Cargo.toml

@@ -18,7 +18,7 @@ pub struct DateTimeBuilder {
     time: Option<time::Time>,
     weekday: Option<weekday::Weekday>,
     timezone: Option<time::Offset>,
-    conversion_timezone: Option<time::Offset>,
+    conversion_timezone: Option<FixedOffset>,
     relative: Vec<relative::Relative>,
 }
 
@@ -99,7 +99,10 @@ impl DateTimeBuilder {
         }
     }
 
-    pub(super) fn set_conversion_timezone(mut self, conversion_timezone: time::Offset) -> Result<Self, &'static str> {
+    pub(super) fn set_conversion_timezone(
+        mut self,
+        conversion_timezone: FixedOffset,
+    ) -> Result<Self, &'static str> {
         if self.conversion_timezone.is_some() {
             Err("TZ= cannot appear more than once")
         } else {
@@ -277,13 +280,12 @@ impl DateTimeBuilder {
         }
 
         if let Some(offset) = self.timezone {
-            dt = with_timezone_restore(offset, dt)?;
+            let offset = chrono::FixedOffset::try_from(offset).ok();
+            dt = with_timezone_restore(offset?, dt)?;
         }
 
-        if let Some(mut offset) = self.conversion_timezone {
-            // Reuse with_timezone_restore with a swapped offset
-            offset.negative = !offset.negative;
-            dt = with_timezone_restore(offset, dt)?;
+        if let Some(conversion_timezone) = self.conversion_timezone {
+            dt = with_timezone_restore(conversion_timezone, dt)?;
         }
 
         Some(dt)
@@ -310,10 +312,9 @@ fn new_date(
 /// Restores year, month, day, etc after applying the timezone
 /// returns None if timezone overflows the date
 fn with_timezone_restore(
-    offset: time::Offset,
+    offset: FixedOffset,
     at: DateTime<FixedOffset>,
 ) -> Option<DateTime<FixedOffset>> {
-    let offset: FixedOffset = chrono::FixedOffset::try_from(offset).ok()?;
     let copy = at;
     let x = at
         .with_timezone(&offset)

fuzz/Cargo.lock

@@ -1,13 +1,29 @@
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
 
-use winnow::{ModalResult, Parser};
+use chrono::{FixedOffset, NaiveDate, TimeZone};
+use chrono_tz::Tz;
+use winnow::{combinator::peek, error::ErrMode, token::take_while, ModalResult, Parser};
 
-use super::time;
+use super::{primitive::ctx_err, time};
 
-pub(crate) fn parse(input: &mut &str) -> ModalResult<time::Offset> {
+pub(crate) fn parse(input: &mut &str) -> ModalResult<FixedOffset> {
     let _ = "tz=\"".parse_next(input)?;
-    let tz = time::timezone(input);
+    let mut tz_name = take_while(1.., |character| character != '\"').parse_next(input)?;
     let _ = "\" ".parse_next(input)?;
-    return tz
+
+    // Try and use the built in timezone system first before trying to use the
+    // chrono_tz library which can handle named timezones
+    if let Ok(mut offset) = peek(time::timezone).parse_next(&mut tz_name) {
+        offset.negative = !offset.negative;
+        offset
+            .try_into()
+            .map_err(|_| ErrMode::Cut(ctx_err("Invalid timezone")))
+    } else {
+        let conv: Tz = chrono_tz::Tz::from_str_insensitive(tz_name)
+            .map_err(|_| ErrMode::Cut(ctx_err("Invalid timezone")))?;
+        Ok(chrono::Offset::fix(
+            &conv.offset_from_utc_date(&NaiveDate::default()),
+        ))
+    }
 }

src/items/builder.rs

@@ -31,14 +31,14 @@
 
 // date and time items
 mod combined;
+mod conversion_timezone;
 mod date;
 mod epoch;
 mod relative;
 mod time;
 mod timezone;
 mod weekday;
 mod year;
-mod conversion_timezone;
 
 // utility modules
 mod builder;
@@ -59,7 +59,7 @@ use crate::ParseDateTimeError;
 
 #[derive(PartialEq, Debug)]
 pub(crate) enum Item {
-    ConversionTimeZone(time::Offset),
+    ConversionTimeZone(FixedOffset),
     Timestamp(f64),
     Year(u32),
     DateTime(combined::DateTime),

src/items/conversion_timezone.rs

@@ -93,3 +93,29 @@ fn test_date_omitting_year(#[case] input: &str, #[case] year: u32, #[case] expec
     let now = DateTime::parse_from_rfc3339(&format!("{year}-06-01T00:00:00+00:00")).unwrap();
     check_relative(now, input, expected);
 }
+
+#[rstest]
+#[case::convert_timezone_ahead(r#"TZ="UTC+1" 2022-12-14"#, 2022, "2022-12-14 01:00:00+00:00")]
+#[case::convert_timezone_behind(r#"TZ="UTC-1" 2022-12-14"#, 2022, "2022-12-13 23:00:00+00:00")]
+#[case::convert_timezone_ahead_minutes(
+    r#"TZ="UTC+1:30" 2022-12-14"#,
+    2022,
+    "2022-12-14 01:30:00+00:00"
+)]
+#[case::convert_timezone_behind_minutes(
+    r#"TZ="UTC-1:30" 2022-12-14"#,
+    2022,
+    "2022-12-13 22:30:00+00:00"
+)]
+#[case::convert_named_timezone(
+    r#"TZ="America/New_York" 2022-12-14 12:00"#,
+    2022,
+    "2022-12-14 17:00:00+00:00"
+)]
+fn test_conversion_date(#[case] input: &str, #[case] year: u32, #[case] expected: &str) {
+    use chrono::DateTime;
+    use common::check_relative;
+
+    let now = DateTime::parse_from_rfc3339(&format!("{year}-06-01T00:00:00+00:00")).unwrap();
+    check_relative(now, input, expected);
+}