Add posix time zone string support

Author: nekevss

provider/src/tzif.rs

@@ -69,7 +69,7 @@ impl ZeroTzif<'_> {
         let mapped_local_records: Vec<LocalTimeRecord> =
             tzif.local_time_types.iter().map(Into::into).collect();
         let types = ZeroVec::alloc_from_slice(&mapped_local_records);
-        let posix = String::from("TODO").into();
+        let posix = Cow::from(data.posix_string.clone());
 
         Self {
             transitions,

zoneinfo/examples/zoneinfo

@@ -304,6 +304,33 @@ Rule	Russia	1984	1995	-	Sep	lastSun	 2:00s	0	-
 Rule	Russia	1985	2010	-	Mar	lastSun	 2:00s	1:00	S
 Rule	Russia	1996	2010	-	Oct	lastSun	 2:00s	0	-
 
+# Minsk and Moscow are primarily added for their POSIX tz test case
+
+Zone	Europe/Minsk	1:50:16 -	LMT	1880
+			1:50	-	MMT	1924 May  2 # Minsk Mean Time
+			2:00	-	EET	1930 Jun 21
+			3:00	-	MSK	1941 Jun 28
+			1:00	C-Eur	CE%sT	1944 Jul  3
+			3:00	Russia	MSK/MSD	1990
+			3:00	-	MSK	1991 Mar 31  2:00s
+			2:00	Russia	EE%sT	2011 Mar 27  2:00s
+			3:00	-	%z
+
+Zone Europe/Moscow	 2:30:17 -	LMT	1880
+			 2:30:17 -	MMT	1916 Jul  3 # Moscow Mean Time
+			 2:31:19 Russia	%s	1919 Jul  1  0:00u
+			 3:00	Russia	%s	1921 Oct
+			 3:00	Russia	MSK/MSD	1922 Oct
+			 2:00	-	EET	1930 Jun 21
+			 3:00	Russia	MSK/MSD	1991 Mar 31  2:00s
+			 2:00	Russia	EE%sT	1992 Jan 19  2:00s
+			 3:00	Russia	MSK/MSD	2011 Mar 27  2:00s
+			 4:00	-	MSK	2014 Oct 26  2:00s
+			 3:00	-	MSK
+
+
+
+
 # Rule	NAME	FROM	TO	-	IN	ON	AT	SAVE	LETTER/S
 Rule	France	1916	only	-	Jun	14	23:00s	1:00	S
 Rule	France	1916	1919	-	Oct	Sun>=1	23:00s	0	-

zoneinfo/src/compiler.rs

@@ -122,9 +122,10 @@ pub struct CompiledTransitionsMap {
 // ==== ZoneInfoCompiler build / compile methods ====
 
 use crate::{
+    posix::PosixTimeZone,
     types::{QualifiedTimeKind, Time},
     tzif::TzifBlockV2,
-    zone::ZoneBuildContext,
+    zone::{ZoneBuildContext, ZoneRecord},
     ZoneInfoData,
 };
 
@@ -185,15 +186,26 @@ impl ZoneInfoCompiler {
             }
         }
 
-        // TODO: POSIX tz string handling
+        let posix_string = zone_table
+            .get_posix_time_zone()
+            .to_string()
+            .expect("to_string only throws when a `write!` fails.");
 
         CompiledTransitions {
             initial_record,
             transitions,
-            posix_string: String::default(),
+            posix_string,
         }
     }
 
+    pub fn get_posix_time_zone(&mut self, target: &str) -> Option<PosixTimeZone> {
+        self.associate();
+        self.data
+            .zones
+            .get(target)
+            .map(ZoneRecord::get_posix_time_zone)
+    }
+
     /// Associates the current `ZoneTables` with their applicable rules.
     pub fn associate(&mut self) {
         for zones in self.data.zones.values_mut() {

zoneinfo/src/lib.rs

@@ -52,6 +52,7 @@ pub(crate) mod utils;
 
 pub mod compiler;
 pub mod parser;
+pub mod posix;
 pub mod rule;
 pub mod types;
 pub mod tzif;

zoneinfo/src/posix.rs

@@ -0,0 +1,264 @@
+use crate::{
+    rule::{LastRules, Rule},
+    types::{DayOfMonth, Month, QualifiedTime, Sign, Time, WeekDay},
+    utils::month_to_day,
+    zone::ZoneEntry,
+};
+use alloc::string::String;
+use core::fmt::Write;
+
+#[derive(Debug)]
+pub struct MonthWeekDay(pub Month, pub u8, pub WeekDay);
+
+#[derive(Debug)]
+pub enum PosixDate {
+    JulianNoLeap(u16),
+    JulianLeap(u16),
+    MonthWeekDay(MonthWeekDay),
+}
+
+impl PosixDate {
+    pub(crate) fn from_rule(rule: &Rule) -> Self {
+        match rule.on_date {
+            DayOfMonth::Day(day) if rule.in_month == Month::Jan || rule.in_month == Month::Feb => {
+                PosixDate::JulianNoLeap(month_to_day(rule.in_month as u8, 1) as u16 + day as u16)
+            }
+            DayOfMonth::Day(day) => {
+                PosixDate::JulianNoLeap(month_to_day(rule.in_month as u8, 1) as u16 + day as u16)
+            }
+            DayOfMonth::Last(wd) => PosixDate::MonthWeekDay(MonthWeekDay(rule.in_month, 5, wd)),
+            DayOfMonth::WeekDayGEThanMonthDay(week_day, day_of_month) => {
+                let week = 1 + (day_of_month - 1) / 7;
+                PosixDate::MonthWeekDay(MonthWeekDay(rule.in_month, week, week_day))
+            }
+            DayOfMonth::WeekDayLEThanMonthDay(week_day, day_of_month) => {
+                let week = day_of_month / 7;
+                PosixDate::MonthWeekDay(MonthWeekDay(rule.in_month, week, week_day))
+            }
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct PosixDateTime {
+    pub date: PosixDate,
+    pub time: Time,
+}
+
+impl PosixDateTime {
+    pub(crate) fn from_rule_and_transition_info(rule: &Rule, offset: Time, savings: Time) -> Self {
+        let date = PosixDate::from_rule(rule);
+        let time = match rule.at {
+            QualifiedTime::Local(time) => time,
+            QualifiedTime::Standard(standard_time) => standard_time.add(rule.save),
+            QualifiedTime::Universal(universal_time) => universal_time.add(offset).add(savings),
+        };
+        Self { date, time }
+    }
+}
+
+#[non_exhaustive]
+#[derive(Debug)]
+pub struct PosixTransition {
+    pub abbr: PosixAbbreviation,
+    pub savings: Time,
+    pub start: PosixDateTime,
+    pub end: PosixDateTime,
+}
+
+#[non_exhaustive]
+#[derive(Debug)]
+pub struct PosixTimeZone {
+    pub abbr: PosixAbbreviation,
+    pub offset: Time,
+    pub transition_info: Option<PosixTransition>,
+}
+
+#[non_exhaustive]
+#[derive(Debug)]
+pub struct PosixAbbreviation {
+    is_numeric: bool,
+    formatted: String,
+}
+
+impl PosixTimeZone {
+    pub(crate) fn from_zone_and_savings(entry: &ZoneEntry, savings: Time) -> Self {
+        let offset = entry.std_offset.add(savings);
+        let formatted = entry
+            .format
+            .format(offset.as_secs(), None, savings != Time::default());
+        let is_numeric = is_numeric(&formatted);
+        let abbr = PosixAbbreviation {
+            is_numeric,
+            formatted,
+        };
+        Self {
+            abbr,
+            offset,
+            transition_info: None,
+        }
+    }
+
+    pub(crate) fn from_zone_and_rules(entry: &ZoneEntry, rules: &LastRules) -> Self {
+        let offset = entry.std_offset.add(rules.standard.save);
+        let formatted = entry.format.format(
+            entry.std_offset.as_secs(),
+            rules.standard.letter.as_deref(),
+            rules.standard.is_dst(),
+        );
+        let is_numeric = is_numeric(&formatted);
+        let abbr = PosixAbbreviation {
+            is_numeric,
+            formatted,
+        };
+
+        let transition_info = rules.saving.as_ref().map(|rule| {
+            let formatted = entry.format.format(
+                entry.std_offset.as_secs() + rule.save.as_secs(),
+                rule.letter.as_deref(),
+                rule.is_dst(),
+            );
+            let abbr = PosixAbbreviation {
+                is_numeric,
+                formatted,
+            };
+            let savings = rule.save;
+            let start = PosixDateTime::from_rule_and_transition_info(
+                rule,
+                entry.std_offset,
+                rules.standard.save,
+            );
+            let end = PosixDateTime::from_rule_and_transition_info(
+                &rules.standard,
+                entry.std_offset,
+                rule.save,
+            );
+            PosixTransition {
+                abbr,
+                savings,
+                start,
+                end,
+            }
+        });
+
+        PosixTimeZone {
+            abbr,
+            offset,
+            transition_info,
+        }
+    }
+}
+
+impl PosixTimeZone {
+    pub fn to_string(&self) -> Result<String, core::fmt::Error> {
+        let mut posix_string = String::new();
+        write_abbr(&self.abbr, &mut posix_string)?;
+        write_inverted_time(&self.offset, &mut posix_string)?;
+
+        if let Some(transition_info) = &self.transition_info {
+            write_abbr(&transition_info.abbr, &mut posix_string)?;
+            if transition_info.savings != Time::one() {
+                write_inverted_time(&self.offset.add(transition_info.savings), &mut posix_string)?;
+            }
+            write_date_time(&transition_info.start, &mut posix_string)?;
+            write_date_time(&transition_info.end, &mut posix_string)?;
+        }
+        Ok(posix_string)
+    }
+}
+
+fn is_numeric(str: &str) -> bool {
+    str.parse::<i16>().is_ok()
+}
+
+fn write_abbr(posix_abbr: &PosixAbbreviation, output: &mut String) -> core::fmt::Result {
+    if posix_abbr.is_numeric {
+        write!(output, "<")?;
+        write!(output, "{}", posix_abbr.formatted)?;
+        write!(output, ">")?;
+        return Ok(());
+    }
+    write!(output, "{}", posix_abbr.formatted)
+}
+
+fn write_inverted_time(time: &Time, output: &mut String) -> core::fmt::Result {
+    // Yep, it's inverted
+    if time.sign == Sign::Positive && time.hour != 0 {
+        write!(output, "-")?;
+    }
+    write_time(time, output)
+}
+
+fn write_time(time: &Time, output: &mut String) -> core::fmt::Result {
+    write!(output, "{}", time.hour)?;
+    if time.minute == 0 && time.second == 0 {
+        return Ok(());
+    }
+    write!(output, ":{}", time.minute)?;
+    if time.second > 0 {
+        write!(output, ":{}", time.second)?;
+    }
+    Ok(())
+}
+
+fn write_date_time(datetime: &PosixDateTime, output: &mut String) -> core::fmt::Result {
+    write!(output, ",")?;
+    match datetime.date {
+        PosixDate::JulianLeap(d) => write!(output, "{d}")?,
+        PosixDate::JulianNoLeap(d) => write!(output, "J{d}")?,
+        PosixDate::MonthWeekDay(MonthWeekDay(month, week, day)) => {
+            write!(output, "M{}.{week}.{}", month as u8, day as u8)?
+        }
+    }
+    if datetime.time != Time::two() {
+        write!(output, "/")?;
+        write_time(&datetime.time, output)?;
+    }
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    #[cfg(feature = "std")]
+    #[test]
+    fn posix_string_test() {
+        use std::path::Path;
+
+        use crate::{ZoneInfoCompiler, ZoneInfoData};
+
+        let manifest_dir = Path::new(env!("CARGO_MANIFEST_DIR"));
+        let zoneinfo = ZoneInfoData::from_filepath(manifest_dir.join("examples/zoneinfo")).unwrap();
+
+        let mut zic = ZoneInfoCompiler::new(zoneinfo);
+
+        let chicago_posix = zic.get_posix_time_zone("America/Chicago").unwrap();
+        assert_eq!(
+            chicago_posix.to_string(),
+            Ok("CST6CDT,M3.2.0,M11.1.0".into())
+        );
+
+        let lord_howe_posix = zic.get_posix_time_zone("Australia/Lord_Howe").unwrap();
+        assert_eq!(
+            lord_howe_posix.to_string(),
+            Ok("<+1030>-10:30<+11>-11,M10.1.0,M4.1.0".into())
+        );
+
+        let troll_posix = zic.get_posix_time_zone("Antarctica/Troll").unwrap();
+        assert_eq!(
+            troll_posix.to_string(),
+            Ok("<+00>0<+02>-2,M3.5.0/1,M10.5.0/3".into())
+        );
+
+        let dublin_posix = zic.get_posix_time_zone("Europe/Dublin").unwrap();
+        assert_eq!(
+            dublin_posix.to_string(),
+            Ok("IST-1GMT0,M10.5.0,M3.5.0/1".into())
+        );
+
+        let minsk_posix = zic.get_posix_time_zone("Europe/Minsk").unwrap();
+        assert_eq!(minsk_posix.to_string(), Ok("<+03>-3".into()));
+
+        let moscow_posix = zic.get_posix_time_zone("Europe/Moscow").unwrap();
+        assert_eq!(moscow_posix.to_string(), Ok("MSK-3".into()));
+    }
+}