Bump to 0.9.1 with 2024b

chrono-tz-build/src/lib.rs

@@ -41,14 +41,18 @@ fn format_rest(rest: Vec<(i64, FixedTimespan)>) -> String {
         },
     ) in rest
     {
+        let timespan_name = match name.as_ref() {
+            "%z" => None,
+            name => Some(name),
+        };
         ret.push_str(&format!(
             "                    ({start}, FixedTimespan {{ \
-             utc_offset: {utc}, dst_offset: {dst}, name: \"{name}\" \
+             utc_offset: {utc}, dst_offset: {dst}, name: {name:?} \
              }}),\n",
             start = start,
             utc = utc_offset,
             dst = dst_offset,
-            name = name,
+            name = timespan_name,
         ));
     }
     ret.push_str("                ]");
@@ -230,6 +234,10 @@ impl FromStr for Tz {{
     for zone in &zones {
         let timespans = table.timespans(zone).unwrap();
         let zone_name = convert_bad_chars(zone);
+        let timespan_name = match timespans.first.name.as_ref() {
+            "%z" => None,
+            name => Some(name),
+        };
         writeln!(
             timezone_file,
             "            Tz::{zone} => {{
@@ -238,7 +246,7 @@ impl FromStr for Tz {{
                     first: FixedTimespan {{
                         utc_offset: {utc},
                         dst_offset: {dst},
-                        name: \"{name}\",
+                        name: {name:?},
                     }},
                     rest: REST
                 }}
@@ -247,7 +255,7 @@ impl FromStr for Tz {{
             rest = format_rest(timespans.rest),
             utc = timespans.first.utc_offset,
             dst = timespans.first.dst_offset,
-            name = timespans.first.name,
+            name = timespan_name,
         )?;
     }
     write!(

chrono-tz/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "chrono-tz"
-version = "0.9.0"
+version = "0.10.0"
 edition = "2021"
 rust-version = "1.60"
 build = "build.rs"

chrono-tz/src/lib.rs

@@ -148,7 +148,10 @@ pub use crate::IANA_TZDB_VERSION;
 
 #[cfg(test)]
 mod tests {
+    use super::Africa::Addis_Ababa;
     use super::America::Danmarkshavn;
+    use super::America::Scoresbysund;
+    use super::Antarctica::Casey;
     use super::Asia::Dhaka;
     use super::Australia::Adelaide;
     use super::Europe::Berlin;
@@ -496,4 +499,19 @@ mod tests {
         assert_eq!(4, numbers.len());
         assert!(IANA_TZDB_VERSION.ends_with(|c: char| c.is_ascii_lowercase()));
     }
+
+    #[test]
+    fn test_numeric_names() {
+        let dt = Scoresbysund
+            .with_ymd_and_hms(2024, 05, 01, 0, 0, 0)
+            .unwrap();
+        assert_eq!(format!("{}", dt.offset()), "-01");
+        assert_eq!(format!("{:?}", dt.offset()), "-01");
+        let dt = Casey.with_ymd_and_hms(2022, 11, 01, 0, 0, 0).unwrap();
+        assert_eq!(format!("{}", dt.offset()), "+11");
+        assert_eq!(format!("{:?}", dt.offset()), "+11");
+        let dt = Addis_Ababa.with_ymd_and_hms(1937, 02, 01, 0, 0, 0).unwrap();
+        assert_eq!(format!("{}", dt.offset()), "+0245");
+        assert_eq!(format!("{:?}", dt.offset()), "+0245");
+    }
 }

chrono-tz/src/timezone_impl.rs

@@ -1,5 +1,5 @@
 use core::cmp::Ordering;
-use core::fmt::{Debug, Display, Error, Formatter};
+use core::fmt::{Debug, Display, Error, Formatter, Write};
 
 use chrono::{
     Duration, FixedOffset, LocalResult, NaiveDate, NaiveDateTime, NaiveTime, Offset, TimeZone,
@@ -26,7 +26,7 @@ pub struct FixedTimespan {
     /// The additional offset from UTC for this timespan; typically for daylight saving time
     pub dst_offset: i32,
     /// The name of this timezone, for example the difference between `EDT`/`EST`
-    pub name: &'static str,
+    pub name: Option<&'static str>,
 }
 
 impl Offset for FixedTimespan {
@@ -37,13 +37,38 @@ impl Offset for FixedTimespan {
 
 impl Display for FixedTimespan {
     fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error> {
-        write!(f, "{}", self.name)
+        if let Some(name) = self.name {
+            return write!(f, "{}", name);
+        }
+        let offset = self.utc_offset + self.dst_offset;
+        let (sign, off) = if offset < 0 {
+            ('-', -offset)
+        } else {
+            ('+', offset)
+        };
+
+        let minutes = off / 60;
+        let secs = (off % 60) as u8;
+        let mins = (minutes % 60) as u8;
+        let hours = (minutes / 60) as u8;
+
+        assert!(
+            secs == 0,
+            "numeric names are not used if the offset has fractional minutes"
+        );
+
+        f.write_char(sign)?;
+        write!(f, "{:02}", hours)?;
+        if mins != 0 {
+            write!(f, "{:02}", mins)?;
+        }
+        Ok(())
     }
 }
 
 impl Debug for FixedTimespan {
     fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error> {
-        write!(f, "{}", self.name)
+        Display::fmt(self, f)
     }
 }
 
@@ -104,13 +129,13 @@ pub trait OffsetComponents {
 /// let london_time = London.ymd(2016, 2, 10).and_hms(12, 0, 0);
 /// assert_eq!(london_time.offset().tz_id(), "Europe/London");
 /// // London is normally on GMT
-/// assert_eq!(london_time.offset().abbreviation(), "GMT");
+/// assert_eq!(london_time.offset().abbreviation(), Some("GMT"));
 ///
 /// let london_summer_time = London.ymd(2016, 5, 10).and_hms(12, 0, 0);
 /// // The TZ ID remains constant year round
 /// assert_eq!(london_summer_time.offset().tz_id(), "Europe/London");
 /// // During the summer, this becomes British Summer Time
-/// assert_eq!(london_summer_time.offset().abbreviation(), "BST");
+/// assert_eq!(london_summer_time.offset().abbreviation(), Some("BST"));
 /// # }
 /// ```
 pub trait OffsetName {
@@ -121,7 +146,7 @@ pub trait OffsetName {
     /// This takes into account any special offsets that may be in effect.
     /// For example, at a given instant, the time zone with ID *America/New_York*
     /// may be either *EST* or *EDT*.
-    fn abbreviation(&self) -> &str;
+    fn abbreviation(&self) -> Option<&str>;
 }
 
 impl TzOffset {
@@ -155,7 +180,7 @@ impl OffsetName for TzOffset {
         self.tz.name()
     }
 
-    fn abbreviation(&self) -> &str {
+    fn abbreviation(&self) -> Option<&str> {
         self.offset.name
     }
 }

chrono-tz/src/timezones.rs.example

@@ -39,79 +39,79 @@ impl TimeSpans for Tz {
         match *self {
             Tz::America__New_York => {
                 const REST: &'static [(i64, FixedTimespan)] = &[
-                    (-2717650800, FixedTimespan { utc_offset: -18000, dst_offset: 0, name: "EST" }),
-                    (-1633280400, FixedTimespan { utc_offset: -18000, dst_offset: 3600, name: "EDT" }),
-                    (-1615140000, FixedTimespan { utc_offset: -18000, dst_offset: 0, name: "EST" }),
+                    (-2717650800, FixedTimespan { utc_offset: -18000, dst_offset: 0, name: Some("EST") }),
+                    (-1633280400, FixedTimespan { utc_offset: -18000, dst_offset: 3600, name: Some("EDT") }),
+                    (-1615140000, FixedTimespan { utc_offset: -18000, dst_offset: 0, name: Some("EST") }),
                 ];
                 FixedTimespanSet {
                     first: FixedTimespan {
                         utc_offset: -17762,
                         dst_offset: 0,
-                        name: "LMT",
+                        name: Some("LMT"),
                     },
                     rest: REST
                 }
             },
 
             Tz::America__Toronto => {
                 const REST: &'static [(i64, FixedTimespan)] = &[
-                    (-2366736148, FixedTimespan { utc_offset: -18000, dst_offset: 0, name: "EST" }),
-                    (-1632070800, FixedTimespan { utc_offset: -18000, dst_offset: 3600, name: "EDT" }),
-                    (-1615140000, FixedTimespan { utc_offset: -18000, dst_offset: 0, name: "EST" }),
+                    (-2366736148, FixedTimespan { utc_offset: -18000, dst_offset: 0, name: Some("EST") }),
+                    (-1632070800, FixedTimespan { utc_offset: -18000, dst_offset: 3600, name: Some("EDT") }),
+                    (-1615140000, FixedTimespan { utc_offset: -18000, dst_offset: 0, name: Some("EST") }),
                 ];
                 FixedTimespanSet {
                     first: FixedTimespan {
                         utc_offset: -19052,
                         dst_offset: 0,
-                        name: "LMT",
+                        name: Some("LMT"),
                     },
                     rest: REST
                 }
             },
 
             Tz::Europe__London => {
                 const REST: &'static [(i64, FixedTimespan)] = &[
-                    (-3852662325, FixedTimespan { utc_offset: 0, dst_offset: 0, name: "GMT" }),
-                    (-1691964000, FixedTimespan { utc_offset: 0, dst_offset: 3600, name: "BST" }),
-                    (-1680472800, FixedTimespan { utc_offset: 0, dst_offset: 0, name: "GMT" }),
+                    (-3852662325, FixedTimespan { utc_offset: 0, dst_offset: 0, name: Some("GMT") }),
+                    (-1691964000, FixedTimespan { utc_offset: 0, dst_offset: 3600, name: Some("BST") }),
+                    (-1680472800, FixedTimespan { utc_offset: 0, dst_offset: 0, name: Some("GMT") }),
                 ];
                 FixedTimespanSet {
                     first: FixedTimespan {
                         utc_offset: -75,
                         dst_offset: 0,
-                        name: "LMT",
+                        name: Some("LMT"),
                     },
                     rest: REST
                 }
             },
 
             Tz::Europe__Moscow => {
                 const REST: &'static [(i64, FixedTimespan)] = &[
-                    (-2840149817, FixedTimespan { utc_offset: 9017, dst_offset: 0, name: "MMT" }),
-                    (-1688265017, FixedTimespan { utc_offset: 9079, dst_offset: 0, name: "MMT" }),
-                    (-1656819079, FixedTimespan { utc_offset: 9079, dst_offset: 3600, name: "MST" }),
+                    (-2840149817, FixedTimespan { utc_offset: 9017, dst_offset: 0, name: Some("MMT") }),
+                    (-1688265017, FixedTimespan { utc_offset: 9079, dst_offset: 0, name: Some("MMT") }),
+                    (-1656819079, FixedTimespan { utc_offset: 9079, dst_offset: 3600, name: Some("MST") }),
                 ];
                 FixedTimespanSet {
                     first: FixedTimespan {
                         utc_offset: 9017,
                         dst_offset: 0,
-                        name: "LMT",
+                        name: Some("LMT"),
                     },
                     rest: REST
                 }
             },
 
             Tz::Europe__Rome => {
                 const REST: &'static [(i64, FixedTimespan)] = &[
-                    (-3259097396, FixedTimespan { utc_offset: 2996, dst_offset: 0, name: "RMT" }),
-                    (-2403564596, FixedTimespan { utc_offset: 3600, dst_offset: 0, name: "CET" }),
-                    (-1690851600, FixedTimespan { utc_offset: 3600, dst_offset: 3600, name: "CEST" }),
+                    (-3259097396, FixedTimespan { utc_offset: 2996, dst_offset: 0, name: Some("RMT") }),
+                    (-2403564596, FixedTimespan { utc_offset: 3600, dst_offset: 0, name: Some("CET") }),
+                    (-1690851600, FixedTimespan { utc_offset: 3600, dst_offset: 3600, name: Some("CEST") }),
                 ];
                 FixedTimespanSet {
                     first: FixedTimespan {
                         utc_offset: 2996,
                         dst_offset: 0,
-                        name: "LMT",
+                        name: Some("LMT"),
                     },
                     rest: REST
                 }