use chrono::{Datelike, NaiveDate, NaiveTime, Timelike};
use crate::{Error, Result, Value};
use super::clock::ClockKind;
use super::zone::{add_offset, zone_kind, ZoneSpec};
use super::{
format_zone_offset, lookup, Temporal, NANOS_PER_MICRO, NANOS_PER_MILLI, NANOS_PER_SECOND,
SECONDS_PER_HOUR, SECONDS_PER_MINUTE,
};
#[derive(Clone, Copy, PartialEq, Eq)]
enum Component {
Year,
Month,
Day,
OrdinalDay,
Quarter,
Week,
WeekYear,
DayOfWeek,
DayOfQuarter,
Hour,
Minute,
Second,
Millisecond,
Microsecond,
Nanosecond,
Timezone,
Offset,
OffsetSeconds,
OffsetMinutes,
EpochSeconds,
EpochMillis,
}
impl Component {
const TABLE: &'static [(&'static str, Component)] = &[
("year", Component::Year),
("month", Component::Month),
("day", Component::Day),
("ordinalday", Component::OrdinalDay),
("quarter", Component::Quarter),
("week", Component::Week),
("weekyear", Component::WeekYear),
("dayofweek", Component::DayOfWeek),
("weekday", Component::DayOfWeek),
("dayofquarter", Component::DayOfQuarter),
("hour", Component::Hour),
("minute", Component::Minute),
("second", Component::Second),
("millisecond", Component::Millisecond),
("microsecond", Component::Microsecond),
("nanosecond", Component::Nanosecond),
("timezone", Component::Timezone),
("offset", Component::Offset),
("offsetseconds", Component::OffsetSeconds),
("offsetminutes", Component::OffsetMinutes),
("epochseconds", Component::EpochSeconds),
("epochmillis", Component::EpochMillis),
];
fn from_name(name: &str) -> Option<Self> {
lookup(Self::TABLE, name)
}
}
#[derive(Clone, Copy)]
enum DurationComponent {
Years,
Quarters,
Months,
Weeks,
Days,
Hours,
Minutes,
Seconds,
Millis,
Micros,
Nanos,
MonthsOfYear,
QuartersOfYear,
MonthsOfQuarter,
DaysOfWeek,
MinutesOfHour,
SecondsOfMinute,
MillisOfSecond,
MicrosOfSecond,
NanosOfSecond,
}
impl DurationComponent {
const TABLE: &'static [(&'static str, DurationComponent)] = &[
("years", DurationComponent::Years),
("quarters", DurationComponent::Quarters),
("months", DurationComponent::Months),
("weeks", DurationComponent::Weeks),
("days", DurationComponent::Days),
("hours", DurationComponent::Hours),
("minutes", DurationComponent::Minutes),
("seconds", DurationComponent::Seconds),
("milliseconds", DurationComponent::Millis),
("microseconds", DurationComponent::Micros),
("nanoseconds", DurationComponent::Nanos),
("monthsofyear", DurationComponent::MonthsOfYear),
("quartersofyear", DurationComponent::QuartersOfYear),
("monthsofquarter", DurationComponent::MonthsOfQuarter),
("daysofweek", DurationComponent::DaysOfWeek),
("minutesofhour", DurationComponent::MinutesOfHour),
("secondsofminute", DurationComponent::SecondsOfMinute),
("millisecondsofsecond", DurationComponent::MillisOfSecond),
("microsecondsofsecond", DurationComponent::MicrosOfSecond),
("nanosecondsofsecond", DurationComponent::NanosOfSecond),
];
fn from_name(name: &str) -> Option<Self> {
lookup(Self::TABLE, name)
}
}
fn clock_kind(t: &Temporal) -> Option<ClockKind> {
match t {
Temporal::Date(_) => Some(ClockKind::Date),
Temporal::LocalTime(_) => Some(ClockKind::LocalTime),
Temporal::Time { .. } => Some(ClockKind::Time),
Temporal::LocalDateTime(_) => Some(ClockKind::LocalDateTime),
Temporal::DateTime { .. } => Some(ClockKind::DateTime),
Temporal::CivilDate { .. } | Temporal::CivilDateTime { .. } | Temporal::Duration { .. } => {
None
}
}
}
pub(super) fn read(t: &Temporal, key: &str) -> Result<Value> {
let name = key.to_ascii_lowercase();
if let Temporal::Duration {
months,
days,
nanos,
} = t
{
let component =
DurationComponent::from_name(&name).ok_or_else(|| no_component("duration", key))?;
return duration_component(*months, *days, *nanos, component);
}
let kind = clock_kind(t).ok_or_else(|| no_component("civil temporal", key))?;
let component = Component::from_name(&name).ok_or_else(|| no_component(kind.name(), key))?;
component_value(t, component)?.ok_or_else(|| no_component(kind.name(), key))
}
fn no_component(kind: &str, key: &str) -> Error {
Error::ty(format!("no such component '{key}' on a {kind} value"))
}
fn date_part(t: &Temporal) -> Result<Option<NaiveDate>> {
Ok(match t {
Temporal::Date(d) => Some(*d),
Temporal::LocalDateTime(dt) => Some(dt.date()),
Temporal::DateTime { utc, offset, .. } => Some(add_offset(*utc, *offset)?.date()),
_ => None,
})
}
fn time_part(t: &Temporal) -> Result<Option<NaiveTime>> {
Ok(match t {
Temporal::LocalTime(tm) | Temporal::Time { time: tm, .. } => Some(*tm),
Temporal::LocalDateTime(dt) => Some(dt.time()),
Temporal::DateTime { utc, offset, .. } => Some(add_offset(*utc, *offset)?.time()),
_ => None,
})
}
fn offset_part(t: &Temporal) -> Option<i32> {
match t {
Temporal::Time { offset, .. } | Temporal::DateTime { offset, .. } => Some(*offset),
_ => None,
}
}
fn timezone_part(t: &Temporal) -> Option<String> {
let offset = offset_part(t)?;
if let Temporal::DateTime {
zone: Some(zone), ..
} = t
{
return Some(match zone_kind(zone) {
ZoneSpec::Iana(name) => name.into(),
ZoneSpec::Fixed(_) => format_zone_offset(offset),
ZoneSpec::Prefixed(name) => name.into(),
ZoneSpec::Utc => "Z".into(),
ZoneSpec::Other(_) => format_zone_offset(offset),
});
}
Some(format_zone_offset(offset))
}
fn component_value(t: &Temporal, component: Component) -> Result<Option<Value>> {
let date_int = |f: fn(NaiveDate) -> i64| -> Result<Option<Value>> {
Ok(date_part(t)?.map(|d| Value::Int(f(d))))
};
let time_int = |f: fn(NaiveTime) -> i64| -> Result<Option<Value>> {
Ok(time_part(t)?.map(|tm| Value::Int(f(tm))))
};
match component {
Component::Year => date_int(|d| i64::from(d.year())),
Component::Month => date_int(|d| i64::from(d.month())),
Component::Day => date_int(|d| i64::from(d.day())),
Component::OrdinalDay => date_int(|d| i64::from(d.ordinal())),
Component::Quarter => date_int(|d| i64::from((d.month() - 1) / 3 + 1)),
Component::Week => date_int(|d| i64::from(d.iso_week().week())),
Component::WeekYear => date_int(|d| i64::from(d.iso_week().year())),
Component::DayOfWeek => date_int(|d| i64::from(d.weekday().number_from_monday())),
Component::DayOfQuarter => {
let Some(d) = date_part(t)? else {
return Ok(None);
};
let qstart = (d.month() - 1) / 3 * 3 + 1;
let Some(start) = NaiveDate::from_ymd_opt(d.year(), qstart, 1) else {
return Ok(None);
};
Ok(Some(Value::Int((d - start).num_days() + 1)))
}
Component::Hour => time_int(|tm| i64::from(tm.hour())),
Component::Minute => time_int(|tm| i64::from(tm.minute())),
Component::Second => time_int(|tm| i64::from(tm.second())),
Component::Millisecond => time_int(|tm| i64::from(tm.nanosecond() / 1_000_000)),
Component::Microsecond => time_int(|tm| i64::from(tm.nanosecond() / 1_000)),
Component::Nanosecond => time_int(|tm| i64::from(tm.nanosecond())),
Component::Timezone => Ok(timezone_part(t).map(|z| Value::String(z.into()))),
Component::Offset => {
Ok(offset_part(t).map(|o| Value::String(format_zone_offset(o).into())))
}
Component::OffsetSeconds => Ok(offset_part(t).map(|o| Value::Int(i64::from(o)))),
Component::OffsetMinutes => Ok(offset_part(t).map(|o| Value::Int(i64::from(o / 60)))),
Component::EpochSeconds => Ok(epoch_part(t).map(|(seconds, _)| Value::Int(seconds))),
Component::EpochMillis => Ok(epoch_part(t).map(|(_, millis)| Value::Int(millis))),
}
}
fn epoch_part(t: &Temporal) -> Option<(i64, i64)> {
let Temporal::DateTime { utc, .. } = t else {
return None;
};
let dt = utc.and_utc();
let millis = dt.timestamp() * 1000 + i64::from(dt.timestamp_subsec_millis());
Some((dt.timestamp(), millis))
}
fn duration_component(
months: i64,
days: i64,
nanos: i128,
component: DurationComponent,
) -> Result<Value> {
let total_seconds = nanos.div_euclid(NANOS_PER_SECOND);
let sub_nanos = nanos.rem_euclid(NANOS_PER_SECOND);
let total_minutes = total_seconds / SECONDS_PER_MINUTE;
let hours = total_seconds / SECONDS_PER_HOUR;
let total = |v: i128| i64::try_from(v).map_err(|_| super::range_err());
Ok(Value::Int(match component {
DurationComponent::Years => months / 12,
DurationComponent::Months => months,
DurationComponent::MonthsOfYear => months.rem_euclid(12),
DurationComponent::Quarters => months / 3,
DurationComponent::QuartersOfYear => months.rem_euclid(12) / 3,
DurationComponent::MonthsOfQuarter => months.rem_euclid(3),
DurationComponent::Weeks => days / 7,
DurationComponent::Days => days,
DurationComponent::DaysOfWeek => days.rem_euclid(7),
DurationComponent::Hours => total(hours)?,
DurationComponent::Minutes => total(total_minutes)?,
DurationComponent::MinutesOfHour => total(total_minutes % 60)?,
DurationComponent::Seconds => total(total_seconds)?,
DurationComponent::SecondsOfMinute => total(total_seconds % 60)?,
DurationComponent::Nanos => total(nanos)?,
DurationComponent::Millis => total(nanos.div_euclid(NANOS_PER_MILLI))?,
DurationComponent::Micros => total(nanos.div_euclid(NANOS_PER_MICRO))?,
DurationComponent::MillisOfSecond => total(sub_nanos / NANOS_PER_MILLI)?,
DurationComponent::MicrosOfSecond => total(sub_nanos / NANOS_PER_MICRO)?,
DurationComponent::NanosOfSecond => total(sub_nanos)?,
}))
}
#[cfg(test)]
mod tests {
use super::*;
use crate::temporal::{
construct_date, construct_datetime, construct_localdatetime, construct_localtime,
construct_time,
};
fn sample(kind: ClockKind) -> Temporal {
match kind {
ClockKind::Date => construct_date(None).unwrap(),
ClockKind::LocalTime => construct_localtime(None).unwrap(),
ClockKind::Time => construct_time(None).unwrap(),
ClockKind::LocalDateTime => construct_localdatetime(None).unwrap(),
ClockKind::DateTime => construct_datetime(None).unwrap(),
}
}
#[test]
fn accessors_read_exactly_the_parts_the_kind_carries() {
let date = sample(ClockKind::Date);
assert!(read(&date, "year").is_ok());
assert!(read(&date, "dayOfQuarter").is_ok());
assert!(read(&date, "epochSeconds").is_err());
assert!(read(&date, "hour").is_err());
assert!(read(&date, "offset").is_err());
let localtime = sample(ClockKind::LocalTime);
assert!(read(&localtime, "hour").is_ok());
assert!(read(&localtime, "timezone").is_err());
assert!(read(&localtime, "year").is_err());
let time = sample(ClockKind::Time);
assert!(read(&time, "hour").is_ok());
assert!(read(&time, "offsetMinutes").is_ok());
assert!(read(&time, "timezone").is_ok());
assert!(read(&time, "year").is_err());
assert!(read(&time, "epochMillis").is_err());
let localdatetime = sample(ClockKind::LocalDateTime);
assert!(read(&localdatetime, "year").is_ok());
assert!(read(&localdatetime, "hour").is_ok());
assert!(read(&localdatetime, "timezone").is_err());
assert!(read(&localdatetime, "epochSeconds").is_err());
let datetime = sample(ClockKind::DateTime);
assert!(read(&datetime, "year").is_ok());
assert!(read(&datetime, "timezone").is_ok());
assert!(read(&datetime, "epochMillis").is_ok());
let err = read(&date, "hour").unwrap_err();
assert!(err.to_string().contains("no such component"), "{err}");
}
#[test]
fn a_zero_offset_renders_z_through_both_accessors() {
let utc = crate::temporal::parse_iso("time", "12:00Z").unwrap();
assert_eq!(read(&utc, "timezone").unwrap(), Value::String("Z".into()));
assert_eq!(read(&utc, "offset").unwrap(), Value::String("Z".into()));
let plus_one = crate::temporal::parse_iso("time", "12:00+01:00").unwrap();
assert_eq!(
read(&plus_one, "timezone").unwrap(),
Value::String("+01:00".into())
);
assert_eq!(
read(&plus_one, "offset").unwrap(),
Value::String("+01:00".into())
);
}
#[test]
fn an_out_of_range_offset_is_a_typed_range_error() {
let t = Temporal::DateTime {
utc: NaiveDate::MAX.and_hms_opt(23, 59, 59).unwrap(),
offset: 3600,
zone: None,
};
let err = read(&t, "year").unwrap_err();
assert!(err.to_string().contains("out of range"), "{err}");
}
#[test]
fn duration_reads_only_its_own_spellings() {
let d =
crate::temporal::construct_duration(Some(&Value::String("P1Y2M3D".into()))).unwrap();
assert_eq!(read(&d, "years").unwrap(), Value::Int(1));
assert_eq!(read(&d, "months").unwrap(), Value::Int(14));
assert!(read(&d, "year").is_err());
assert!(read(&d, "weekOfMonth").is_err());
assert!(read(&d, "epochSeconds").is_err());
}
}