Add POSIX time zone string support to zoneinfo

provider/Cargo.toml

@@ -22,6 +22,8 @@ datagen = [
     "dep:databake",
     "dep:yoke",
     "dep:serde_json",
+    "tinystr/serde",
+    "tinystr/databake",
     "zerotrie/serde",
     "zerotrie/databake",
     "zerovec/serde",
@@ -36,6 +38,7 @@ std = []
 # Provider dependency
 zerotrie = "0.2.2"
 zerovec = { version = "0.11.2", features = ["derive", "alloc"] }
+tinystr = { workspace = true, features = ["zerovec"] }
 
 # IANA dependency
 zoneinfo_rs = { workspace = true, features = ["std"], optional = true }

provider/src/lib.rs

@@ -11,6 +11,7 @@ extern crate alloc;
 #[cfg(feature = "std")]
 extern crate std;
 
+pub mod posix;
 mod tzdb;
 pub mod tzif;
 

provider/src/posix.rs

@@ -0,0 +1,130 @@
+use tinystr::TinyAsciiStr;
+#[cfg(feature = "datagen")]
+use zoneinfo_rs::posix::{MonthWeekDay, PosixDate, PosixDateTime, PosixTimeZone, PosixTransition};
+
+#[zerovec::make_ule(PosixZoneULE)]
+#[derive(PartialEq, Eq, Debug, Clone, Copy, PartialOrd, Ord)]
+#[cfg_attr(
+    feature = "datagen",
+    derive(yoke::Yokeable, serde::Serialize, databake::Bake)
+)]
+#[cfg_attr(feature = "datagen", databake(path = timezone_provider::tzif))]
+pub struct PosixZone {
+    abbr: TinyAsciiStr<5>,
+    offset: i64,
+    transition: Option<ZeroPosixTransition>,
+}
+
+#[cfg(feature = "datagen")]
+impl From<&PosixTimeZone> for PosixZone {
+    fn from(value: &PosixTimeZone) -> Self {
+        let abbr = TinyAsciiStr::<5>::try_from_str(&value.abbr.formatted).unwrap();
+        let offset = value.offset.as_secs();
+        let transition = value
+            .transition_info
+            .as_ref()
+            .map(ZeroPosixTransition::from);
+
+        Self {
+            abbr,
+            offset,
+            transition,
+        }
+    }
+}
+
+#[zerovec::make_ule(PosixTransitionULE)]
+#[derive(PartialEq, Eq, Debug, Clone, Copy, PartialOrd, Ord)]
+#[cfg_attr(
+    feature = "datagen",
+    derive(yoke::Yokeable, serde::Serialize, databake::Bake)
+)]
+#[cfg_attr(feature = "datagen", databake(path = timezone_provider::tzif))]
+pub struct ZeroPosixTransition {
+    abbr: TinyAsciiStr<5>,
+    savings: i64,
+    start: ZeroTransitionDateTime,
+    end: ZeroTransitionDateTime,
+}
+
+#[cfg(feature = "datagen")]
+impl From<&PosixTransition> for ZeroPosixTransition {
+    fn from(value: &PosixTransition) -> Self {
+        let abbr = TinyAsciiStr::<5>::try_from_str(&value.abbr.formatted).unwrap();
+        let savings = value.savings.as_secs();
+        let start = ZeroTransitionDateTime::from(&value.start);
+        let end = ZeroTransitionDateTime::from(&value.end);
+        Self {
+            abbr,
+            savings,
+            start,
+            end,
+        }
+    }
+}
+
+#[zerovec::make_ule(TransitionDateTimeULE)]
+#[derive(PartialEq, Eq, Debug, Clone, Copy, PartialOrd, Ord)]
+#[cfg_attr(
+    feature = "datagen",
+    derive(yoke::Yokeable, serde::Serialize, databake::Bake)
+)]
+#[cfg_attr(feature = "datagen", databake(path = timezone_provider::tzif))]
+pub struct ZeroTransitionDateTime {
+    /// The date at which a transition should occur.
+    date: ZeroTransitionDate,
+    /// The time of day in seconds.
+    time: i64,
+}
+
+#[cfg(feature = "datagen")]
+impl From<&PosixDateTime> for ZeroTransitionDateTime {
+    fn from(value: &PosixDateTime) -> Self {
+        Self {
+            date: value.date.into(),
+            time: value.time.as_secs(),
+        }
+    }
+}
+
+#[zerovec::make_ule(DateULE)]
+#[derive(PartialEq, Eq, Debug, Clone, Copy, PartialOrd, Ord)]
+#[cfg_attr(
+    feature = "datagen",
+    derive(yoke::Yokeable, serde::Serialize, databake::Bake)
+)]
+#[cfg_attr(feature = "datagen", databake(path = timezone_provider::tzif))]
+pub struct ZeroTransitionDate {
+    kind: DateKind,
+    day: Option<u16>,
+    mwd: Option<(u8, u8, u8)>,
+}
+
+#[cfg(feature = "datagen")]
+impl From<PosixDate> for ZeroTransitionDate {
+    fn from(value: PosixDate) -> Self {
+        let (kind, day, mwd) = match value {
+            PosixDate::JulianLeap(day) => (DateKind::Julian, Some(day), None),
+            PosixDate::JulianNoLeap(day) => (DateKind::JulianNoLeap, Some(day), None),
+            PosixDate::MonthWeekDay(MonthWeekDay(month, week, day)) => (
+                DateKind::MonthWeekDay,
+                None,
+                Some((month as u8, week, day as u8)),
+            ),
+        };
+        Self { kind, day, mwd }
+    }
+}
+#[zerovec::make_ule(DateKindULE)]
+#[derive(PartialEq, Eq, Debug, Clone, Copy, PartialOrd, Ord)]
+#[cfg_attr(
+    feature = "datagen",
+    derive(yoke::Yokeable, serde::Serialize, databake::Bake)
+)]
+#[cfg_attr(feature = "datagen", databake(path = timezone_provider::tzif))]
+#[repr(u8)]
+pub enum DateKind {
+    JulianNoLeap = 0,
+    Julian = 1,
+    MonthWeekDay = 2,
+}

provider/src/tzdb.rs

@@ -96,8 +96,8 @@ pub enum IanaDataError {
     Build(zerotrie::ZeroTrieBuildError),
 }
 
+#[cfg(feature = "datagen")]
 impl IanaIdentifierNormalizer<'_> {
-    #[cfg(feature = "datagen")]
     pub fn build(tzdata_path: &Path) -> Result<Self, IanaDataError> {
         let provider = TzdbDataSource::try_from_zoneinfo_directory(tzdata_path)
             .map_err(IanaDataError::Provider)?;

provider/src/tzif.rs

@@ -7,15 +7,19 @@
 #[cfg(feature = "datagen")]
 use alloc::vec::Vec;
 
-#[cfg(feature = "datagen")]
-use std::{collections::BTreeMap, path::Path};
 use zerotrie::ZeroAsciiIgnoreCaseTrie;
+use zerovec::{vecs::Index32, VarZeroVec, ZeroVec};
+
+#[cfg(feature = "datagen")]
+use alloc::collections::BTreeMap;
+#[cfg(feature = "datagen")]
+use std::path::Path;
 #[cfg(feature = "datagen")]
 use zerotrie::ZeroTrieBuildError;
-use zerovec::{vecs::Index32, VarZeroVec, ZeroVec};
 #[cfg(feature = "datagen")]
 use zoneinfo_rs::{compiler::CompiledTransitions, ZoneInfoCompiler, ZoneInfoData};
 
+use crate::posix::PosixZone;
 #[cfg(feature = "datagen")]
 use crate::tzdb::TzdbDataSource;
 
@@ -47,7 +51,7 @@ pub struct ZeroTzif<'data> {
     pub transition_types: ZeroVec<'data, u8>,
     // NOTE: zoneinfo64 does a fun little bitmap str
     pub types: ZeroVec<'data, LocalTimeRecord>,
-    pub posix: &'data str,
+    pub posix: PosixZone,
 }
 
 #[zerovec::make_ule(LocalTimeRecordULE)]
@@ -70,16 +74,17 @@ impl From<&zoneinfo_rs::tzif::LocalTimeRecord> for LocalTimeRecord {
     }
 }
 
+#[cfg(feature = "datagen")]
 impl ZeroTzif<'_> {
-    #[cfg(feature = "datagen")]
     fn from_transition_data(data: &CompiledTransitions) -> Self {
         let tzif = data.to_v2_data_block();
         let transitions = ZeroVec::alloc_from_slice(&tzif.transition_times);
         let transition_types = ZeroVec::alloc_from_slice(&tzif.transition_types);
         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 = "TODO";
+        // TODO: handle this much better.
+        let posix = PosixZone::from(&data.posix_time_zone);
 
         Self {
             transitions,
@@ -96,8 +101,8 @@ pub enum ZoneInfoDataError {
     Build(ZeroTrieBuildError),
 }
 
+#[cfg(feature = "datagen")]
 impl ZoneInfoProvider<'_> {
-    #[cfg(feature = "datagen")]
     pub fn build(tzdata: &Path) -> Result<Self, ZoneInfoDataError> {
         let tzdb_source = TzdbDataSource::try_from_zoneinfo_directory(tzdata).unwrap();
         let compiled_transitions = ZoneInfoCompiler::new(tzdb_source.data.clone()).build();

zoneinfo/src/compiler.rs

@@ -99,7 +99,7 @@ pub struct CompiledTransitions {
     /// The POSIX time zone string
     ///
     /// This string should be used to calculate the time zone beyond the last available transition.
-    pub posix_string: String, // TODO: Implement POSIX string building
+    pub posix_time_zone: PosixTimeZone,
 }
 
 // NOTE: candidate for removal? Should this library offer TZif structs long term?
@@ -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,23 @@ impl ZoneInfoCompiler {
             }
         }
 
-        // TODO: POSIX tz string handling
+        let posix_time_zone = zone_table.get_posix_time_zone();
 
         CompiledTransitions {
             initial_record,
             transitions,
-            posix_string: String::default(),
+            posix_time_zone,
         }
     }
 
+    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

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