use chrono::{DateTime, FixedOffset, NaiveDate};
use serde::Deserialize;
use serde::de::{Deserializer, Error as _};
pub(crate) fn date<'de, D: Deserializer<'de>>(deserializer: D) -> Result<NaiveDate, D::Error> {
let value = String::deserialize(deserializer)?;
parse_date(&value).ok_or_else(|| D::Error::custom(format!("{value:?} is not a date")))
}
pub(crate) fn date_time<'de, D: Deserializer<'de>>(
deserializer: D,
) -> Result<DateTime<FixedOffset>, D::Error> {
let value = String::deserialize(deserializer)?;
parse_date_time(&value).ok_or_else(|| D::Error::custom(format!("{value:?} is not a date-time")))
}
pub(crate) fn option_date_time<'de, D: Deserializer<'de>>(
deserializer: D,
) -> Result<Option<DateTime<FixedOffset>>, D::Error> {
Option::<String>::deserialize(deserializer)?
.map(|value| {
parse_date_time(&value)
.ok_or_else(|| D::Error::custom(format!("{value:?} is not a date-time")))
})
.transpose()
}
fn parse_date(value: &str) -> Option<NaiveDate> {
let b = value.as_bytes();
if b.len() != 10 || !is_date_shape(b) {
return None;
}
NaiveDate::parse_from_str(value, "%Y-%m-%d").ok()
}
fn parse_date_time(value: &str) -> Option<DateTime<FixedOffset>> {
let b = value.as_bytes();
if b.len() < 20 || !is_date_shape(&b[..10]) || !matches!(b[10], b'T' | b't') {
return None;
}
let time = &b[11..19];
if !(digits(&time[0..2]) && time[2] == b':' && digits(&time[3..5]) && time[5] == b':')
|| !digits(&time[6..8])
|| &time[6..8] >= b"60".as_slice()
{
return None;
}
let mut rest = &b[19..];
if let Some(fraction) = rest.strip_prefix(b".") {
let n = fraction.iter().take_while(|c| c.is_ascii_digit()).count();
if n == 0 {
return None;
}
rest = &fraction[n..];
}
let zoned = rest == b"Z"
|| rest == b"z"
|| (rest.len() == 6
&& matches!(rest[0], b'+' | b'-')
&& digits(&rest[1..3])
&& rest[3] == b':'
&& digits(&rest[4..6]));
if !zoned {
return None;
}
DateTime::parse_from_rfc3339(value).ok()
}
fn is_date_shape(b: &[u8]) -> bool {
digits(&b[0..4]) && b[4] == b'-' && digits(&b[5..7]) && b[7] == b'-' && digits(&b[8..10])
}
fn digits(b: &[u8]) -> bool {
b.iter().all(u8::is_ascii_digit)
}
#[cfg(test)]
mod tests {
use super::{parse_date, parse_date_time};
#[test]
fn a_date_is_a_full_date_on_a_day_that_exists() {
assert_eq!(parse_date("2026-10-19").map(|d| d.to_string()), Some("2026-10-19".to_owned()));
assert_eq!(parse_date("2028-02-29").map(|d| d.to_string()), Some("2028-02-29".to_owned()));
for value in [
"",
"x",
"tomorrow",
"monday",
"2026-02-30",
"2026-11-31",
"2027-02-29",
"2026-13-01",
"2026-10-5",
"2026-1-05",
"+2026-10-20",
" 2026-10-20",
"2026-10-20 ",
"-0001-10-20",
"+12026-10-20",
"20261020",
"2026-W43-2",
"2026-293",
"2026-10-20T10:00:00Z",
"2026-10-20",
] {
assert_eq!(parse_date(value), None, "{value:?}");
}
}
#[test]
fn a_date_time_is_rfc_3339_with_a_zone_at_a_time_that_exists() {
for (value, read) in [
("2026-09-04T10:00:00.123Z", "2026-09-04T10:00:00.123+00:00"),
("2026-09-04T10:00:00Z", "2026-09-04T10:00:00+00:00"),
("2026-09-04T10:00:00+05:00", "2026-09-04T10:00:00+05:00"),
("2026-09-04T10:00:00.5-08:30", "2026-09-04T10:00:00.500-08:30"),
("2028-02-29T23:59:59Z", "2028-02-29T23:59:59+00:00"),
("2026-10-20t10:00:00Z", "2026-10-20T10:00:00+00:00"),
("2026-10-20T10:00:00z", "2026-10-20T10:00:00+00:00"),
("2026-10-20t10:00:00.5z", "2026-10-20T10:00:00.500+00:00"),
] {
assert_eq!(
parse_date_time(value).map(|d| d.to_rfc3339()),
Some(read.to_owned()),
"{value:?}"
);
}
for value in [
"",
"x",
"tomorrow",
"monday",
"10:00",
"2026-10-20",
"2026-10-20T10:00:00",
"2026-10-20T10:00Z",
"2026-02-30T00:00:00Z",
"2026-11-31T00:00:00Z",
"2026-10-20T24:00:00Z",
"2026-10-20T23:60:00Z",
"2026-10-20T23:59:60Z",
"2026-10-20 10:00:00Z",
"2026-10-20T10:00:00+0500",
"2026-10-20T10:00:00+05",
"2026-10-20T10:00:00.Z",
" 2026-10-20T10:00:00Z",
"2026-10-20T10:00:00Z ",
"+002026-10-20T10:00:00Z",
"2026-10-20T10:00:00+24:00",
"2026-10-20T10:00:00 +05:00",
"2026-10-20T10:00:00+05:00x",
"2026-10-20T10:00:00.1Z",
] {
assert_eq!(parse_date_time(value), None, "{value:?}");
}
}
}