1use std::ops::RangeInclusive;
2
3use crate::parser::error::CustomError;
4use crate::parser::prelude::*;
5use crate::parser::trivia::from_utf8_unchecked;
6
7use toml_datetime::{Date, Datetime, Offset, Time};
8use winnow::combinator::alt;
9use winnow::combinator::cut_err;
10use winnow::combinator::opt;
11use winnow::combinator::preceded;
12use winnow::combinator::trace;
13use winnow::stream::Stream as _;
14use winnow::token::one_of;
15use winnow::token::take_while;
16
17// ;; Date and Time (as defined in RFC 3339)
18
19// date-time = offset-date-time / local-date-time / local-date / local-time
20// offset-date-time = full-date time-delim full-time
21// local-date-time = full-date time-delim partial-time
22// local-date = full-date
23// local-time = partial-time
24// full-time = partial-time time-offset
25pub(crate) fn date_time(input: &mut Input<'_>) -> ModalResult<Datetime> {
26 trace(
27 "date-time",
28 alt((
29 (full_date, opt((time_delim, partial_time, opt(time_offset))))
30 .map(|(date, opt)| {
31 match opt {
32 // Offset Date-Time
33 Some((_, time, offset)) => Datetime {
34 date: Some(date),
35 time: Some(time),
36 offset,
37 },
38 // Local Date
39 None => Datetime {
40 date: Some(date),
41 time: None,
42 offset: None,
43 },
44 }
45 })
46 .context(StrContext::Label("date-time")),
47 partial_time
48 .map(|t| t.into())
49 .context(StrContext::Label("time")),
50 )),
51 )
52 .parse_next(input)
53}
54
55// full-date = date-fullyear "-" date-month "-" date-mday
56pub(crate) fn full_date(input: &mut Input<'_>) -> ModalResult<Date> {
57 trace(name:"full-date", parser:full_date_).parse_next(input)
58}
59
60fn full_date_(input: &mut Input<'_>) -> ModalResult<Date> {
61 let year: u16 = date_fullyear.parse_next(input)?;
62 let _ = b'-'.parse_next(input)?;
63 let month: u8 = cut_err(parser:date_month).parse_next(input)?;
64 let _ = cut_err(parser:b'-').parse_next(input)?;
65 let day_start: Checkpoint, …>, …> = input.checkpoint();
66 let day: u8 = cut_err(parser:date_mday).parse_next(input)?;
67
68 let is_leap_year: bool = (year % 4 == 0) && ((year % 100 != 0) || (year % 400 == 0));
69 let max_days_in_month: u8 = match month {
70 2 if is_leap_year => 29,
71 2 => 28,
72 4 | 6 | 9 | 11 => 30,
73 _ => 31,
74 };
75 if max_days_in_month < day {
76 input.reset(&day_start);
77 return Err(
78 winnow::error::ErrMode::from_external_error(input, e:CustomError::OutOfRange).cut(),
79 );
80 }
81
82 Ok(Date { year, month, day })
83}
84
85// partial-time = time-hour ":" time-minute ":" time-second [time-secfrac]
86pub(crate) fn partial_time(input: &mut Input<'_>) -> ModalResult<Time> {
87 traceimpl Parser, …>, …, …>(
88 name:"partial-time",
89 (
90 time_hour,
91 b':',
92 cut_err((time_minute, b':', time_second, opt(parser:time_secfrac))),
93 )
94 .map(|(hour: u8, _, (minute: u8, _, second: u8, nanosecond: Option))| Time {
95 hour,
96 minute,
97 second,
98 nanosecond: nanosecond.unwrap_or_default(),
99 }),
100 )
101 .parse_next(input)
102}
103
104// time-offset = "Z" / time-numoffset
105// time-numoffset = ( "+" / "-" ) time-hour ":" time-minute
106pub(crate) fn time_offset(input: &mut Input<'_>) -> ModalResult<Offset> {
107 traceimpl Parser, …>, …, …>(
108 name:"time-offset",
109 parser:alt((
110 one_of((b'Z', b'z')).value(val:Offset::Z),
111 (
112 one_of((b'+', b'-')),
113 cut_err((time_hour, b':', time_minute)),
114 )
115 .map(|(sign, (hours, _, minutes))| {
116 let sign = match sign {
117 b'+' => 1,
118 b'-' => -1,
119 _ => unreachable!("Parser prevents this"),
120 };
121 sign * (hours as i16 * 60 + minutes as i16)
122 })
123 .verify(|minutes: &i16| ((-24 * 60)..=(24 * 60)).contains(item:minutes))
124 .map(|minutes: i16| Offset::Custom { minutes }),
125 ))
126 .context(StrContext::Label("time offset")),
127 )
128 .parse_next(input)
129}
130
131// date-fullyear = 4DIGIT
132pub(crate) fn date_fullyear(input: &mut Input<'_>) -> ModalResult<u16> {
133 unsigned_digitsMap(…) -> …, …, …, …, …, …>::<4, 4>
134 .map(|s: &str| s.parse::<u16>().expect(msg:"4DIGIT should match u8"))
135 .parse_next(input)
136}
137
138// date-month = 2DIGIT ; 01-12
139pub(crate) fn date_month(input: &mut Input<'_>) -> ModalResult<u8> {
140 unsigned_digitsTryMap(…) -> …, …, …, …, …, …, …>::<2, 2>
141 .try_map(|s: &str| {
142 let d: u8 = s.parse::<u8>().expect(msg:"2DIGIT should match u8");
143 if (1..=12).contains(&d) {
144 Ok(d)
145 } else {
146 Err(CustomError::OutOfRange)
147 }
148 })
149 .parse_next(input)
150}
151
152// date-mday = 2DIGIT ; 01-28, 01-29, 01-30, 01-31 based on month/year
153pub(crate) fn date_mday(input: &mut Input<'_>) -> ModalResult<u8> {
154 unsigned_digitsTryMap(…) -> …, …, …, …, …, …, …>::<2, 2>
155 .try_map(|s: &str| {
156 let d: u8 = s.parse::<u8>().expect(msg:"2DIGIT should match u8");
157 if (1..=31).contains(&d) {
158 Ok(d)
159 } else {
160 Err(CustomError::OutOfRange)
161 }
162 })
163 .parse_next(input)
164}
165
166// time-delim = "T" / %x20 ; T, t, or space
167pub(crate) fn time_delim(input: &mut Input<'_>) -> ModalResult<u8> {
168 one_of(TIME_DELIM).parse_next(input)
169}
170
171const TIME_DELIM: (u8, u8, u8) = (b'T', b't', b' ');
172
173// time-hour = 2DIGIT ; 00-23
174pub(crate) fn time_hour(input: &mut Input<'_>) -> ModalResult<u8> {
175 unsigned_digitsTryMap(…) -> …, …, …, …, …, …, …>::<2, 2>
176 .try_map(|s: &str| {
177 let d: u8 = s.parse::<u8>().expect(msg:"2DIGIT should match u8");
178 if (0..=23).contains(&d) {
179 Ok(d)
180 } else {
181 Err(CustomError::OutOfRange)
182 }
183 })
184 .parse_next(input)
185}
186
187// time-minute = 2DIGIT ; 00-59
188pub(crate) fn time_minute(input: &mut Input<'_>) -> ModalResult<u8> {
189 unsigned_digitsTryMap(…) -> …, …, …, …, …, …, …>::<2, 2>
190 .try_map(|s: &str| {
191 let d: u8 = s.parse::<u8>().expect(msg:"2DIGIT should match u8");
192 if (0..=59).contains(&d) {
193 Ok(d)
194 } else {
195 Err(CustomError::OutOfRange)
196 }
197 })
198 .parse_next(input)
199}
200
201// time-second = 2DIGIT ; 00-58, 00-59, 00-60 based on leap second rules
202pub(crate) fn time_second(input: &mut Input<'_>) -> ModalResult<u8> {
203 unsigned_digitsTryMap(…) -> …, …, …, …, …, …, …>::<2, 2>
204 .try_map(|s: &str| {
205 let d: u8 = s.parse::<u8>().expect(msg:"2DIGIT should match u8");
206 if (0..=60).contains(&d) {
207 Ok(d)
208 } else {
209 Err(CustomError::OutOfRange)
210 }
211 })
212 .parse_next(input)
213}
214
215// time-secfrac = "." 1*DIGIT
216pub(crate) fn time_secfrac(input: &mut Input<'_>) -> ModalResult<u32> {
217 static SCALE: [u32; 10] = [
218 0,
219 100_000_000,
220 10_000_000,
221 1_000_000,
222 100_000,
223 10_000,
224 1_000,
225 100,
226 10,
227 1,
228 ];
229 const INF: usize = usize::MAX;
230 preceded(b'.', unsigned_digits::<1, INF>)
231 .try_map(|mut repr: &str| -> Result<u32, CustomError> {
232 let max_digits = SCALE.len() - 1;
233 if max_digits < repr.len() {
234 // Millisecond precision is required. Further precision of fractional seconds is
235 // implementation-specific. If the value contains greater precision than the
236 // implementation can support, the additional precision must be truncated, not rounded.
237 repr = &repr[0..max_digits];
238 }
239
240 let v = repr.parse::<u32>().map_err(|_| CustomError::OutOfRange)?;
241 let num_digits = repr.len();
242
243 // scale the number accordingly.
244 let scale = SCALE.get(num_digits).ok_or(CustomError::OutOfRange)?;
245 let v = v.checked_mul(*scale).ok_or(CustomError::OutOfRange)?;
246 Ok(v)
247 })
248 .parse_next(input)
249}
250
251pub(crate) fn unsigned_digits<'i, const MIN: usize, const MAX: usize>(
252 input: &mut Input<'i>,
253) -> ModalResult<&'i str> {
254 take_whileMap, …, …>, …, …, …, …, …>(MIN..=MAX, DIGIT)
255 .map(|b: &[u8]| unsafe { from_utf8_unchecked(bytes:b, safety_justification:"`is_ascii_digit` filters out on-ASCII") })
256 .parse_next(input)
257}
258
259// DIGIT = %x30-39 ; 0-9
260const DIGIT: RangeInclusive<u8> = b'0'..=b'9';
261
262#[cfg(test)]
263#[cfg(feature = "parse")]
264#[cfg(feature = "display")]
265mod test {
266 use super::*;
267
268 #[test]
269 fn offset_date_time() {
270 let inputs = [
271 (
272 "1979-05-27T07:32:00Z",
273 Datetime {
274 date: Some(Date {
275 year: 1979,
276 month: 5,
277 day: 27,
278 }),
279 time: Some(Time {
280 hour: 7,
281 minute: 32,
282 second: 0,
283 nanosecond: 0,
284 }),
285 offset: Some(Offset::Z),
286 },
287 ),
288 (
289 "1979-05-27T00:32:00-07:00",
290 Datetime {
291 date: Some(Date {
292 year: 1979,
293 month: 5,
294 day: 27,
295 }),
296 time: Some(Time {
297 hour: 0,
298 minute: 32,
299 second: 0,
300 nanosecond: 0,
301 }),
302 offset: Some(Offset::Custom { minutes: -7 * 60 }),
303 },
304 ),
305 (
306 "1979-05-27T00:32:00-00:36",
307 Datetime {
308 date: Some(Date {
309 year: 1979,
310 month: 5,
311 day: 27,
312 }),
313 time: Some(Time {
314 hour: 0,
315 minute: 32,
316 second: 0,
317 nanosecond: 0,
318 }),
319 offset: Some(Offset::Custom { minutes: -36 }),
320 },
321 ),
322 (
323 "1979-05-27T00:32:00.999999",
324 Datetime {
325 date: Some(Date {
326 year: 1979,
327 month: 5,
328 day: 27,
329 }),
330 time: Some(Time {
331 hour: 0,
332 minute: 32,
333 second: 0,
334 nanosecond: 999999000,
335 }),
336 offset: None,
337 },
338 ),
339 ];
340 for (input, expected) in inputs {
341 dbg!(input);
342 let actual = date_time.parse(new_input(input)).unwrap();
343 assert_eq!(expected, actual);
344 }
345 }
346
347 #[test]
348 fn local_date_time() {
349 let inputs = [
350 (
351 "1979-05-27T07:32:00",
352 Datetime {
353 date: Some(Date {
354 year: 1979,
355 month: 5,
356 day: 27,
357 }),
358 time: Some(Time {
359 hour: 7,
360 minute: 32,
361 second: 0,
362 nanosecond: 0,
363 }),
364 offset: None,
365 },
366 ),
367 (
368 "1979-05-27T00:32:00.999999",
369 Datetime {
370 date: Some(Date {
371 year: 1979,
372 month: 5,
373 day: 27,
374 }),
375 time: Some(Time {
376 hour: 0,
377 minute: 32,
378 second: 0,
379 nanosecond: 999999000,
380 }),
381 offset: None,
382 },
383 ),
384 ];
385 for (input, expected) in inputs {
386 dbg!(input);
387 let actual = date_time.parse(new_input(input)).unwrap();
388 assert_eq!(expected, actual);
389 }
390 }
391
392 #[test]
393 fn local_date() {
394 let inputs = [
395 (
396 "1979-05-27",
397 Datetime {
398 date: Some(Date {
399 year: 1979,
400 month: 5,
401 day: 27,
402 }),
403 time: None,
404 offset: None,
405 },
406 ),
407 (
408 "2017-07-20",
409 Datetime {
410 date: Some(Date {
411 year: 2017,
412 month: 7,
413 day: 20,
414 }),
415 time: None,
416 offset: None,
417 },
418 ),
419 ];
420 for (input, expected) in inputs {
421 dbg!(input);
422 let actual = date_time.parse(new_input(input)).unwrap();
423 assert_eq!(expected, actual);
424 }
425 }
426
427 #[test]
428 fn local_time() {
429 let inputs = [
430 (
431 "07:32:00",
432 Datetime {
433 date: None,
434 time: Some(Time {
435 hour: 7,
436 minute: 32,
437 second: 0,
438 nanosecond: 0,
439 }),
440 offset: None,
441 },
442 ),
443 (
444 "00:32:00.999999",
445 Datetime {
446 date: None,
447 time: Some(Time {
448 hour: 0,
449 minute: 32,
450 second: 0,
451 nanosecond: 999999000,
452 }),
453 offset: None,
454 },
455 ),
456 ];
457 for (input, expected) in inputs {
458 dbg!(input);
459 let actual = date_time.parse(new_input(input)).unwrap();
460 assert_eq!(expected, actual);
461 }
462 }
463
464 #[test]
465 fn time_fraction_truncated() {
466 let input = "1987-07-05T17:45:00.123456789012345Z";
467 date_time.parse(new_input(input)).unwrap();
468 }
469}
470