Use simpler constructor to cast from chrono_tz::Tz

Instead of generating one const variant of Tz for each chrono_tz::tz
variant, provide a const function to convert chrono_tz::Tz into Tz in a
static context.

The main change here is the introduction of Tz::from_static(). Other
changes merely adapt existing code to use this instead of chrono_tz
directly.

Author: WhyNotHugo

rrule-afl-fuzz/Cargo.toml

@@ -12,6 +12,7 @@ rust-version.workspace = true
 [dependencies]
 afl = "*"
 chrono = "0.4.39"
+chrono-tz = "0.10.1"
 num-traits = "0.2.19"
 
 [dependencies.rrule]

rrule-afl-fuzz/src/take_data.rs

@@ -67,10 +67,11 @@ pub fn take_datetime(input: &mut &[u8]) -> DateTime<Tz> {
         LocalResult::None => {
             // Will always succeed
             let nanos: i64 = take_data_i64(input);
-            Utc.timestamp_nanos(nanos).with_timezone(&Tz::UTC)
+            Utc.timestamp_nanos(nanos)
+                .with_timezone(&Tz::from_static(chrono_tz::UTC))
         }
         LocalResult::Single(datetime) | LocalResult::Ambiguous(datetime, _) => {
-            datetime.with_timezone(&Tz::UTC)
+            datetime.with_timezone(&Tz::from_static(chrono_tz::UTC))
         }
     }
 }

rrule-debugger/Cargo.toml

@@ -12,6 +12,7 @@ rust-version.workspace = true
 [dependencies]
 rrule = { path = "../rrule" }
 chrono = "0.4.39"
+chrono-tz = "0.10.1"
 clap = { version = "4.5.26", features = ["derive"] }
 rrule-afl-fuzz = { version = "0.1.0", path = "../rrule-afl-fuzz" }
 log = "0.4.25"

rrule-debugger/src/debug.rs

@@ -36,7 +36,7 @@ fn test_parsed_rrule() {
 }
 
 fn ymd_hms(year: i32, month: u32, day: u32, hour: u32, minute: u32, second: u32) -> DateTime<Tz> {
-    Tz::UTC
+    Tz::from(chrono_tz::UTC)
         .with_ymd_and_hms(year, month, day, hour, minute, second)
         .unwrap()
 }

rrule/examples/manual_rrule.rs

@@ -7,7 +7,9 @@ use rrule::{Frequency, RRule, Tz};
 
 fn main() {
     // Build an RRuleSet that starts the first day in 2020 at 9:00AM and occurs daily 5 times
-    let start_date = Tz::UTC.with_ymd_and_hms(2020, 1, 1, 9, 0, 0).unwrap();
+    let start_date = Tz::from(chrono_tz::UTC)
+        .with_ymd_and_hms(2020, 1, 1, 9, 0, 0)
+        .unwrap();
     let rrule_set = RRule::default()
         .count(5)
         .freq(Frequency::Daily)

rrule/examples/manual_rrule_set.rs

@@ -19,15 +19,23 @@ fn main() {
                 NWeekday::Every(Weekday::Tue),
                 NWeekday::Every(Weekday::Wed),
             ])
-            .build(Tz::UTC.with_ymd_and_hms(2020, 1, 1, 9, 0, 0).unwrap())
+            .build(
+                Tz::from(chrono_tz::UTC)
+                    .with_ymd_and_hms(2020, 1, 1, 9, 0, 0)
+                    .unwrap(),
+            )
             .expect("RRule invalid");
 
         // Build exrule that occurs weekly on Wednesday
         let exrule = RRule::default()
             .count(4)
             .freq(Frequency::Weekly)
             .by_weekday(vec![NWeekday::Every(Weekday::Wed)])
-            .validate(Tz::UTC.with_ymd_and_hms(2020, 1, 1, 9, 0, 0).unwrap())
+            .validate(
+                Tz::from(chrono_tz::UTC)
+                    .with_ymd_and_hms(2020, 1, 1, 9, 0, 0)
+                    .unwrap(),
+            )
             .expect("RRule invalid");
 
         let recurrences = rrule_set.exrule(exrule).all(10).dates;

rrule/examples/timezone_support.rs

@@ -8,9 +8,11 @@ use chrono::{DateTime, TimeZone};
 use rrule::{Frequency, RRule, Tz};
 
 fn main() {
-    let tz = Tz::Europe__Berlin;
+    let tz = Tz::from(chrono_tz::Europe::Berlin);
     let start_date = tz.with_ymd_and_hms(2020, 1, 1, 9, 0, 0).unwrap();
-    let exdate = Tz::UTC.with_ymd_and_hms(2020, 1, 2, 8, 0, 0).unwrap();
+    let exdate = Tz::from(chrono_tz::UTC)
+        .with_ymd_and_hms(2020, 1, 2, 8, 0, 0)
+        .unwrap();
 
     // Build an rrule set that occurs daily at 9:00 for 4 times
     let rrule_set = RRule::default()

rrule/src/core/rruleset.rs

@@ -355,7 +355,9 @@ mod tests {
         let rruleset = RRuleSet::from_str(rruleset_str).unwrap();
 
         // Check start date
-        let dt_start = Tz::UTC.with_ymd_and_hms(2012, 2, 1, 9, 30, 0).unwrap();
+        let dt_start = Tz::from(chrono_tz::UTC)
+            .with_ymd_and_hms(2012, 2, 1, 9, 30, 0)
+            .unwrap();
         assert_eq!(rruleset.dt_start, dt_start);
 
         // Check rrule
@@ -371,8 +373,12 @@ mod tests {
         assert_eq!(
             rruleset.rdate,
             vec![
-                Tz::UTC.with_ymd_and_hms(1997, 1, 1, 0, 0, 0).unwrap(),
-                Tz::UTC.with_ymd_and_hms(1997, 1, 20, 0, 0, 0).unwrap()
+                Tz::from(chrono_tz::UTC)
+                    .with_ymd_and_hms(1997, 1, 1, 0, 0, 0)
+                    .unwrap(),
+                Tz::from(chrono_tz::UTC)
+                    .with_ymd_and_hms(1997, 1, 20, 0, 0, 0)
+                    .unwrap()
             ]
         );
 
@@ -389,7 +395,9 @@ mod tests {
         // Check exdate
         assert_eq!(
             rruleset.exdate,
-            vec![Tz::UTC.with_ymd_and_hms(1997, 1, 21, 0, 0, 0).unwrap()]
+            vec![Tz::from(chrono_tz::UTC)
+                .with_ymd_and_hms(1997, 1, 21, 0, 0, 0)
+                .unwrap()]
         );
 
         // Serialize to string again