lennart-k / ical-rs / #68

Committed 12 Jan 2026 10:17AM UTC coverage: 80.485% (+2.7%) from 77.802%

Build # #68

Build Type

Committed by

Commit Message

fixes

Pull Request Pull Request #2: Major overhaul

Run Details

935 of 1181 new or added lines in 30 files covered. (79.17%)

21 existing lines in 9 files now uncovered.

1262 of 1568 relevant lines covered (80.48%)

2.85 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

77.97

/src/types/datetime.rs

use crate::types::{Timezone, Value};
use crate::{property::ContentLine, types::CalDateTimeError};
use chrono::{DateTime, Datelike, Duration, Local, NaiveDate, NaiveDateTime, Utc};
use chrono_tz::Tz;
use std::{collections::HashMap, ops::Add};

const LOCAL_DATE_TIME: &str = "%Y%m%dT%H%M%S";
const UTC_DATE_TIME: &str = "%Y%m%dT%H%M%SZ";

#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
// Form 1, example: 19980118T230000 -> Local
// Form 2, example: 19980119T070000Z -> UTC
// Form 3, example: TZID=America/New_York:19980119T020000 -> Olson
// https://en.wikipedia.org/wiki/Tz_database
pub struct CalDateTime(pub(crate) DateTime<Timezone>);

impl From<CalDateTime> for DateTime<rrule::Tz> {
    fn from(value: CalDateTime) -> Self {
        value.0.with_timezone(&value.timezone().into())
    }
}

impl From<DateTime<rrule::Tz>> for CalDateTime {
    fn from(value: DateTime<rrule::Tz>) -> Self {
        Self(value.with_timezone(&value.timezone().into()))
    }
}

impl From<DateTime<Timezone>> for CalDateTime {
    fn from(value: DateTime<Timezone>) -> Self {
        Self(value)
    }
}

impl From<DateTime<Local>> for CalDateTime {
    fn from(value: DateTime<Local>) -> Self {
        Self(value.with_timezone(&Timezone::Local))
    }
}

impl From<DateTime<Utc>> for CalDateTime {
    fn from(value: DateTime<Utc>) -> Self {
        Self(value.with_timezone(&Timezone::Olson(chrono_tz::UTC)))
    }
}

impl Add<Duration> for CalDateTime {
    type Output = Self;

    fn add(self, duration: Duration) -> Self::Output {
        Self(self.0 + duration)
    }
}

impl CalDateTime {
    pub fn parse_prop(
        prop: &ContentLine,
        timezones: Option<&HashMap<String, Option<chrono_tz::Tz>>>,
    ) -> Result<Self, CalDateTimeError> {
        let prop_value = prop
            .value
            .as_ref()
            .ok_or_else(|| CalDateTimeError::InvalidDatetimeFormat("empty property".into()))?;

        let timezone = if let Some(tzid) = prop.params.get_tzid() {
            if let Some(timezone) = timezones.and_then(|timezones| timezones.get(tzid)) {
                timezone.to_owned()
            } else {
                // TZID refers to timezone that does not exist
                return Err(CalDateTimeError::InvalidTZID(tzid.to_string()));
            }
        } else {
            // No explicit timezone specified.
            // This is valid and will be localtime or UTC depending on the value
            // We will stick to this default as documented in https://github.com/lennart-k/rustical/issues/102
            None
        };

        Self::parse(prop_value, timezone)
    }

    #[must_use]
    pub fn format(&self) -> String {
        match self.timezone() {
            Timezone::Olson(chrono_tz::UTC) => self.0.format(UTC_DATE_TIME).to_string(),
            _ => self.0.format(LOCAL_DATE_TIME).to_string(),
        }
    }

    pub fn parse(value: &str, timezone: Option<Tz>) -> Result<Self, CalDateTimeError> {
        if let Ok(datetime) = NaiveDateTime::parse_from_str(value, LOCAL_DATE_TIME) {
            if let Some(timezone) = timezone {
                return Ok(Self(
                    datetime
                        .and_local_timezone(timezone.into())
                        .earliest()
                        .ok_or(CalDateTimeError::LocalTimeGap)?,
                ));
            }
            return Ok(Self(
                datetime
                    .and_local_timezone(Timezone::Local)
                    .earliest()
                    .ok_or(CalDateTimeError::LocalTimeGap)?,
            ));
        }

        if let Ok(datetime) = NaiveDateTime::parse_from_str(value, UTC_DATE_TIME) {
            return Ok(datetime.and_utc().into());
        }

        Err(CalDateTimeError::InvalidDatetimeFormat(value.to_string()))
    }

    #[must_use]
    pub fn utc(&self) -> DateTime<Utc> {
        self.0.to_utc()
    }

    #[must_use]
    pub fn timezone(&self) -> Timezone {
        self.0.timezone()
    }

    #[must_use]
    pub fn date_floor(&self) -> NaiveDate {
        self.0.date_naive()
    }
    #[must_use]
    pub fn date_ceil(&self) -> NaiveDate {
        let date = self.0.date_naive();
        date.succ_opt().unwrap_or(date)
    }
}

impl From<CalDateTime> for DateTime<Utc> {
    fn from(value: CalDateTime) -> Self {
        value.utc()
    }
}

#[cfg(not(tarpaulin_include))]
impl Datelike for CalDateTime {
    fn year(&self) -> i32 {
        self.0.year()
    }
    fn month(&self) -> u32 {
        self.0.month()
    }

    fn month0(&self) -> u32 {
        self.0.month0()
    }
    fn day(&self) -> u32 {
        self.0.day()
    }
    fn day0(&self) -> u32 {
        self.0.day0()
    }
    fn ordinal(&self) -> u32 {
        self.0.ordinal()
    }
    fn ordinal0(&self) -> u32 {
        self.0.ordinal0()
    }
    fn weekday(&self) -> chrono::Weekday {
        self.0.weekday()
    }
    fn iso_week(&self) -> chrono::IsoWeek {
        self.0.iso_week()
    }
    fn with_year(&self, year: i32) -> Option<Self> {
        Some(Self(self.0.with_year(year)?))
    }
    fn with_month(&self, month: u32) -> Option<Self> {
        Some(Self(self.0.with_month(month)?))
    }
    fn with_month0(&self, month0: u32) -> Option<Self> {
        Some(Self(self.0.with_month0(month0)?))
    }
    fn with_day(&self, day: u32) -> Option<Self> {
        Some(Self(self.0.with_day(day)?))
    }
    fn with_day0(&self, day0: u32) -> Option<Self> {
        Some(Self(self.0.with_day0(day0)?))
    }
    fn with_ordinal(&self, ordinal: u32) -> Option<Self> {
        Some(Self(self.0.with_ordinal(ordinal)?))
    }
    fn with_ordinal0(&self, ordinal0: u32) -> Option<Self> {
        Some(Self(self.0.with_ordinal0(ordinal0)?))
    }
}

impl Value for CalDateTime {
    fn value_type(&self) -> Option<&'static str> {
        Some("DATE-TIME")
    }
    fn value(&self) -> String {
        self.format()
    }

    fn utc_or_local(self) -> Self {
        match self.timezone() {
            Timezone::Local => self.clone(),
            Timezone::Olson(_) => Self(self.0.with_timezone(&Timezone::utc())),
        }
    }
}

1	use crate::types::{Timezone, Value};
2	use crate::{property::ContentLine, types::CalDateTimeError};
3	use chrono::{DateTime, Datelike, Duration, Local, NaiveDate, NaiveDateTime, Utc};
4	use chrono_tz::Tz;
5	use std::{collections::HashMap, ops::Add};
6
7	const LOCAL_DATE_TIME: &str = "%Y%m%dT%H%M%S";
8	const UTC_DATE_TIME: &str = "%Y%m%dT%H%M%SZ";
9
10	#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
11	// Form 1, example: 19980118T230000 -> Local
12	// Form 2, example: 19980119T070000Z -> UTC
13	// Form 3, example: TZID=America/New_York:19980119T020000 -> Olson
14	// https://en.wikipedia.org/wiki/Tz_database
15	pub struct CalDateTime(pub(crate) DateTime<Timezone>);
16
17	impl From<CalDateTime> for DateTime<rrule::Tz> {
NEW 18	fn from(value: CalDateTime) -> Self {	×
NEW 19	value.0.with_timezone(&value.timezone().into())	×
20	}
21	}
22
23	impl From<DateTime<rrule::Tz>> for CalDateTime {
24	fn from(value: DateTime<rrule::Tz>) -> Self {	1✔
25	Self(value.with_timezone(&value.timezone().into()))	1✔
26	}
27	}
28
29	impl From<DateTime<Timezone>> for CalDateTime {
30	fn from(value: DateTime<Timezone>) -> Self {	1✔
31	Self(value)	1✔
32	}
33	}
34
35	impl From<DateTime<Local>> for CalDateTime {
NEW 36	fn from(value: DateTime<Local>) -> Self {	×
NEW 37	Self(value.with_timezone(&Timezone::Local))	×
38	}
39	}
40
41	impl From<DateTime<Utc>> for CalDateTime {
42	fn from(value: DateTime<Utc>) -> Self {	5✔
43	Self(value.with_timezone(&Timezone::Olson(chrono_tz::UTC)))	5✔
44	}
45	}
46
47	impl Add<Duration> for CalDateTime {
48	type Output = Self;
49
50	fn add(self, duration: Duration) -> Self::Output {	1✔
51	Self(self.0 + duration)	1✔
52	}
53	}
54
55	impl CalDateTime {
56	pub fn parse_prop(	3✔
57	prop: &ContentLine,
58	timezones: Option<&HashMap<String, Option<chrono_tz::Tz>>>,
59	) -> Result<Self, CalDateTimeError> {
60	let prop_value = prop	6✔
61	.value
62	.as_ref()
63	.ok_or_else(\|\| CalDateTimeError::InvalidDatetimeFormat("empty property".into()))?;	3✔
64
65	let timezone = if let Some(tzid) = prop.params.get_tzid() {	6✔
66	if let Some(timezone) = timezones.and_then(\|timezones\| timezones.get(tzid)) {	14✔
67	timezone.to_owned()	3✔
68	} else {
69	// TZID refers to timezone that does not exist
NEW 70	return Err(CalDateTimeError::InvalidTZID(tzid.to_string()));	×
71	}
72	} else {
73	// No explicit timezone specified.
74	// This is valid and will be localtime or UTC depending on the value
75	// We will stick to this default as documented in https://github.com/lennart-k/rustical/issues/102
76	None	3✔
77	};
78
79	Self::parse(prop_value, timezone)	5✔
80	}
81
82	#[must_use]
83	pub fn format(&self) -> String {	4✔
84	match self.timezone() {	4✔
85	Timezone::Olson(chrono_tz::UTC) => self.0.format(UTC_DATE_TIME).to_string(),	3✔
86	_ => self.0.format(LOCAL_DATE_TIME).to_string(),	1✔
87	}
88	}
89
90	pub fn parse(value: &str, timezone: Option<Tz>) -> Result<Self, CalDateTimeError> {	5✔
91	if let Ok(datetime) = NaiveDateTime::parse_from_str(value, LOCAL_DATE_TIME) {	8✔
92	if let Some(timezone) = timezone {	2✔
93	return Ok(Self(	2✔
94	datetime	1✔
95	.and_local_timezone(timezone.into())	1✔
96	.earliest()	1✔
97	.ok_or(CalDateTimeError::LocalTimeGap)?,	2✔
98	));
99	}
100	return Ok(Self(	1✔
101	datetime	1✔
102	.and_local_timezone(Timezone::Local)	1✔
103	.earliest()	1✔
104	.ok_or(CalDateTimeError::LocalTimeGap)?,	1✔
105	));
106	}
107
108	if let Ok(datetime) = NaiveDateTime::parse_from_str(value, UTC_DATE_TIME) {	10✔
109	return Ok(datetime.and_utc().into());	5✔
110	}
111
112	Err(CalDateTimeError::InvalidDatetimeFormat(value.to_string()))	1✔
113	}
114
115	#[must_use]
116	pub fn utc(&self) -> DateTime<Utc> {	1✔
117	self.0.to_utc()	2✔
118	}
119
120	#[must_use]
121	pub fn timezone(&self) -> Timezone {	4✔
122	self.0.timezone()	5✔
123	}
124
125	#[must_use]
NEW 126	pub fn date_floor(&self) -> NaiveDate {	×
NEW 127	self.0.date_naive()	×
128	}
129	#[must_use]
NEW 130	pub fn date_ceil(&self) -> NaiveDate {	×
NEW 131	let date = self.0.date_naive();	×
NEW 132	date.succ_opt().unwrap_or(date)	×
133	}
134	}
135
136	impl From<CalDateTime> for DateTime<Utc> {
NEW 137	fn from(value: CalDateTime) -> Self {	×
NEW 138	value.utc()	×
139	}
140	}
141
142	#[cfg(not(tarpaulin_include))]
143	impl Datelike for CalDateTime {
144	fn year(&self) -> i32 {
145	self.0.year()
146	}
147	fn month(&self) -> u32 {
148	self.0.month()
149	}
150
151	fn month0(&self) -> u32 {
152	self.0.month0()
153	}
154	fn day(&self) -> u32 {
155	self.0.day()
156	}
157	fn day0(&self) -> u32 {
158	self.0.day0()
159	}
160	fn ordinal(&self) -> u32 {
161	self.0.ordinal()
162	}
163	fn ordinal0(&self) -> u32 {
164	self.0.ordinal0()
165	}
166	fn weekday(&self) -> chrono::Weekday {
167	self.0.weekday()
168	}
169	fn iso_week(&self) -> chrono::IsoWeek {
170	self.0.iso_week()
171	}
172	fn with_year(&self, year: i32) -> Option<Self> {
173	Some(Self(self.0.with_year(year)?))
174	}
175	fn with_month(&self, month: u32) -> Option<Self> {
176	Some(Self(self.0.with_month(month)?))
177	}
178	fn with_month0(&self, month0: u32) -> Option<Self> {
179	Some(Self(self.0.with_month0(month0)?))
180	}
181	fn with_day(&self, day: u32) -> Option<Self> {
182	Some(Self(self.0.with_day(day)?))
183	}
184	fn with_day0(&self, day0: u32) -> Option<Self> {
185	Some(Self(self.0.with_day0(day0)?))
186	}
187	fn with_ordinal(&self, ordinal: u32) -> Option<Self> {
188	Some(Self(self.0.with_ordinal(ordinal)?))
189	}
190	fn with_ordinal0(&self, ordinal0: u32) -> Option<Self> {
191	Some(Self(self.0.with_ordinal0(ordinal0)?))
192	}
193	}
194
195	impl Value for CalDateTime {
196	fn value_type(&self) -> Option<&'static str> {	2✔
197	Some("DATE-TIME")
198	}
199	fn value(&self) -> String {	4✔
200	self.format()	4✔
201	}
202
203	fn utc_or_local(self) -> Self {	1✔
204	match self.timezone() {	1✔
NEW 205	Timezone::Local => self.clone(),	×
206	Timezone::Olson(_) => Self(self.0.with_timezone(&Timezone::utc())),	1✔
207	}
208	}
209	}

lennart-k / ical-rs / #68

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous