Add feature gated defmt support.

pebender · djc · commit 35f9f2daef4c · 2025-10-19T10:02:10.000+02:00
diff --git a/Cargo.toml b/Cargo.toml
@@ -20,6 +20,7 @@ name = "chrono"
 # Don't forget to adjust `ALL_NON_EXCLUSIVE_FEATURES` in CI scripts when adding a feature or an optional dependency.
 default = ["clock", "std", "oldtime", "wasmbind"]
 alloc = []
+defmt = ["dep:defmt", "pure-rust-locales?/defmt"]
 libc = []
 winapi = ["windows-link"]
 std = ["alloc"]
@@ -41,9 +42,10 @@ __internal_bench = []
 [dependencies]
 num-traits = { version = "0.2", default-features = false }
 serde = { version = "1.0.99", default-features = false, optional = true }
-pure-rust-locales = { version = "0.8", optional = true }
+pure-rust-locales = { version = "0.8.2", optional = true }
 rkyv = { version = "0.7.43", optional = true, default-features = false }
 arbitrary = { version = "1.0.0", features = ["derive"], optional = true }
+defmt = { version = "1.0.1", optional = true }
 
 [target.'cfg(all(target_arch = "wasm32", not(any(target_os = "emscripten", target_os = "wasi"))))'.dependencies]
 wasm-bindgen = { version = "0.2", optional = true }
diff --git a/src/date.rs b/src/date.rs
@@ -551,6 +551,16 @@ where
     }
 }
 
+#[cfg(feature = "defmt")]
+impl<Tz: TimeZone> defmt::Format for Date<Tz>
+where
+    Tz::Offset: defmt::Format,
+{
+    fn format(&self, fmt: defmt::Formatter) {
+        defmt::write!(fmt, "{}{}", self.naive_local(), self.offset);
+    }
+}
+
 // Note that implementation of Arbitrary cannot be automatically derived for Date<Tz>, due to
 // the nontrivial bound <Tz as TimeZone>::Offset: Arbitrary.
 #[cfg(all(feature = "arbitrary", feature = "std"))]
diff --git a/src/datetime/mod.rs b/src/datetime/mod.rs
@@ -1812,6 +1812,16 @@ impl<Tz: TimeZone> fmt::Debug for DateTime<Tz> {
     }
 }
 
+#[cfg(feature = "defmt")]
+impl<Tz: TimeZone> defmt::Format for DateTime<Tz>
+where
+    Tz::Offset: defmt::Format,
+{
+    fn format(&self, fmt: defmt::Formatter) {
+        defmt::write!(fmt, "{}{}", self.overflowing_naive_local(), self.offset);
+    }
+}
+
 // `fmt::Debug` is hand implemented for the `rkyv::Archive` variant of `DateTime` because
 // deriving a trait recursively does not propagate trait defined associated types with their own
 // constraints:
diff --git a/src/format/formatting.rs b/src/format/formatting.rs
@@ -474,6 +474,7 @@ impl OffsetFormat {
 ///
 /// See the `TimeZone::to_rfc3339_opts` function for usage.
 #[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
 #[allow(clippy::manual_non_exhaustive)]
 pub enum SecondsFormat {
     /// Format whole seconds only, with no decimal point nor subseconds.
diff --git a/src/format/mod.rs b/src/format/mod.rs
@@ -78,6 +78,7 @@ enum Void {}
 
 /// Padding characters for numeric items.
 #[derive(Copy, Clone, PartialEq, Eq, Debug, Hash)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
 pub enum Pad {
     /// No padding.
     None,
@@ -102,6 +103,7 @@ pub enum Pad {
 /// parsed with the same formatting items.
 #[non_exhaustive]
 #[derive(Clone, PartialEq, Eq, Debug, Hash)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
 pub enum Numeric {
     /// Full Gregorian year (FW=4, PW=∞).
     /// May accept years before 1 BCE or after 9999 CE, given an initial sign (+/-).
@@ -170,12 +172,20 @@ impl fmt::Debug for InternalNumeric {
     }
 }
 
+#[cfg(feature = "defmt")]
+impl defmt::Format for InternalNumeric {
+    fn format(&self, f: defmt::Formatter) {
+        defmt::write!(f, "<InternalNumeric>")
+    }
+}
+
 /// Fixed-format item types.
 ///
 /// They have their own rules of formatting and parsing.
 /// Otherwise noted, they print in the specified cases but parse case-insensitively.
 #[non_exhaustive]
 #[derive(Clone, PartialEq, Eq, Debug, Hash)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
 pub enum Fixed {
     /// Abbreviated month names.
     ///
@@ -260,11 +270,13 @@ pub enum Fixed {
 
 /// An opaque type representing fixed-format item types for internal uses only.
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
 pub struct InternalFixed {
     val: InternalInternal,
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
 enum InternalInternal {
     /// Same as [`TimezoneOffsetColonZ`](#variant.TimezoneOffsetColonZ), but
     /// allows missing minutes (per [ISO 8601][iso8601]).
@@ -285,6 +297,7 @@ enum InternalInternal {
 
 /// Type for specifying the format of UTC offsets.
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
 pub struct OffsetFormat {
     /// See `OffsetPrecision`.
     pub precision: OffsetPrecision,
@@ -298,6 +311,7 @@ pub struct OffsetFormat {
 
 /// The precision of an offset from UTC formatting item.
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
 pub enum OffsetPrecision {
     /// Format offset from UTC as only hours. Not recommended, it is not uncommon for timezones to
     /// have an offset of 30 minutes, 15 minutes, etc.
@@ -319,6 +333,7 @@ pub enum OffsetPrecision {
 
 /// The separator between hours and minutes in an offset.
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
 pub enum Colons {
     /// No separator
     None,
@@ -350,6 +365,23 @@ pub enum Item<'a> {
     Error,
 }
 
+#[cfg(feature = "defmt")]
+impl<'a> defmt::Format for Item<'a> {
+    fn format(&self, f: defmt::Formatter) {
+        match self {
+            Item::Literal(v) => defmt::write!(f, "Literal {{ {} }}", v),
+            #[cfg(feature = "alloc")]
+            Item::OwnedLiteral(_) => {}
+            Item::Space(v) => defmt::write!(f, "Space {{ {}  }}", v),
+            #[cfg(feature = "alloc")]
+            Item::OwnedSpace(_) => {}
+            Item::Numeric(u, v) => defmt::write!(f, "Numeric {{ {}, {} }}", u, v),
+            Item::Fixed(v) => defmt::write!(f, "Fixed {{ {}  }}", v),
+            Item::Error => defmt::write!(f, "Error"),
+        }
+    }
+}
+
 const fn num(numeric: Numeric) -> Item<'static> {
     Item::Numeric(numeric, Pad::None)
 }
@@ -388,6 +420,7 @@ impl Item<'_> {
 
 /// An error from the `parse` function.
 #[derive(Debug, Clone, PartialEq, Eq, Copy, Hash)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
 pub struct ParseError(ParseErrorKind);
 
 impl ParseError {
@@ -400,6 +433,7 @@ impl ParseError {
 /// The category of parse error
 #[allow(clippy::manual_non_exhaustive)]
 #[derive(Debug, Clone, PartialEq, Eq, Copy, Hash)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
 pub enum ParseErrorKind {
     /// Given field is out of permitted range.
     OutOfRange,
diff --git a/src/format/parsed.rs b/src/format/parsed.rs
@@ -126,6 +126,7 @@ use crate::{DateTime, Datelike, TimeDelta, Timelike, Weekday};
 /// ```
 #[allow(clippy::manual_non_exhaustive)]
 #[derive(Clone, PartialEq, Eq, Debug, Default, Hash)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
 pub struct Parsed {
     #[doc(hidden)]
     pub year: Option<i32>,
diff --git a/src/format/strftime.rs b/src/format/strftime.rs
@@ -189,6 +189,7 @@ use alloc::vec::Vec;
 /// [`DateTime`]: crate::DateTime
 /// [`format::parse()`]: crate::format::parse()
 #[derive(Clone, Debug)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
 pub struct StrftimeItems<'a> {
     /// Remaining portion of the string.
     remainder: &'a str,
diff --git a/src/lib.rs b/src/lib.rs
@@ -687,6 +687,13 @@ impl fmt::Debug for OutOfRange {
     }
 }
 
+#[cfg(feature = "defmt")]
+impl defmt::Format for OutOfRange {
+    fn format(&self, fmt: defmt::Formatter) {
+        defmt::write!(fmt, "out of range");
+    }
+}
+
 #[cfg(feature = "std")]
 impl std::error::Error for OutOfRange {}
 
diff --git a/src/month.rs b/src/month.rs
@@ -38,6 +38,7 @@ use crate::naive::NaiveDate;
 )]
 #[cfg_attr(feature = "rkyv-validation", archive(check_bytes))]
 #[cfg_attr(all(feature = "arbitrary", feature = "std"), derive(arbitrary::Arbitrary))]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
 pub enum Month {
     /// January
     January = 0,
@@ -248,6 +249,7 @@ impl num_traits::FromPrimitive for Month {
 /// A duration in calendar months
 #[derive(Clone, Copy, Debug, Eq, Hash, PartialEq, PartialOrd, Ord)]
 #[cfg_attr(all(feature = "arbitrary", feature = "std"), derive(arbitrary::Arbitrary))]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
 pub struct Months(pub(crate) u32);
 
 impl Months {
@@ -287,6 +289,13 @@ impl fmt::Debug for ParseMonthError {
     }
 }
 
+#[cfg(feature = "defmt")]
+impl defmt::Format for ParseMonthError {
+    fn format(&self, fmt: defmt::Formatter) {
+        defmt::write!(fmt, "ParseMonthError {{ .. }}")
+    }
+}
+
 #[cfg(feature = "serde")]
 mod month_serde {
     use super::Month;
diff --git a/src/naive/date/mod.rs b/src/naive/date/mod.rs
@@ -2302,6 +2302,23 @@ impl fmt::Debug for NaiveDate {
     }
 }
 
+#[cfg(feature = "defmt")]
+impl defmt::Format for NaiveDate {
+    fn format(&self, fmt: defmt::Formatter) {
+        let year = self.year();
+        let mdf = self.mdf();
+        if (0..=9999).contains(&year) {
+            defmt::write!(fmt, "{:02}{:02}", year / 100, year % 100);
+        } else {
+            // ISO 8601 requires the explicit sign for out-of-range years
+            let sign = ['+', '-'][(year < 0) as usize];
+            defmt::write!(fmt, "{}{:05}", sign, year.abs());
+        }
+
+        defmt::write!(fmt, "-{:02}-{:02}", mdf.month(), mdf.day());
+    }
+}
+
 /// The `Display` output of the naive date `d` is the same as
 /// [`d.format("%Y-%m-%d")`](crate::format::strftime).
 ///
diff --git a/src/naive/datetime/mod.rs b/src/naive/datetime/mod.rs
@@ -2057,6 +2057,13 @@ impl fmt::Debug for NaiveDateTime {
     }
 }
 
+#[cfg(feature = "defmt")]
+impl defmt::Format for NaiveDateTime {
+    fn format(&self, fmt: defmt::Formatter) {
+        defmt::write!(fmt, "{}T{}", self.date, self.time);
+    }
+}
+
 /// The `Display` output of the naive date and time `dt` is the same as
 /// [`dt.format("%Y-%m-%d %H:%M:%S%.f")`](crate::format::strftime).
 ///
diff --git a/src/naive/isoweek.rs b/src/naive/isoweek.rs
@@ -160,6 +160,21 @@ impl fmt::Debug for IsoWeek {
     }
 }
 
+#[cfg(feature = "defmt")]
+impl defmt::Format for IsoWeek {
+    fn format(&self, fmt: defmt::Formatter) {
+        let year = self.year();
+        let week = self.week();
+        if (0..=9999).contains(&year) {
+            defmt::write!(fmt, "{:04}-W{:02}", year, week)
+        } else {
+            // ISO 8601 requires the explicit sign for out-of-range years
+            let sign = ['+', '-'][(year < 0) as usize];
+            defmt::write!(fmt, "{}{:05}-W{:02}", sign, year.abs(), week)
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     #[cfg(feature = "rkyv-validation")]
diff --git a/src/naive/mod.rs b/src/naive/mod.rs
@@ -31,6 +31,7 @@ pub use self::internals::YearFlags as __BenchYearFlags;
 /// A week represented by a [`NaiveDate`] and a [`Weekday`] which is the first
 /// day of the week.
 #[derive(Clone, Copy, Debug, Eq)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
 pub struct NaiveWeek {
     date: NaiveDate,
     start: Weekday,
@@ -226,6 +227,7 @@ impl Hash for NaiveWeek {
 /// difference applies only when dealing with `DateTime<TimeZone>` data types and in other cases
 /// `TimeDelta::days(n)` and `Days::new(n)` are equivalent.
 #[derive(Clone, Copy, Debug, Eq, Hash, PartialEq, PartialOrd, Ord)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
 pub struct Days(pub(crate) u64);
 
 impl Days {
diff --git a/src/naive/time/mod.rs b/src/naive/time/mod.rs
@@ -1529,6 +1529,31 @@ impl fmt::Debug for NaiveTime {
     }
 }
 
+#[cfg(feature = "defmt")]
+impl defmt::Format for NaiveTime {
+    fn format(&self, fmt: defmt::Formatter) {
+        let (hour, min, sec) = self.hms();
+        let (sec, nano) = if self.frac >= 1_000_000_000 {
+            (sec + 1, self.frac - 1_000_000_000)
+        } else {
+            (sec, self.frac)
+        };
+
+        let (hour, min, sec) = (hour as u8, min as u8, sec as u8);
+        defmt::write!(fmt, "{:02}:{:02}:{:02}", hour, min, sec);
+
+        if nano == 0 {
+            return;
+        } else if nano % 1_000_000 == 0 {
+            defmt::write!(fmt, ".{:03}", nano / 1_000_000);
+        } else if nano % 1_000 == 0 {
+            defmt::write!(fmt, ".{:06}", nano / 1_000);
+        } else {
+            defmt::write!(fmt, ".{:09}", nano);
+        }
+    }
+}
+
 /// The `Display` output of the naive time `t` is the same as
 /// [`t.format("%H:%M:%S%.f")`](crate::format::strftime).
 ///
diff --git a/src/offset/fixed.rs b/src/offset/fixed.rs
@@ -174,6 +174,23 @@ impl fmt::Display for FixedOffset {
     }
 }
 
+#[cfg(feature = "defmt")]
+impl defmt::Format for FixedOffset {
+    fn format(&self, f: defmt::Formatter) {
+        let offset = self.local_minus_utc;
+        let (sign, offset) = if offset < 0 { ('-', -offset) } else { ('+', offset) };
+        let sec = offset.rem_euclid(60);
+        let mins = offset.div_euclid(60);
+        let min = mins.rem_euclid(60);
+        let hour = mins.div_euclid(60);
+        if sec == 0 {
+            defmt::write!(f, "{}{:02}:{:02}", sign, hour, min)
+        } else {
+            defmt::write!(f, "{}{:02}:{:02}:{:02}", sign, hour, min, sec)
+        }
+    }
+}
+
 #[cfg(all(feature = "arbitrary", feature = "std"))]
 impl arbitrary::Arbitrary<'_> for FixedOffset {
     fn arbitrary(u: &mut arbitrary::Unstructured) -> arbitrary::Result<FixedOffset> {
diff --git a/src/offset/local/mod.rs b/src/offset/local/mod.rs
@@ -122,6 +122,7 @@ mod tz_info;
 )]
 #[cfg_attr(feature = "rkyv-validation", archive(check_bytes))]
 #[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
 pub struct Local;
 
 impl Local {
diff --git a/src/offset/mod.rs b/src/offset/mod.rs
@@ -76,7 +76,7 @@ pub use self::utc::Utc;
 /// The type of `T` is usually a [`DateTime`] but may also be only an offset.
 pub type MappedLocalTime<T> = LocalResult<T>;
 #[derive(Clone, PartialEq, Debug, Copy, Eq, Hash)]
-
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
 /// Old name of [`MappedLocalTime`]. See that type for more documentation.
 pub enum LocalResult<T> {
     /// The local time maps to a single unique result.
diff --git a/src/offset/utc.rs b/src/offset/utc.rs
@@ -150,3 +150,10 @@ impl fmt::Display for Utc {
         write!(f, "UTC")
     }
 }
+
+#[cfg(feature = "defmt")]
+impl defmt::Format for Utc {
+    fn format(&self, fmt: defmt::Formatter) {
+        defmt::write!(fmt, "Z");
+    }
+}
diff --git a/src/round.rs b/src/round.rs
diff --git a/src/time_delta.rs b/src/time_delta.rs
diff --git a/src/weekday.rs b/src/weekday.rs
diff --git a/src/weekday_set.rs b/src/weekday_set.rs

Original file line number	Diff line number	Diff line change
`@@ -687,6 +687,13 @@ impl fmt::Debug for OutOfRange {`
`687`	`687`	`}`
`688`	`688`	`}`
`689`	`689`
	`690`	`+#[cfg(feature = "defmt")]`
	`691`	`+impl defmt::Format for OutOfRange {`
	`692`	`+ fn format(&self, fmt: defmt::Formatter) {`
	`693`	`+ defmt::write!(fmt, "out of range");`
	`694`	`+ }`
	`695`	`+}`
	`696`	`+`
`690`	`697`	`#[cfg(feature = "std")]`
`691`	`698`	`impl std::error::Error for OutOfRange {}`
`692`	`699`