Add TZ="timezone" support

Cargo.toml

@@ -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"

src/items/builder.rs

@@ -17,6 +17,7 @@ pub(crate) struct DateTimeBuilder {
     date: Option<date::Date>,
     time: Option<time::Time>,
     weekday: Option<weekday::Weekday>,
+    conversion_timezone: Option<FixedOffset>,
     timezone: Option<timezone::Offset>,
     relative: Vec<relative::Relative>,
 }
@@ -99,14 +100,25 @@ impl DateTimeBuilder {
         Ok(self)
     }
 
+    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 {
+            self.conversion_timezone = Some(conversion_timezone);
+            Ok(self)
+        }
+    }
+
     pub(super) fn push_relative(
         mut self,
         relative: relative::Relative,
     ) -> Result<Self, &'static str> {
         if self.timestamp.is_some() {
             return Err("timestamp cannot be combined with other date/time items");
         }
-
         self.relative.push(relative);
         Ok(self)
     }
@@ -311,7 +323,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(conversion_timezone) = self.conversion_timezone {
+            dt = with_timezone_restore(conversion_timezone, dt)?;
         }
 
         Some(dt)
@@ -338,10 +355,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: timezone::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)

src/items/conversion_timezone.rs

@@ -0,0 +1,29 @@
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+
+use chrono::{FixedOffset, NaiveDate, TimeZone};
+use chrono_tz::Tz;
+use winnow::{combinator::peek, error::ErrMode, token::take_while, ModalResult, Parser};
+
+use super::{primitive::ctx_err, timezone};
+
+pub(crate) fn parse(input: &mut &str) -> ModalResult<FixedOffset> {
+    let _ = "tz=\"".parse_next(input)?;
+    let mut tz_name = take_while(1.., |character| character != '\"').parse_next(input)?;
+    let _ = "\" ".parse_next(input)?;
+
+    // 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(timezone::parse).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/mod.rs

@@ -30,6 +30,7 @@
 
 // date and time items
 mod combined;
+mod conversion_timezone;
 mod date;
 mod epoch;
 mod pure;
@@ -58,6 +59,7 @@ use crate::ParseDateTimeError;
 
 #[derive(PartialEq, Debug)]
 pub(crate) enum Item {
+    ConversionTimeZone(FixedOffset),
     Timestamp(f64),
     DateTime(combined::DateTime),
     Date(date::Date),
@@ -214,6 +216,11 @@ fn parse_items(input: &mut &str) -> ModalResult<DateTimeBuilder> {
     loop {
         match parse_item.parse_next(input) {
             Ok(item) => match item {
+                Item::ConversionTimeZone(tz) => {
+                    builder = builder
+                        .set_conversion_timezone(tz)
+                        .map_err(|e| expect_error(input, e))?;
+                }
                 Item::Timestamp(ts) => {
                     builder = builder
                         .set_timestamp(ts)
@@ -269,6 +276,7 @@ fn parse_item(input: &mut &str) -> ModalResult<Item> {
     trace(
         "parse_item",
         alt((
+            conversion_timezone::parse.map(Item::ConversionTimeZone),
             combined::parse.map(Item::DateTime),
             date::parse.map(Item::Date),
             time::parse.map(Item::Time),

tests/date.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);
+}