use chrono::{DateTime, Datelike, Offset, Timelike, Weekday};
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
pub enum Token {
DayPadded, DayAbbr, Day, DayName, DayIso, DaySuffix, DayWeekSun0, DayOfYear, WeekIso, MonthName, MonthPadded, MonthAbbr, Month, DaysInMonth, LeapYear, YearIso, Year, YearShort, AmPmLower, AmPmUpper, Swatch, Hour12, Hour24, Hour12Padded, Hour24Padded, Minute, Second, Microseconds, Milliseconds, TzId, Dst, OffsetShort, OffsetColon, OffsetColonZ, TzAbbr, OffsetSeconds, Iso8601, Rfc2822, UnixTime, }
impl Token {
pub fn from_char(c: char) -> Option<Self> {
Some(match c {
'd' => Self::DayPadded,
'D' => Self::DayAbbr,
'j' => Self::Day,
'l' => Self::DayName,
'N' => Self::DayIso,
'S' => Self::DaySuffix,
'w' => Self::DayWeekSun0,
'z' => Self::DayOfYear,
'W' => Self::WeekIso,
'F' => Self::MonthName,
'm' => Self::MonthPadded,
'M' => Self::MonthAbbr,
'n' => Self::Month,
't' => Self::DaysInMonth,
'L' => Self::LeapYear,
'o' => Self::YearIso,
'Y' => Self::Year,
'y' => Self::YearShort,
'a' => Self::AmPmLower,
'A' => Self::AmPmUpper,
'B' => Self::Swatch,
'g' => Self::Hour12,
'G' => Self::Hour24,
'h' => Self::Hour12Padded,
'H' => Self::Hour24Padded,
'i' => Self::Minute,
's' => Self::Second,
'u' => Self::Microseconds,
'v' => Self::Milliseconds,
'e' => Self::TzId,
'I' => Self::Dst,
'O' => Self::OffsetShort,
'P' => Self::OffsetColon,
'p' => Self::OffsetColonZ,
'T' => Self::TzAbbr,
'Z' => Self::OffsetSeconds,
'c' => Self::Iso8601,
'r' => Self::Rfc2822,
'U' => Self::UnixTime,
_ => return None,
})
}
}
const WEEKDAYS_ABBR: [&str; 7] = ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"];
const WEEKDAYS_FULL: [&str; 7] = [
"Monday",
"Tuesday",
"Wednesday",
"Thursday",
"Friday",
"Saturday",
"Sunday",
];
const MONTHS_FULL: [&str; 12] = [
"January",
"February",
"March",
"April",
"May",
"June",
"July",
"August",
"September",
"October",
"November",
"December",
];
const MONTHS_ABBR: [&str; 12] = [
"Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec",
];
fn weekday_index(wd: Weekday) -> usize {
match wd {
Weekday::Mon => 0,
Weekday::Tue => 1,
Weekday::Wed => 2,
Weekday::Thu => 3,
Weekday::Fri => 4,
Weekday::Sat => 5,
Weekday::Sun => 6,
}
}
fn ordinal_suffix(day: u32) -> &'static str {
match day % 100 {
11..=13 => "th",
_ => match day % 10 {
1 => "st",
2 => "nd",
3 => "rd",
_ => "th",
},
}
}
fn hour12(hour: u32) -> u32 {
match hour % 12 {
0 => 12,
h => h,
}
}
fn format_offset_short(secs: i32) -> String {
let sign = if secs >= 0 { '+' } else { '-' };
let abs = secs.unsigned_abs();
let hours = abs / 3600;
let mins = (abs % 3600) / 60;
format!("{sign}{hours:02}{mins:02}")
}
fn format_offset_colon(secs: i32) -> String {
let sign = if secs >= 0 { '+' } else { '-' };
let abs = secs.unsigned_abs();
let hours = abs / 3600;
let mins = (abs % 3600) / 60;
format!("{sign}{hours:02}:{mins:02}")
}
fn swatch_beats(dt: &DateTime<impl chrono::TimeZone>) -> u32 {
let utc = dt.with_timezone(&chrono::Utc);
let seconds = utc.num_seconds_from_midnight() as i64;
let beats = ((seconds + 3600) % 86400) as f64 / 86.4;
beats.floor() as u32
}
pub fn render_token<Tz: chrono::TimeZone>(dt: &DateTime<Tz>, token: Token, out: &mut String)
where
Tz::Offset: std::fmt::Display,
{
let offset_secs = dt.offset().fix().local_minus_utc();
match token {
Token::DayPadded => out.push_str(&format!("{:02}", dt.day())),
Token::DayAbbr => out.push_str(WEEKDAYS_ABBR[weekday_index(dt.weekday())]),
Token::Day => out.push_str(&dt.day().to_string()),
Token::DayName => out.push_str(WEEKDAYS_FULL[weekday_index(dt.weekday())]),
Token::DayIso => {
let n = match dt.weekday() {
Weekday::Mon => 1,
Weekday::Tue => 2,
Weekday::Wed => 3,
Weekday::Thu => 4,
Weekday::Fri => 5,
Weekday::Sat => 6,
Weekday::Sun => 7,
};
out.push_str(&n.to_string());
}
Token::DaySuffix => out.push_str(ordinal_suffix(dt.day())),
Token::DayWeekSun0 => {
let w = match dt.weekday() {
Weekday::Sun => 0,
Weekday::Mon => 1,
Weekday::Tue => 2,
Weekday::Wed => 3,
Weekday::Thu => 4,
Weekday::Fri => 5,
Weekday::Sat => 6,
};
out.push_str(&w.to_string());
}
Token::DayOfYear => out.push_str(&(dt.ordinal() - 1).to_string()),
Token::WeekIso => out.push_str(&format!("{:02}", dt.iso_week().week())),
Token::MonthName => out.push_str(MONTHS_FULL[(dt.month() - 1) as usize]),
Token::MonthPadded => out.push_str(&format!("{:02}", dt.month())),
Token::MonthAbbr => out.push_str(MONTHS_ABBR[(dt.month() - 1) as usize]),
Token::Month => out.push_str(&dt.month().to_string()),
Token::DaysInMonth => {
let days = match dt.month() {
1 | 3 | 5 | 7 | 8 | 10 | 12 => 31,
4 | 6 | 9 | 11 => 30,
2 => {
if dt.date_naive().leap_year() {
29
} else {
28
}
}
_ => unreachable!(),
};
out.push_str(&days.to_string());
}
Token::LeapYear => out.push(if dt.date_naive().leap_year() {
'1'
} else {
'0'
}),
Token::YearIso => out.push_str(&dt.iso_week().year().to_string()),
Token::Year => out.push_str(&format!("{:04}", dt.year())),
Token::YearShort => out.push_str(&format!("{:02}", dt.year().rem_euclid(100))),
Token::AmPmLower => out.push_str(if dt.hour() < 12 { "am" } else { "pm" }),
Token::AmPmUpper => out.push_str(if dt.hour() < 12 { "AM" } else { "PM" }),
Token::Swatch => out.push_str(&format!("{:03}", swatch_beats(dt))),
Token::Hour12 => out.push_str(&hour12(dt.hour()).to_string()),
Token::Hour24 => out.push_str(&dt.hour().to_string()),
Token::Hour12Padded => out.push_str(&format!("{:02}", hour12(dt.hour()))),
Token::Hour24Padded => out.push_str(&format!("{:02}", dt.hour())),
Token::Minute => out.push_str(&format!("{:02}", dt.minute())),
Token::Second => out.push_str(&format!("{:02}", dt.second())),
Token::Microseconds => {
out.push_str(&format!("{:06}", dt.timestamp_subsec_micros()));
}
Token::Milliseconds => {
out.push_str(&format!("{:03}", dt.timestamp_subsec_millis()));
}
Token::TzId => {
if offset_secs == 0 {
out.push_str("UTC");
} else {
out.push_str(&format_offset_colon(offset_secs));
}
}
Token::Dst => {
out.push('0');
}
Token::OffsetShort => out.push_str(&format_offset_short(offset_secs)),
Token::OffsetColon => out.push_str(&format_offset_colon(offset_secs)),
Token::OffsetColonZ => {
if offset_secs == 0 {
out.push('Z');
} else {
out.push_str(&format_offset_colon(offset_secs));
}
}
Token::TzAbbr => {
if offset_secs == 0 {
out.push_str("UTC");
} else {
out.push_str(&format_offset_short(offset_secs));
}
}
Token::OffsetSeconds => out.push_str(&offset_secs.to_string()),
Token::Iso8601 => {
out.push_str(&format!(
"{:04}-{:02}-{:02}T{:02}:{:02}:{:02}{}",
dt.year(),
dt.month(),
dt.day(),
dt.hour(),
dt.minute(),
dt.second(),
format_offset_colon(offset_secs)
));
}
Token::Rfc2822 => {
out.push_str(&format!(
"{}, {:02} {} {:04} {:02}:{:02}:{:02} {}",
WEEKDAYS_ABBR[weekday_index(dt.weekday())],
dt.day(),
MONTHS_ABBR[(dt.month() - 1) as usize],
dt.year(),
dt.hour(),
dt.minute(),
dt.second(),
format_offset_short(offset_secs)
));
}
Token::UnixTime => out.push_str(&dt.timestamp().to_string()),
}
}
#[cfg(test)]
mod tests {
use super::*;
use chrono::{DateTime, FixedOffset, TimeZone, Utc};
fn utc(ts: i64) -> DateTime<Utc> {
DateTime::from_timestamp(ts, 0).unwrap()
}
#[test]
fn mysql_datetime() {
let dt = utc(978307200); let mut s = String::new();
for c in "Y-m-d H:i:s".chars() {
if let Some(t) = Token::from_char(c) {
render_token(&dt, t, &mut s);
} else {
s.push(c);
}
}
assert_eq!(s, "2001-01-01 00:00:00");
}
#[test]
fn ordinal_and_names() {
let dt = Utc.with_ymd_and_hms(2001, 3, 10, 17, 16, 18).unwrap();
assert_eq!(ordinal_suffix(10), "th");
assert_eq!(ordinal_suffix(1), "st");
assert_eq!(ordinal_suffix(22), "nd");
assert_eq!(WEEKDAYS_ABBR[weekday_index(dt.weekday())], "Sat");
assert_eq!(MONTHS_FULL[(dt.month() - 1) as usize], "March");
}
#[test]
fn offset_formats() {
let east = FixedOffset::east_opt(2 * 3600).unwrap();
let dt = east.with_ymd_and_hms(2000, 12, 21, 16, 1, 7).unwrap();
let mut s = String::new();
render_token(&dt, Token::Rfc2822, &mut s);
assert_eq!(s, "Thu, 21 Dec 2000 16:01:07 +0200");
}
#[test]
fn from_char_maps_all_supported_tokens() {
let chars = "dDjlNSwzWFmMntLoYyaABgGhHisuveIOPpTZcrU";
for c in chars.chars() {
assert!(
Token::from_char(c).is_some(),
"expected token mapping for {c:?}"
);
}
assert!(Token::from_char('q').is_none());
assert!(Token::from_char('!').is_none());
assert!(Token::from_char(' ').is_none());
}
#[test]
fn from_char_roundtrip_distinct() {
let chars = "dDjlNSwzWFmMntLoYyaABgGhHisuveIOPpTZcrU";
let mut seen = std::collections::BTreeSet::new();
for c in chars.chars() {
let tok = Token::from_char(c).unwrap();
assert!(seen.insert(tok), "duplicate token for {c:?}");
}
assert_eq!(seen.len(), chars.chars().count());
}
#[test]
fn subseconds_u_and_v() {
let dt = DateTime::from_timestamp(978_307_200, 123_456_789).unwrap();
let mut u = String::new();
let mut v = String::new();
render_token(&dt, Token::Microseconds, &mut u);
render_token(&dt, Token::Milliseconds, &mut v);
assert_eq!(u, "123456");
assert_eq!(v, "123");
}
#[test]
fn west_offset_tokens() {
let west = FixedOffset::west_opt(5 * 3600 + 30 * 60).unwrap(); let dt = west.with_ymd_and_hms(2001, 3, 10, 12, 0, 0).unwrap();
let mut o = String::new();
let mut p = String::new();
let mut colon = String::new();
let mut z = String::new();
let mut e = String::new();
render_token(&dt, Token::OffsetShort, &mut o);
render_token(&dt, Token::OffsetColon, &mut colon);
render_token(&dt, Token::OffsetColonZ, &mut p);
render_token(&dt, Token::OffsetSeconds, &mut z);
render_token(&dt, Token::TzId, &mut e);
assert_eq!(o, "-0530");
assert_eq!(colon, "-05:30");
assert_eq!(p, "-05:30");
assert_eq!(z, (-(5 * 3600 + 30 * 60)).to_string());
assert_eq!(e, "-05:30");
}
#[test]
fn dst_flag_always_zero_without_tzdb() {
let dt = Utc.with_ymd_and_hms(2001, 7, 1, 12, 0, 0).unwrap();
let mut s = String::new();
render_token(&dt, Token::Dst, &mut s);
assert_eq!(s, "0");
}
#[test]
fn iso8601_with_positive_offset() {
let east = FixedOffset::east_opt(3600).unwrap();
let dt = east.with_ymd_and_hms(2004, 2, 12, 15, 19, 21).unwrap();
let mut s = String::new();
render_token(&dt, Token::Iso8601, &mut s);
assert_eq!(s, "2004-02-12T15:19:21+01:00");
}
}