From 07d4b80ea53747ee629a2104a9a41bea16fcbf4e Mon Sep 17 00:00:00 2001 From: Terts Diepraam Date: Fri, 26 Jan 2024 17:17:36 +0100 Subject: [PATCH 1/4] start parsing date with winnow --- Cargo.lock | 10 + Cargo.toml | 1 + src/items/combined.rs | 76 +++++++ src/items/date.rs | 232 ++++++++++++++++++++++ src/items/mod.rs | 158 +++++++++++++++ src/items/number.rs | 45 +++++ src/items/ordinal.rs | 46 +++++ src/items/relative.rs | 190 ++++++++++++++++++ src/items/time.rs | 438 +++++++++++++++++++++++++++++++++++++++++ src/items/time_zone.rs | 14 ++ src/items/weekday.rs | 124 ++++++++++++ src/lib.rs | 349 +------------------------------- 12 files changed, 1342 insertions(+), 341 deletions(-) create mode 100644 src/items/combined.rs create mode 100644 src/items/date.rs create mode 100644 src/items/mod.rs create mode 100644 src/items/number.rs create mode 100644 src/items/ordinal.rs create mode 100644 src/items/relative.rs create mode 100644 src/items/time.rs create mode 100644 src/items/time_zone.rs create mode 100644 src/items/weekday.rs diff --git a/Cargo.lock b/Cargo.lock index c4cc03d..6de1e00 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -149,6 +149,7 @@ dependencies = [ "chrono", "nom", "regex", + "winnow", ] [[package]] @@ -348,3 +349,12 @@ name = "windows_x86_64_msvc" version = "0.52.5" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "bec47e5bfd1bff0eeaf6d8b485cc1074891a197ab4225d504cb7a1ab88b02bf0" + +[[package]] +name = "winnow" +version = "0.5.40" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f593a95398737aeed53e489c785df13f3618e41dbcd6718c6addbf1395aa6876" +dependencies = [ + "memchr", +] diff --git a/Cargo.toml b/Cargo.toml index 751b38f..daa557f 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -11,3 +11,4 @@ readme = "README.md" regex = "1.10.4" chrono = { version="0.4.38", default-features=false, features=["std", "alloc", "clock"] } nom = "8.0.0" +winnow = "0.5.34" diff --git a/src/items/combined.rs b/src/items/combined.rs new file mode 100644 index 0000000..241fe32 --- /dev/null +++ b/src/items/combined.rs @@ -0,0 +1,76 @@ +// For the full copyright and license information, please view the LICENSE +// file that was distributed with this source code. + +//! Parse an ISO 8601 date and time item +//! +//! The GNU docs state: +//! +//! > The ISO 8601 date and time of day extended format consists of an ISO 8601 +//! > date, a ‘T’ character separator, and an ISO 8601 time of day. This format +//! > is also recognized if the ‘T’ is replaced by a space. +//! > +//! > In this format, the time of day should use 24-hour notation. Fractional +//! > seconds are allowed, with either comma or period preceding the fraction. +//! > ISO 8601 fractional minutes and hours are not supported. Typically, hosts +//! > support nanosecond timestamp resolution; excess precision is silently discarded. + +use winnow::{combinator::alt, seq, PResult, Parser}; + +use crate::items::space; + +use super::{ + date::{self, Date}, + s, + time::{self, Time}, +}; + +#[derive(PartialEq, Debug, Clone)] +pub struct DateTime { + date: Date, + time: Time, +} + +pub fn parse(input: &mut &str) -> PResult { + seq!(DateTime { + date: date::iso, + // Note: the `T` is lowercased by the main parse function + _: alt((s('t').void(), (' ', space).void())), + time: time::iso, + }) + .parse_next(input) +} + +#[cfg(test)] +mod tests { + use super::{parse, DateTime}; + use crate::items::{date::Date, time::Time}; + + #[test] + fn some_date() { + let reference = Some(DateTime { + date: Date { + day: 10, + month: 10, + year: Some(2022), + }, + time: Time { + hour: 10, + minute: 10, + second: 55.0, + offset: None, + }, + }); + + for mut s in [ + "2022-10-10t10:10:55", + "2022-10-10 10:10:55", + "2022-10-10 t 10:10:55", + "2022-10-10 10:10:55", + "2022-10-10 (A comment!) t 10:10:55", + "2022-10-10 (A comment!) 10:10:55", + ] { + let old_s = s.to_owned(); + assert_eq!(parse(&mut s).ok(), reference, "Failed string: {old_s}") + } + } +} diff --git a/src/items/date.rs b/src/items/date.rs new file mode 100644 index 0000000..f6f3096 --- /dev/null +++ b/src/items/date.rs @@ -0,0 +1,232 @@ +// For the full copyright and license information, please view the LICENSE +// file that was distributed with this source code. + +//! Parse a date item (without time component) +//! +//! The GNU docs say: +//! +//! > A calendar date item specifies a day of the year. It is specified +//! > differently, depending on whether the month is specified numerically +//! > or literally. +//! > +//! > ... +//! > +//! > For numeric months, the ISO 8601 format ‘year-month-day’ is allowed, +//! > where year is any positive number, month is a number between 01 and +//! > 12, and day is a number between 01 and 31. A leading zero must be +//! > present if a number is less than ten. If year is 68 or smaller, then +//! > 2000 is added to it; otherwise, if year is less than 100, then 1900 +//! > is added to it. The construct ‘month/day/year’, popular in the United +//! > States, is accepted. Also ‘month/day’, omitting the year. +//! > +//! > Literal months may be spelled out in full: ‘January’, ‘February’, +//! > ‘March’, ‘April’, ‘May’, ‘June’, ‘July’, ‘August’, ‘September’, +//! > ‘October’, ‘November’ or ‘December’. Literal months may be +//! > abbreviated to their first three letters, possibly followed by an +//! > abbreviating dot. It is also permitted to write ‘Sept’ instead of +//! > ‘September’. + +use winnow::{ + ascii::{alpha1, dec_uint}, + combinator::{alt, opt, preceded}, + seq, + token::take, + PResult, Parser, +}; + +use super::s; +use crate::ParseDateTimeError; + +#[derive(PartialEq, Eq, Clone, Debug)] +pub struct Date { + pub day: u32, + pub month: u32, + pub year: Option, +} + +pub fn parse(input: &mut &str) -> PResult { + alt((iso, us, literal1, literal2)).parse_next(input) +} + +/// Parse `YYYY-MM-DD` or `YY-MM-DD` +/// +/// This is also used by [`combined`](super::combined). +pub fn iso(input: &mut &str) -> PResult { + seq!(Date { + year: year.map(Some), + _: s('-'), + month: month, + _: s('-'), + day: day, + }) + .parse_next(input) +} + +/// Parse `MM/DD/YYYY`, `MM/DD/YY` or `MM/DD` +fn us(input: &mut &str) -> PResult { + seq!(Date { + month: month, + _: s('/'), + day: day, + year: opt(preceded(s('/'), year)), + }) + .parse_next(input) +} + +/// Parse `14 November 2022`, `14 Nov 2022`, "14nov2022", "14-nov-2022", "14-nov2022", "14nov-2022" +fn literal1(input: &mut &str) -> PResult { + seq!(Date { + day: day, + _: opt(s('-')), + month: literal_month, + year: opt(preceded(opt(s('-')), year)), + }) + .parse_next(input) +} + +/// Parse `November 14, 2022` and `Nov 14, 2022` +fn literal2(input: &mut &str) -> PResult { + seq!(Date { + month: literal_month, + day: day, + // FIXME: GNU requires _some_ space between the day and the year, + // probably to distinguish with floats. + year: opt(preceded(s(","), year)), + }) + .parse_next(input) +} + +fn year(input: &mut &str) -> PResult { + s(alt(( + take(4usize).try_map(|x: &str| x.parse()), + take(3usize).try_map(|x: &str| x.parse()), + take(2usize).try_map(|x: &str| x.parse()).map( + |x: u32| { + if x <= 68 { + x + 2000 + } else { + x + 1900 + } + }, + ), + ))) + .parse_next(input) +} + +fn month(input: &mut &str) -> PResult { + s(dec_uint) + .try_map(|x| { + (x >= 1 && x <= 12) + .then_some(x) + .ok_or(ParseDateTimeError::InvalidInput) + }) + .parse_next(input) +} + +fn day(input: &mut &str) -> PResult { + s(dec_uint) + .try_map(|x| { + (x >= 1 && x <= 31) + .then_some(x) + .ok_or(ParseDateTimeError::InvalidInput) + }) + .parse_next(input) +} + +/// Parse the name of a month (case-insensitive) +fn literal_month(input: &mut &str) -> PResult { + s(alpha1) + .verify_map(|s: &str| { + Some(match s { + "january" | "jan" => 1, + "february" | "feb" => 2, + "march" | "mar" => 3, + "april" | "apr" => 4, + "may" => 5, + "june" | "jun" => 6, + "july" | "jul" => 7, + "august" | "aug" => 8, + "september" | "sep" | "sept" => 9, + "october" | "oct" => 10, + "november" | "nov" => 11, + "december" | "dec" => 12, + _ => return None, + }) + }) + .parse_next(input) +} + +#[cfg(test)] +mod tests { + use super::{parse, Date}; + + // Test cases from the GNU docs: + // + // ``` + // 2022-11-14 # ISO 8601. + // 22-11-14 # Assume 19xx for 69 through 99, + // # 20xx for 00 through 68 (not recommended). + // 11/14/2022 # Common U.S. writing. + // 14 November 2022 + // 14 Nov 2022 # Three-letter abbreviations always allowed. + // November 14, 2022 + // 14-nov-2022 + // 14nov2022 + // ``` + + #[test] + fn with_year() { + let reference = Date { + year: Some(2022), + month: 11, + day: 14, + }; + + for mut s in [ + "2022-11-14", + "2022 - 11 - 14", + "22-11-14", + "2022---11----14", + "22(comment 1)-11(comment 2)-14", + "11/14/2022", + "11--/14--/2022", + "11(comment 1)/(comment 2)14(comment 3)/(comment 4)2022", + "11 / 14 / 2022", + "11/14/22", + "14 november 2022", + "14 nov 2022", + "november 14, 2022", + "november 14 , 2022", + "nov 14, 2022", + "14-nov-2022", + "14nov2022", + "14nov 2022", + ] { + let old_s = s.to_owned(); + assert_eq!(parse(&mut s).unwrap(), reference, "Format string: {old_s}"); + } + } + + #[test] + fn no_year() { + let reference = Date { + year: None, + month: 11, + day: 14, + }; + for mut s in [ + "11/14", + "14 november", + "14 nov", + "14(comment!)nov", + "november 14", + "november(comment!)14", + "nov 14", + "14-nov", + "14nov", + "14(comment????)nov", + ] { + assert_eq!(parse(&mut s).unwrap(), reference); + } + } +} diff --git a/src/items/mod.rs b/src/items/mod.rs new file mode 100644 index 0000000..347cdf0 --- /dev/null +++ b/src/items/mod.rs @@ -0,0 +1,158 @@ +// For the full copyright and license information, please view the LICENSE +// file that was distributed with this source code. + +// spell-checker:ignore multispace0 + +//! From the GNU docs: +//! +//! > A date is a string, possibly empty, containing many items separated by +//! > whitespace. The whitespace may be omitted when no ambiguity arises. The +//! > empty string means the beginning of today (i.e., midnight). Order of the +//! > items is immaterial. A date string may contain many flavors of items: +//! > - calendar date items +//! > - time of day items +//! > - time zone items +//! > - combined date and time of day items +//! > - day of the week items +//! > - relative items +//! > - pure numbers. +//! +//! We put all of those in separate modules: +//! - [`date`] +//! - [`time`] +//! - [`time_zone`] +//! - [`combined`] +//! - [`weekday`] +//! - [`relative`] +//! - [`number] + +mod combined; +mod date; +mod ordinal; +mod relative; +mod time; +mod time_zone; +mod weekday; +mod number {} + +use winnow::{ + ascii::multispace0, + combinator::{alt, delimited, not, peek, preceded, repeat, separated, terminated}, + error::ParserError, + stream::AsChar, + token::{none_of, take_while}, + PResult, Parser, +}; + +#[derive(PartialEq, Debug)] +pub enum Item { + DateTime(combined::DateTime), + Date(date::Date), + Time(time::Time), + Weekday(weekday::Weekday), + Relative(relative::Relative), + TimeZone(()), +} + +/// Allow spaces and comments before a parser +/// +/// Every token parser should be wrapped in this to allow spaces and comments. +/// It is only preceding, because that allows us to check mandatory whitespace +/// after running the parser. +fn s<'a, O, E>(p: impl Parser<&'a str, O, E>) -> impl Parser<&'a str, O, E> +where + E: ParserError<&'a str>, +{ + preceded(space, p) +} + +/// Parse the space in-between tokens +/// +/// You probably want to use the [`s`] combinator instead. +fn space<'a, E>(input: &mut &'a str) -> PResult<(), E> +where + E: ParserError<&'a str>, +{ + separated(0.., multispace0, alt((comment, ignored_hyphen_or_plus))).parse_next(input) +} + +/// A hyphen or plus is ignored when it is not followed by a digit +/// +/// This includes being followed by a comment! Compare these inputs: +/// ```txt +/// - 12 weeks +/// - (comment) 12 weeks +/// ``` +/// The last comment should be ignored. +/// +/// The plus is undocumented, but it seems to be ignored. +fn ignored_hyphen_or_plus<'a, E>(input: &mut &'a str) -> PResult<(), E> +where + E: ParserError<&'a str>, +{ + ( + alt(('-', '+')), + multispace0, + peek(not(take_while(1, AsChar::is_dec_digit))), + ) + .void() + .parse_next(input) +} + +/// Parse a comment +/// +/// A comment is given between parentheses, which must be balanced. Any other +/// tokens can be within the comment. +fn comment<'a, E>(input: &mut &'a str) -> PResult<(), E> +where + E: ParserError<&'a str>, +{ + delimited( + '(', + repeat(0.., alt((none_of(['(', ')']).void(), comment))), + ')', + ) + .parse_next(input) +} + +/// Parse an item +pub fn parse_one(input: &mut &str) -> PResult { + alt(( + combined::parse.map(Item::DateTime), + date::parse.map(Item::Date), + time::parse.map(Item::Time), + relative::parse.map(Item::Relative), + weekday::parse.map(Item::Weekday), + // time_zone::parse.map(Item::TimeZone), + )) + .parse_next(input) +} + +pub fn parse(input: &mut &str) -> Option> { + terminated(repeat(0.., parse_one), space).parse(input).ok() +} + +#[cfg(test)] +mod tests { + use super::{date::Date, parse, time::Time, Item}; + + #[test] + fn date_and_time() { + assert_eq!( + parse(&mut " 10:10 2022-12-12 "), + Some(vec![ + Item::Time(Time { + hour: 10, + minute: 10, + second: 0.0, + offset: None, + }), + Item::Date(Date { + day: 12, + month: 12, + year: Some(2022) + }) + ]) + ) + } +} diff --git a/src/items/number.rs b/src/items/number.rs new file mode 100644 index 0000000..e795263 --- /dev/null +++ b/src/items/number.rs @@ -0,0 +1,45 @@ +// For the full copyright and license information, please view the LICENSE +// file that was distributed with this source code. + +//! Numbers without other symbols +//! +//! The GNU docs state: +//! +//! > If the decimal number is of the form yyyymmdd and no other calendar date +//! > item (see Calendar date items) appears before it in the date string, then +//! > yyyy is read as the year, mm as the month number and dd as the day of the +//! > month, for the specified calendar date. +//! > +//! > If the decimal number is of the form hhmm and no other time of day item +//! > appears before it in the date string, then hh is read as the hour of the +//! > day and mm as the minute of the hour, for the specified time of day. mm +//! > can also be omitted. + +use winnow::{combinator::cond, PResult}; + +enum Number { + Date, + Time, + Year, +} + +pub fn parse(seen_date: bool, seen_time: bool, input: &mut &str) -> PResult { + alt(( + cond(!seen_date, date_number), + cond(!seen_time, time_number), + cond(seen_date && seen_time, year_number), + )) + .parse_next(input) +} + +fn date_number(input: &mut &str) -> PResult { + todo!() +} + +fn time_number(input: &mut &str) -> PResult { + todo!() +} + +fn year_number(input: &mut &str) -> PResult { + todo!() +} diff --git a/src/items/ordinal.rs b/src/items/ordinal.rs new file mode 100644 index 0000000..8bf65f4 --- /dev/null +++ b/src/items/ordinal.rs @@ -0,0 +1,46 @@ +// For the full copyright and license information, please view the LICENSE +// file that was distributed with this source code. + +use super::s; +use winnow::{ + ascii::{alpha1, dec_uint}, + combinator::{alt, opt}, + PResult, Parser, +}; + +pub fn ordinal(input: &mut &str) -> PResult { + alt((text_ordinal, number_ordinal)).parse_next(input) +} + +fn number_ordinal(input: &mut &str) -> PResult { + let sign = opt(alt(('+'.value(1), '-'.value(-1)))).map(|s| s.unwrap_or(1)); + (s(sign), s(dec_uint)) + .verify_map(|(s, u): (i32, u32)| { + let i: i32 = u.try_into().ok()?; + Some(s * i) + }) + .parse_next(input) +} + +fn text_ordinal(input: &mut &str) -> PResult { + s(alpha1) + .verify_map(|s: &str| { + Some(match s { + "last" => -1, + "this" => 0, + "next" | "first" => 1, + "third" => 3, + "fourth" => 4, + "fifth" => 5, + "sixth" => 6, + "seventh" => 7, + "eight" => 8, + "ninth" => 9, + "tenth" => 10, + "eleventh" => 11, + "twelfth" => 12, + _ => return None, + }) + }) + .parse_next(input) +} diff --git a/src/items/relative.rs b/src/items/relative.rs new file mode 100644 index 0000000..7e7cb81 --- /dev/null +++ b/src/items/relative.rs @@ -0,0 +1,190 @@ +// For the full copyright and license information, please view the LICENSE +// file that was distributed with this source code. + +//! Parse a relative datetime item +//! +//! The GNU docs state: +//! +//! > The unit of time displacement may be selected by the string ‘year’ or +//! > ‘month’ for moving by whole years or months. These are fuzzy units, as +//! > years and months are not all of equal duration. More precise units are +//! > ‘fortnight’ which is worth 14 days, ‘week’ worth 7 days, ‘day’ worth 24 +//! > hours, ‘hour’ worth 60 minutes, ‘minute’ or ‘min’ worth 60 seconds, and +//! > ‘second’ or ‘sec’ worth one second. An ‘s’ suffix on these units is +//! > accepted and ignored. +//! > +//! > The unit of time may be preceded by a multiplier, given as an optionally +//! > signed number. Unsigned numbers are taken as positively signed. No number +//! > at all implies 1 for a multiplier. Following a relative item by the +//! > string ‘ago’ is equivalent to preceding the unit by a multiplier with +//! > value -1. +//! > +//! > The string ‘tomorrow’ is worth one day in the future (equivalent to +//! > ‘day’), the string ‘yesterday’ is worth one day in the past (equivalent +//! > to ‘day ago’). +//! > +//! > The strings ‘now’ or ‘today’ are relative items corresponding to +//! > zero-valued time displacement, these strings come from the fact a +//! > zero-valued time displacement represents the current time when not +//! > otherwise changed by previous items. They may be used to stress other +//! > items, like in ‘12:00 today’. The string ‘this’ also has the meaning of a +//! > zero-valued time displacement, but is preferred in date strings like +//! > ‘this thursday’. + +use winnow::{ + ascii::{alpha1, float}, + combinator::{alt, opt}, + PResult, Parser, +}; + +use super::{ordinal::ordinal, s}; + +#[derive(Clone, Copy, Debug, PartialEq)] +pub enum Relative { + Years(i32), + Months(i32), + Days(i32), + Hours(i32), + Minutes(i32), + // Seconds are special because they can be given as a float + Seconds(f64), +} + +impl Relative { + fn mul(self, n: i32) -> Self { + match self { + Self::Years(x) => Self::Years(n * x), + Self::Months(x) => Self::Months(n * x), + Self::Days(x) => Self::Days(n * x), + Self::Hours(x) => Self::Hours(n * x), + Self::Minutes(x) => Self::Minutes(n * x), + Self::Seconds(x) => Self::Seconds(f64::from(n) * x), + } + } +} + +pub fn parse(input: &mut &str) -> PResult { + alt(( + s("tomorrow").value(Relative::Days(1)), + s("yesterday").value(Relative::Days(-1)), + // For "today" and "now", the unit is arbitrary + s("today").value(Relative::Days(0)), + s("now").value(Relative::Days(0)), + seconds, + other, + )) + .parse_next(input) +} + +fn seconds(input: &mut &str) -> PResult { + ( + opt(alt((s(float), ordinal.map(|x| x as f64)))), + s(alpha1).verify(|s: &str| matches!(s, "seconds" | "second" | "sec" | "secs")), + ago, + ) + .map(|(n, _, ago)| Relative::Seconds(n.unwrap_or(1.0) * if ago { -1.0 } else { 1.0 })) + .parse_next(input) +} + +fn other(input: &mut &str) -> PResult { + (opt(ordinal), integer_unit, ago) + .map(|(n, unit, ago)| unit.mul(n.unwrap_or(1) * if ago { -1 } else { 1 })) + .parse_next(input) +} + +fn ago(input: &mut &str) -> PResult { + opt(s("ago")).map(|o| o.is_some()).parse_next(input) +} + +fn integer_unit(input: &mut &str) -> PResult { + s(alpha1) + .verify_map(|s: &str| { + Some(match s.strip_suffix('s').unwrap_or(&s) { + "year" => Relative::Years(1), + "month" => Relative::Months(1), + "fortnight" => Relative::Days(14), + "week" => Relative::Days(7), + "day" => Relative::Days(1), + "hour" => Relative::Hours(1), + "minute" | "min" => Relative::Minutes(1), + _ => return None, + }) + }) + .parse_next(input) +} + +#[cfg(test)] +mod tests { + use super::{parse, Relative}; + + #[test] + fn all() { + for (s, rel) in [ + // Seconds + ("second", Relative::Seconds(1.0)), + ("sec", Relative::Seconds(1.0)), + ("seconds", Relative::Seconds(1.0)), + ("secs", Relative::Seconds(1.0)), + ("second ago", Relative::Seconds(-1.0)), + ("3 seconds", Relative::Seconds(3.0)), + ("3.5 seconds", Relative::Seconds(3.5)), + // ("+3.5 seconds", Relative::Seconds(3.5)), + ("3.5 seconds ago", Relative::Seconds(-3.5)), + ("-3.5 seconds ago", Relative::Seconds(3.5)), + // Minutes + ("minute", Relative::Minutes(1)), + ("minutes", Relative::Minutes(1)), + ("min", Relative::Minutes(1)), + ("mins", Relative::Minutes(1)), + ("10 minutes", Relative::Minutes(10)), + ("-10 minutes", Relative::Minutes(-10)), + ("10 minutes ago", Relative::Minutes(-10)), + ("-10 minutes ago", Relative::Minutes(10)), + // Hours + ("hour", Relative::Hours(1)), + ("hours", Relative::Hours(1)), + ("10 hours", Relative::Hours(10)), + ("+10 hours", Relative::Hours(10)), + ("-10 hours", Relative::Hours(-10)), + ("10 hours ago", Relative::Hours(-10)), + ("-10 hours ago", Relative::Hours(10)), + // Days + ("day", Relative::Days(1)), + ("days", Relative::Days(1)), + ("10 days", Relative::Days(10)), + ("+10 days", Relative::Days(10)), + ("-10 days", Relative::Days(-10)), + ("10 days ago", Relative::Days(-10)), + ("-10 days ago", Relative::Days(10)), + // Multiple days + ("fortnight", Relative::Days(14)), + ("fortnights", Relative::Days(14)), + ("2 fortnights ago", Relative::Days(-28)), + ("+2 fortnights ago", Relative::Days(-28)), + ("week", Relative::Days(7)), + ("weeks", Relative::Days(7)), + ("2 weeks ago", Relative::Days(-14)), + // Other + ("year", Relative::Years(1)), + ("years", Relative::Years(1)), + ("month", Relative::Months(1)), + ("months", Relative::Months(1)), + // Special + ("yesterday", Relative::Days(-1)), + ("tomorrow", Relative::Days(1)), + ("today", Relative::Days(0)), + ("now", Relative::Days(0)), + // This something + ("this day", Relative::Days(0)), + ("this second", Relative::Seconds(0.0)), + ("this year", Relative::Years(0)), + // Weird stuff + ("next week ago", Relative::Days(-7)), + ("last week ago", Relative::Days(7)), + ("this week ago", Relative::Days(0)), + ] { + let mut t = s; + assert_eq!(parse(&mut t).ok(), Some(rel), "Failed string: {s}") + } + } +} diff --git a/src/items/time.rs b/src/items/time.rs new file mode 100644 index 0000000..7d58896 --- /dev/null +++ b/src/items/time.rs @@ -0,0 +1,438 @@ +// For the full copyright and license information, please view the LICENSE +// file that was distributed with this source code. + +// spell-checker:ignore shhmm colonless + +//! Parse a time item (without a date) +//! +//! The GNU docs state: +//! +//! > More generally, the time of day may be given as ‘hour:minute:second’, +//! > where hour is a number between 0 and 23, minute is a number between 0 and +//! > 59, and second is a number between 0 and 59 possibly followed by ‘.’ or +//! > ‘,’ and a fraction containing one or more digits. Alternatively, +//! > ‘:second’ can be omitted, in which case it is taken to be zero. On the +//! > rare hosts that support leap seconds, second may be 60. +//! > +//! > If the time is followed by ‘am’ or ‘pm’ (or ‘a.m.’ or ‘p.m.’), hour is +//! > restricted to run from 1 to 12, and ‘:minute’ may be omitted (taken to be +//! > zero). ‘am’ indicates the first half of the day, ‘pm’ indicates the +//! > second half of the day. In this notation, 12 is the predecessor of 1: +//! > midnight is ‘12am’ while noon is ‘12pm’. (This is the zero-oriented +//! > interpretation of ‘12am’ and ‘12pm’, as opposed to the old tradition +//! > derived from Latin which uses ‘12m’ for noon and ‘12pm’ for midnight.) +//! > +//! > The time may alternatively be followed by a time zone correction, +//! > expressed as ‘shhmm’, where s is ‘+’ or ‘-’, hh is a number of zone hours +//! > and mm is a number of zone minutes. The zone minutes term, mm, may be +//! > omitted, in which case the one- or two-digit correction is interpreted as +//! > a number of hours. You can also separate hh from mm with a colon. When a +//! > time zone correction is given this way, it forces interpretation of the +//! > time relative to Coordinated Universal Time (UTC), overriding any +//! > previous specification for the time zone or the local time zone. For +//! > example, ‘+0530’ and ‘+05:30’ both stand for the time zone 5.5 hours +//! > ahead of UTC (e.g., India). This is the best way to specify a time zone +//! > correction by fractional parts of an hour. The maximum zone correction is +//! > 24 hours. +//! > +//! > Either ‘am’/‘pm’ or a time zone correction may be specified, but not both. + +use winnow::{ + ascii::{dec_uint, float}, + combinator::{alt, opt, preceded}, + seq, + stream::AsChar, + token::take_while, + PResult, Parser, +}; + +use super::s; + +#[derive(PartialEq, Clone, Debug)] +pub struct Time { + pub hour: u32, + pub minute: u32, + pub second: f64, + pub offset: Option, +} + +#[derive(PartialEq, Debug, Clone)] +pub struct Offset { + negative: bool, + hours: u32, + minutes: u32, +} + +#[derive(Clone)] +enum Suffix { + Am, + Pm, +} + +pub fn parse(input: &mut &str) -> PResult