From c609405135014ff336791ce70376c7cea393fb9f Mon Sep 17 00:00:00 2001
From: Terts Diepraam <terts.diepraam@gmail.com>
Date: Fri, 26 Jan 2024 17:17:36 +0100
Subject: [PATCH 01/15] Delete almost everything to start again

---
 src/lib.rs            | 362 +-----------------------------------------
 src/parse_datetime.rs | 279 --------------------------------
 tests/simple.rs       | 148 -----------------
 3 files changed, 4 insertions(+), 785 deletions(-)
 delete mode 100644 src/parse_datetime.rs

diff --git a/src/lib.rs b/src/lib.rs
index 614b355..ea6e6d5 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1,26 +1,19 @@
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
 
-// Expose parse_datetime
-pub mod parse_datetime;
-
-use chrono::{Duration, Local, NaiveDate, Utc};
-use regex::{Error as RegexError, Regex};
 use std::error::Error;
 use std::fmt::{self, Display};
 
+use chrono::{DateTime, FixedOffset};
+
 #[derive(Debug, PartialEq)]
 pub enum ParseDurationError {
-    InvalidRegex(RegexError),
     InvalidInput,
 }
 
 impl Display for ParseDurationError {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
-            ParseDurationError::InvalidRegex(err) => {
-                write!(f, "Invalid regex for time pattern: {err}")
-            }
             ParseDurationError::InvalidInput => {
                 write!(
                     f,
@@ -33,353 +26,6 @@ impl Display for ParseDurationError {
 
 impl Error for ParseDurationError {}
 
-impl From<RegexError> for ParseDurationError {
-    fn from(err: RegexError) -> Self {
-        ParseDurationError::InvalidRegex(err)
-    }
-}
-
-/// Parses a relative time string and returns a `Duration` representing the
-/// relative time.
-///
-/// # Arguments
-///
-/// * `s` - A string slice representing the relative time.
-///
-/// # Examples
-///
-/// ```
-/// use chrono::Duration;
-/// let duration = parse_datetime::from_str("+3 days");
-/// assert_eq!(duration.unwrap(), Duration::days(3));
-/// ```
-///
-/// # Supported formats
-///
-/// The function supports the following formats for relative time:
-///
-/// * `num` `unit` (e.g., "-1 hour", "+3 days")
-/// * `unit` (e.g., "hour", "day")
-/// * "now" or "today"
-/// * "yesterday"
-/// * "tomorrow"
-/// * use "ago" for the past
-///
-/// `[num]` can be a positive or negative integer.
-/// [unit] can be one of the following: "fortnight", "week", "day", "hour",
-/// "minute", "min", "second", "sec" and their plural forms.
-///
-/// It is also possible to pass "1 hour 2 minutes" or "2 days and 2 hours"
-///
-/// # Returns
-///
-/// * `Ok(Duration)` - If the input string can be parsed as a relative time
-/// * `Err(ParseDurationError)` - If the input string cannot be parsed as a relative time
-///
-/// # Errors
-///
-/// This function will return `Err(ParseDurationError::InvalidInput)` if the input string
-/// cannot be parsed as a relative time.
-///
-/// # Examples
-///
-/// ```
-/// use chrono::Duration;
-/// use parse_datetime::{from_str, ParseDurationError};
-///
-/// assert_eq!(from_str("1 hour, 30 minutes").unwrap(), Duration::minutes(90));
-/// assert_eq!(from_str("tomorrow").unwrap(), Duration::days(1));
-/// assert!(matches!(from_str("invalid"), Err(ParseDurationError::InvalidInput)));
-/// ```
-pub fn from_str(s: &str) -> Result<Duration, ParseDurationError> {
-    from_str_at_date(Utc::now().date_naive(), s)
-}
-
-/// Parses a duration string and returns a `Duration` instance, with the duration
-/// calculated from the specified date.
-///
-/// # Arguments
-///
-/// * `date` - A `Date` instance representing the base date for the calculation
-/// * `s` - A string slice representing the relative time.
-///
-/// # Errors
-///
-/// This function will return `Err(ParseDurationError::InvalidInput)` if the input string
-/// cannot be parsed as a relative time.
-///
-/// # Examples
-///
-/// ```
-/// use chrono::{Duration, NaiveDate, Utc, Local};
-/// use parse_datetime::{from_str_at_date, ParseDurationError};
-/// let today = Local::now().date().naive_local();
-/// let yesterday = today - Duration::days(1);
-/// assert_eq!(
-///     from_str_at_date(yesterday, "2 days").unwrap(),
-///     Duration::days(1) // 1 day from the specified date + 1 day from the input string
-/// );
-/// ```
-pub fn from_str_at_date(date: NaiveDate, s: &str) -> Result<Duration, ParseDurationError> {
-    let time_pattern: Regex = Regex::new(
-        r"(?x)
-        (?:(?P<value>[-+]?\d*)\s*)?
-        (\s*(?P<direction>next|last)?\s*)?
-        (?P<unit>years?|months?|fortnights?|weeks?|days?|hours?|h|minutes?|mins?|m|seconds?|secs?|s|yesterday|tomorrow|now|today)
-        (\s*(?P<separator>and|,)?\s*)?
-        (\s*(?P<ago>ago)?)?",
-    )?;
-
-    let mut total_duration = Duration::seconds(0);
-    let mut is_ago = s.contains(" ago");
-    let mut captures_processed = 0;
-    let mut total_length = 0;
-
-    for capture in time_pattern.captures_iter(s) {
-        captures_processed += 1;
-
-        let value_str = capture
-            .name("value")
-            .ok_or(ParseDurationError::InvalidInput)?
-            .as_str();
-        let value = if value_str.is_empty() {
-            1
-        } else {
-            value_str
-                .parse::<i64>()
-                .map_err(|_| ParseDurationError::InvalidInput)?
-        };
-
-        if let Some(direction) = capture.name("direction") {
-            if direction.as_str() == "last" {
-                is_ago = true;
-            }
-        }
-
-        let unit = capture
-            .name("unit")
-            .ok_or(ParseDurationError::InvalidInput)?
-            .as_str();
-
-        if capture.name("ago").is_some() {
-            is_ago = true;
-        }
-
-        let duration = match unit {
-            "years" | "year" => Duration::days(value * 365),
-            "months" | "month" => Duration::days(value * 30),
-            "fortnights" | "fortnight" => Duration::weeks(value * 2),
-            "weeks" | "week" => Duration::weeks(value),
-            "days" | "day" => Duration::days(value),
-            "hours" | "hour" | "h" => Duration::hours(value),
-            "minutes" | "minute" | "mins" | "min" | "m" => Duration::minutes(value),
-            "seconds" | "second" | "secs" | "sec" | "s" => Duration::seconds(value),
-            "yesterday" => Duration::days(-1),
-            "tomorrow" => Duration::days(1),
-            "now" | "today" => Duration::zero(),
-            _ => return Err(ParseDurationError::InvalidInput),
-        };
-        let neg_duration = -duration;
-        total_duration =
-            match total_duration.checked_add(if is_ago { &neg_duration } else { &duration }) {
-                Some(duration) => duration,
-                None => return Err(ParseDurationError::InvalidInput),
-            };
-
-        // Calculate the total length of the matched substring
-        if let Some(m) = capture.get(0) {
-            total_length += m.end() - m.start();
-        }
-    }
-
-    // Check if the entire input string has been captured
-    if total_length != s.len() {
-        return Err(ParseDurationError::InvalidInput);
-    }
-
-    if captures_processed == 0 {
-        Err(ParseDurationError::InvalidInput)
-    } else {
-        let time_now = Local::now().date_naive();
-        let date_duration = date - time_now;
-
-        Ok(total_duration + date_duration)
-    }
-}
-
-#[cfg(test)]
-mod tests {
-
-    use super::ParseDurationError;
-    use super::{from_str, from_str_at_date};
-    use chrono::{Duration, Local, NaiveDate};
-
-    #[test]
-    fn test_years() {
-        assert_eq!(from_str("1 year").unwrap(), Duration::seconds(31_536_000));
-        assert_eq!(
-            from_str("-2 years").unwrap(),
-            Duration::seconds(-63_072_000)
-        );
-        assert_eq!(
-            from_str("2 years ago").unwrap(),
-            Duration::seconds(-63_072_000)
-        );
-        assert_eq!(from_str("year").unwrap(), Duration::seconds(31_536_000));
-    }
-
-    #[test]
-    fn test_months() {
-        assert_eq!(from_str("1 month").unwrap(), Duration::seconds(2_592_000));
-        assert_eq!(
-            from_str("1 month and 2 weeks").unwrap(),
-            Duration::seconds(3_801_600)
-        );
-        assert_eq!(
-            from_str("1 month and 2 weeks ago").unwrap(),
-            Duration::seconds(-3_801_600)
-        );
-        assert_eq!(from_str("2 months").unwrap(), Duration::seconds(5_184_000));
-        assert_eq!(from_str("month").unwrap(), Duration::seconds(2_592_000));
-    }
-
-    #[test]
-    fn test_fortnights() {
-        assert_eq!(
-            from_str("1 fortnight").unwrap(),
-            Duration::seconds(1_209_600)
-        );
-        assert_eq!(
-            from_str("3 fortnights").unwrap(),
-            Duration::seconds(3_628_800)
-        );
-        assert_eq!(from_str("fortnight").unwrap(), Duration::seconds(1_209_600));
-    }
-
-    #[test]
-    fn test_weeks() {
-        assert_eq!(from_str("1 week").unwrap(), Duration::seconds(604_800));
-        assert_eq!(
-            from_str("1 week 3 days").unwrap(),
-            Duration::seconds(864_000)
-        );
-        assert_eq!(
-            from_str("1 week 3 days ago").unwrap(),
-            Duration::seconds(-864_000)
-        );
-        assert_eq!(from_str("-2 weeks").unwrap(), Duration::seconds(-1_209_600));
-        assert_eq!(
-            from_str("2 weeks ago").unwrap(),
-            Duration::seconds(-1_209_600)
-        );
-        assert_eq!(from_str("week").unwrap(), Duration::seconds(604_800));
-    }
-
-    #[test]
-    fn test_days() {
-        assert_eq!(from_str("1 day").unwrap(), Duration::seconds(86400));
-        assert_eq!(from_str("2 days ago").unwrap(), Duration::seconds(-172_800));
-        assert_eq!(from_str("-2 days").unwrap(), Duration::seconds(-172_800));
-        assert_eq!(from_str("day").unwrap(), Duration::seconds(86400));
-    }
-
-    #[test]
-    fn test_hours() {
-        assert_eq!(from_str("1 hour").unwrap(), Duration::seconds(3600));
-        assert_eq!(from_str("1 hour ago").unwrap(), Duration::seconds(-3600));
-        assert_eq!(from_str("-2 hours").unwrap(), Duration::seconds(-7200));
-        assert_eq!(from_str("hour").unwrap(), Duration::seconds(3600));
-    }
-
-    #[test]
-    fn test_minutes() {
-        assert_eq!(from_str("1 minute").unwrap(), Duration::seconds(60));
-        assert_eq!(from_str("2 minutes").unwrap(), Duration::seconds(120));
-        assert_eq!(from_str("min").unwrap(), Duration::seconds(60));
-    }
-
-    #[test]
-    fn test_seconds() {
-        assert_eq!(from_str("1 second").unwrap(), Duration::seconds(1));
-        assert_eq!(from_str("2 seconds").unwrap(), Duration::seconds(2));
-        assert_eq!(from_str("sec").unwrap(), Duration::seconds(1));
-    }
-
-    #[test]
-    fn test_relative_days() {
-        assert_eq!(from_str("now").unwrap(), Duration::seconds(0));
-        assert_eq!(from_str("today").unwrap(), Duration::seconds(0));
-        assert_eq!(from_str("yesterday").unwrap(), Duration::seconds(-86400));
-        assert_eq!(from_str("tomorrow").unwrap(), Duration::seconds(86400));
-    }
-
-    #[test]
-    fn test_no_spaces() {
-        assert_eq!(from_str("-1hour").unwrap(), Duration::hours(-1));
-        assert_eq!(from_str("+3days").unwrap(), Duration::days(3));
-        assert_eq!(from_str("2weeks").unwrap(), Duration::weeks(2));
-        assert_eq!(
-            from_str("2weeks 1hour").unwrap(),
-            Duration::seconds(1_213_200)
-        );
-        assert_eq!(
-            from_str("2weeks 1hour ago").unwrap(),
-            Duration::seconds(-1_213_200)
-        );
-        assert_eq!(from_str("+4months").unwrap(), Duration::days(4 * 30));
-        assert_eq!(from_str("-2years").unwrap(), Duration::days(-2 * 365));
-        assert_eq!(from_str("15minutes").unwrap(), Duration::minutes(15));
-        assert_eq!(from_str("-30seconds").unwrap(), Duration::seconds(-30));
-        assert_eq!(from_str("30seconds ago").unwrap(), Duration::seconds(-30));
-    }
-
-    #[test]
-    fn test_invalid_input() {
-        let result = from_str("foobar");
-        println!("{result:?}");
-        assert_eq!(result, Err(ParseDurationError::InvalidInput));
-
-        let result = from_str("invalid 1");
-        assert_eq!(result, Err(ParseDurationError::InvalidInput));
-        // Fails for now with a panic
-        /*        let result = from_str("777777777777777771m");
-        match result {
-            Err(ParseDurationError::InvalidInput) => assert!(true),
-            _ => assert!(false),
-        }*/
-    }
-
-    #[test]
-    fn test_from_str_at_date() {
-        let date = NaiveDate::from_ymd_opt(2014, 9, 5).unwrap();
-        let now = Local::now().date_naive();
-        let days_diff = (date - now).num_days();
-
-        assert_eq!(
-            from_str_at_date(date, "1 day").unwrap(),
-            Duration::days(days_diff + 1)
-        );
-
-        assert_eq!(
-            from_str_at_date(date, "2 hours").unwrap(),
-            Duration::days(days_diff) + Duration::hours(2)
-        );
-    }
-
-    #[test]
-    fn test_invalid_input_at_date() {
-        let date = NaiveDate::from_ymd_opt(2014, 9, 5).unwrap();
-        assert!(matches!(
-            from_str_at_date(date, "invalid"),
-            Err(ParseDurationError::InvalidInput)
-        ));
-    }
-
-    #[test]
-    fn test_direction() {
-        assert_eq!(from_str("last hour").unwrap(), Duration::seconds(-3600));
-        assert_eq!(from_str("next year").unwrap(), Duration::days(365));
-        assert_eq!(from_str("next week").unwrap(), Duration::days(7));
-        assert_eq!(from_str("last month").unwrap(), Duration::days(-30));
-    }
+fn parse_datetime(s: &str) -> Result<DateTime<FixedOffset>, ParseDurationError> {
+    todo!()
 }
diff --git a/src/parse_datetime.rs b/src/parse_datetime.rs
deleted file mode 100644
index 7b1f536..0000000
--- a/src/parse_datetime.rs
+++ /dev/null
@@ -1,279 +0,0 @@
-// For the full copyright and license information, please view the LICENSE
-// file that was distributed with this source code.
-
-use chrono::{DateTime, FixedOffset, Local, LocalResult, NaiveDateTime, TimeZone};
-
-use crate::ParseDurationError;
-
-/// Formats that parse input can take.
-/// Taken from `touch` coreutils
-mod format {
-    pub(crate) const ISO_8601: &str = "%Y-%m-%d";
-    pub(crate) const ISO_8601_NO_SEP: &str = "%Y%m%d";
-    pub(crate) const POSIX_LOCALE: &str = "%a %b %e %H:%M:%S %Y";
-    pub(crate) const YYYYMMDDHHMM_DOT_SS: &str = "%Y%m%d%H%M.%S";
-    pub(crate) const YYYYMMDDHHMMSS: &str = "%Y-%m-%d %H:%M:%S.%f";
-    pub(crate) const YYYYMMDDHHMMS: &str = "%Y-%m-%d %H:%M:%S";
-    pub(crate) const YYYY_MM_DD_HH_MM: &str = "%Y-%m-%d %H:%M";
-    pub(crate) const YYYYMMDDHHMM: &str = "%Y%m%d%H%M";
-    pub(crate) const YYYYMMDDHHMM_OFFSET: &str = "%Y%m%d%H%M %z";
-    pub(crate) const YYYYMMDDHHMM_UTC_OFFSET: &str = "%Y%m%d%H%MUTC%z";
-    pub(crate) const YYYYMMDDHHMM_ZULU_OFFSET: &str = "%Y%m%d%H%MZ%z";
-    pub(crate) const YYYYMMDDHHMM_HYPHENATED_OFFSET: &str = "%Y-%m-%d %H:%M %z";
-    pub(crate) const YYYYMMDDHHMMS_T_SEP: &str = "%Y-%m-%dT%H:%M:%S";
-    pub(crate) const UTC_OFFSET: &str = "UTC%#z";
-    pub(crate) const ZULU_OFFSET: &str = "Z%#z";
-}
-
-/// Loosely parses a time string and returns a `DateTime` representing the
-/// absolute time of the string.
-///
-/// # Arguments
-///
-/// * `s` - A string slice representing the time.
-///
-/// # Examples
-///
-/// ```
-/// use chrono::{DateTime, Utc, TimeZone};
-/// let time = parse_datetime::parse_datetime::from_str("2023-06-03 12:00:01Z");
-/// assert_eq!(time.unwrap(), Utc.with_ymd_and_hms(2023, 06, 03, 12, 00, 01).unwrap());
-/// ```
-///
-/// # Supported formats
-///
-/// The function supports the following formats for time:
-///
-/// * ISO formats
-/// * timezone offsets, e.g., "UTC-0100"
-///
-/// # Returns
-///
-/// * `Ok(DateTime<FixedOffset>)` - If the input string can be parsed as a time
-/// * `Err(ParseDurationError)` - If the input string cannot be parsed as a relative time
-///
-/// # Errors
-///
-/// This function will return `Err(ParseDurationError::InvalidInput)` if the input string
-/// cannot be parsed as a relative time.
-///
-pub fn from_str<S: AsRef<str> + Clone>(s: S) -> Result<DateTime<FixedOffset>, ParseDurationError> {
-    // TODO: Replace with a proper customiseable parsing solution using `nom`, `grmtools`, or
-    // similar
-
-    // Formats with offsets don't require NaiveDateTime workaround
-    for fmt in [
-        format::YYYYMMDDHHMM_OFFSET,
-        format::YYYYMMDDHHMM_HYPHENATED_OFFSET,
-        format::YYYYMMDDHHMM_UTC_OFFSET,
-        format::YYYYMMDDHHMM_ZULU_OFFSET,
-    ] {
-        if let Ok(parsed) = DateTime::parse_from_str(s.as_ref(), fmt) {
-            return Ok(parsed);
-        }
-    }
-
-    // Parse formats with no offset, assume local time
-    for fmt in [
-        format::YYYYMMDDHHMMS_T_SEP,
-        format::YYYYMMDDHHMM,
-        format::YYYYMMDDHHMMS,
-        format::YYYYMMDDHHMMSS,
-        format::YYYY_MM_DD_HH_MM,
-        format::YYYYMMDDHHMM_DOT_SS,
-        format::POSIX_LOCALE,
-    ] {
-        if let Ok(parsed) = NaiveDateTime::parse_from_str(s.as_ref(), fmt) {
-            if let Ok(dt) = naive_dt_to_fixed_offset(parsed) {
-                return Ok(dt);
-            }
-        }
-    }
-
-    // Parse epoch seconds
-    if s.as_ref().bytes().next() == Some(b'@') {
-        if let Ok(parsed) = NaiveDateTime::parse_from_str(&s.as_ref()[1..], "%s") {
-            if let Ok(dt) = naive_dt_to_fixed_offset(parsed) {
-                return Ok(dt);
-            }
-        }
-    }
-
-    let ts = s.as_ref().to_owned() + "0000";
-    // Parse date only formats - assume midnight local timezone
-    for fmt in [format::ISO_8601, format::ISO_8601_NO_SEP] {
-        let f = fmt.to_owned() + "%H%M";
-        if let Ok(parsed) = NaiveDateTime::parse_from_str(&ts, &f) {
-            if let Ok(dt) = naive_dt_to_fixed_offset(parsed) {
-                return Ok(dt);
-            }
-        }
-    }
-
-    // Parse offsets. chrono doesn't provide any functionality to parse
-    // offsets, so instead we replicate parse_date behaviour by getting
-    // the current date with local, and create a date time string at midnight,
-    // before trying offset suffixes
-    let local = Local::now();
-    let ts = format!("{}", local.format("%Y%m%d")) + "0000" + s.as_ref();
-    for fmt in [format::UTC_OFFSET, format::ZULU_OFFSET] {
-        let f = format::YYYYMMDDHHMM.to_owned() + fmt;
-        if let Ok(parsed) = DateTime::parse_from_str(&ts, &f) {
-            return Ok(parsed);
-        }
-    }
-
-    // Default parse and failure
-    s.as_ref()
-        .parse()
-        .map_err(|_| (ParseDurationError::InvalidInput))
-}
-
-// Convert NaiveDateTime to DateTime<FixedOffset> by assuming the offset
-// is local time
-fn naive_dt_to_fixed_offset(dt: NaiveDateTime) -> Result<DateTime<FixedOffset>, ()> {
-    let now = Local::now();
-    match now.offset().from_local_datetime(&dt) {
-        LocalResult::Single(dt) => Ok(dt),
-        _ => Err(()),
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    static TEST_TIME: i64 = 1613371067;
-
-    #[cfg(test)]
-    mod iso_8601 {
-        use std::env;
-
-        use crate::{
-            parse_datetime::from_str, parse_datetime::tests::TEST_TIME, ParseDurationError,
-        };
-
-        #[test]
-        fn test_t_sep() {
-            env::set_var("TZ", "UTC");
-            let dt = "2021-02-15T06:37:47";
-            let actual = from_str(dt);
-            assert_eq!(actual.unwrap().timestamp(), TEST_TIME);
-        }
-
-        #[test]
-        fn test_space_sep() {
-            env::set_var("TZ", "UTC");
-            let dt = "2021-02-15 06:37:47";
-            let actual = from_str(dt);
-            assert_eq!(actual.unwrap().timestamp(), TEST_TIME);
-        }
-
-        #[test]
-        fn test_space_sep_offset() {
-            env::set_var("TZ", "UTC");
-            let dt = "2021-02-14 22:37:47 -0800";
-            let actual = from_str(dt);
-            assert_eq!(actual.unwrap().timestamp(), TEST_TIME);
-        }
-
-        #[test]
-        fn test_t_sep_offset() {
-            env::set_var("TZ", "UTC");
-            let dt = "2021-02-14T22:37:47 -0800";
-            let actual = from_str(dt);
-            assert_eq!(actual.unwrap().timestamp(), TEST_TIME);
-        }
-
-        #[test]
-        fn invalid_formats() {
-            let invalid_dts = vec!["NotADate", "202104", "202104-12T22:37:47"];
-            for dt in invalid_dts {
-                assert_eq!(from_str(dt), Err(ParseDurationError::InvalidInput));
-            }
-        }
-
-        #[test]
-        fn test_epoch_seconds() {
-            env::set_var("TZ", "UTC");
-            let dt = "@1613371067";
-            let actual = from_str(dt);
-            assert_eq!(actual.unwrap().timestamp(), TEST_TIME);
-        }
-    }
-
-    #[cfg(test)]
-    mod offsets {
-        use chrono::Local;
-
-        use crate::{parse_datetime::from_str, ParseDurationError};
-
-        #[test]
-        fn test_positive_offsets() {
-            let offsets = vec![
-                "UTC+07:00",
-                "UTC+0700",
-                "UTC+07",
-                "Z+07:00",
-                "Z+0700",
-                "Z+07",
-            ];
-
-            let expected = format!("{}{}", Local::now().format("%Y%m%d"), "0000+0700");
-            for offset in offsets {
-                let actual = from_str(offset).unwrap();
-                assert_eq!(expected, format!("{}", actual.format("%Y%m%d%H%M%z")));
-            }
-        }
-
-        #[test]
-        fn test_partial_offset() {
-            let offsets = vec!["UTC+00:15", "UTC+0015", "Z+00:15", "Z+0015"];
-            let expected = format!("{}{}", Local::now().format("%Y%m%d"), "0000+0015");
-            for offset in offsets {
-                let actual = from_str(offset).unwrap();
-                assert_eq!(expected, format!("{}", actual.format("%Y%m%d%H%M%z")));
-            }
-        }
-
-        #[test]
-        fn invalid_offset_format() {
-            let invalid_offsets = vec!["+0700", "UTC+2", "Z-1", "UTC+01005"];
-            for offset in invalid_offsets {
-                assert_eq!(from_str(offset), Err(ParseDurationError::InvalidInput));
-            }
-        }
-    }
-
-    #[cfg(test)]
-    mod timestamp {
-        use crate::parse_datetime::from_str;
-        use chrono::{TimeZone, Utc};
-
-        #[test]
-        fn test_positive_offsets() {
-            let offsets: Vec<i64> = vec![
-                0, 1, 2, 10, 100, 150, 2000, 1234400000, 1334400000, 1692582913, 2092582910,
-            ];
-
-            for offset in offsets {
-                let time = Utc.timestamp(offset, 0);
-                let dt = from_str(format!("@{}", offset));
-                assert_eq!(dt.unwrap(), time);
-            }
-        }
-    }
-
-    /// Used to test example code presented in the README.
-    mod readme_test {
-        use crate::parse_datetime::from_str;
-        use chrono::{Local, TimeZone};
-
-        #[test]
-        fn test_readme_code() {
-            let dt = from_str("2021-02-14 06:37:47");
-            assert_eq!(
-                dt.unwrap(),
-                Local.with_ymd_and_hms(2021, 2, 14, 6, 37, 47).unwrap()
-            );
-        }
-    }
-}
diff --git a/tests/simple.rs b/tests/simple.rs
index a538f9d..e69de29 100644
--- a/tests/simple.rs
+++ b/tests/simple.rs
@@ -1,148 +0,0 @@
-use chrono::{Duration, Utc};
-use parse_datetime::{from_str, from_str_at_date, ParseDurationError};
-
-#[test]
-fn test_invalid_input() {
-    let result = from_str("foobar");
-    println!("{result:?}");
-    assert_eq!(result, Err(ParseDurationError::InvalidInput));
-
-    let result = from_str("invalid 1");
-    assert_eq!(result, Err(ParseDurationError::InvalidInput));
-}
-
-#[test]
-fn test_duration_parsing() {
-    assert_eq!(from_str("1 year").unwrap(), Duration::seconds(31_536_000));
-    assert_eq!(
-        from_str("-2 years").unwrap(),
-        Duration::seconds(-63_072_000)
-    );
-    assert_eq!(
-        from_str("2 years ago").unwrap(),
-        Duration::seconds(-63_072_000)
-    );
-    assert_eq!(from_str("year").unwrap(), Duration::seconds(31_536_000));
-
-    assert_eq!(from_str("1 month").unwrap(), Duration::seconds(2_592_000));
-    assert_eq!(
-        from_str("1 month and 2 weeks").unwrap(),
-        Duration::seconds(3_801_600)
-    );
-    assert_eq!(
-        from_str("1 month, 2 weeks").unwrap(),
-        Duration::seconds(3_801_600)
-    );
-    assert_eq!(
-        from_str("1 months 2 weeks").unwrap(),
-        Duration::seconds(3_801_600)
-    );
-    assert_eq!(
-        from_str("1 month and 2 weeks ago").unwrap(),
-        Duration::seconds(-3_801_600)
-    );
-    assert_eq!(from_str("2 months").unwrap(), Duration::seconds(5_184_000));
-    assert_eq!(from_str("month").unwrap(), Duration::seconds(2_592_000));
-
-    assert_eq!(
-        from_str("1 fortnight").unwrap(),
-        Duration::seconds(1_209_600)
-    );
-    assert_eq!(
-        from_str("3 fortnights").unwrap(),
-        Duration::seconds(3_628_800)
-    );
-    assert_eq!(from_str("fortnight").unwrap(), Duration::seconds(1_209_600));
-
-    assert_eq!(from_str("1 week").unwrap(), Duration::seconds(604_800));
-    assert_eq!(
-        from_str("1 week 3 days").unwrap(),
-        Duration::seconds(864_000)
-    );
-    assert_eq!(
-        from_str("1 week 3 days ago").unwrap(),
-        Duration::seconds(-864_000)
-    );
-    assert_eq!(from_str("-2 weeks").unwrap(), Duration::seconds(-1_209_600));
-    assert_eq!(
-        from_str("2 weeks ago").unwrap(),
-        Duration::seconds(-1_209_600)
-    );
-    assert_eq!(from_str("week").unwrap(), Duration::seconds(604_800));
-
-    assert_eq!(from_str("1 day").unwrap(), Duration::seconds(86_400));
-    assert_eq!(from_str("2 days ago").unwrap(), Duration::seconds(-172_800));
-    assert_eq!(from_str("-2 days").unwrap(), Duration::seconds(-172_800));
-    assert_eq!(from_str("day").unwrap(), Duration::seconds(86_400));
-
-    assert_eq!(from_str("1 hour").unwrap(), Duration::seconds(3_600));
-    assert_eq!(from_str("1 h").unwrap(), Duration::seconds(3_600));
-    assert_eq!(from_str("1 hour ago").unwrap(), Duration::seconds(-3_600));
-    assert_eq!(from_str("-2 hours").unwrap(), Duration::seconds(-7_200));
-    assert_eq!(from_str("hour").unwrap(), Duration::seconds(3_600));
-
-    assert_eq!(from_str("1 minute").unwrap(), Duration::seconds(60));
-    assert_eq!(from_str("1 min").unwrap(), Duration::seconds(60));
-    assert_eq!(from_str("2 minutes").unwrap(), Duration::seconds(120));
-    assert_eq!(from_str("2 mins").unwrap(), Duration::seconds(120));
-    assert_eq!(from_str("2m").unwrap(), Duration::seconds(120));
-    assert_eq!(from_str("min").unwrap(), Duration::seconds(60));
-
-    assert_eq!(from_str("1 second").unwrap(), Duration::seconds(1));
-    assert_eq!(from_str("1 s").unwrap(), Duration::seconds(1));
-    assert_eq!(from_str("2 seconds").unwrap(), Duration::seconds(2));
-    assert_eq!(from_str("2 secs").unwrap(), Duration::seconds(2));
-    assert_eq!(from_str("2 sec").unwrap(), Duration::seconds(2));
-    assert_eq!(from_str("sec").unwrap(), Duration::seconds(1));
-
-    assert_eq!(from_str("now").unwrap(), Duration::seconds(0));
-    assert_eq!(from_str("today").unwrap(), Duration::seconds(0));
-
-    assert_eq!(
-        from_str("1 year 2 months 4 weeks 3 days and 2 seconds").unwrap(),
-        Duration::seconds(39_398_402)
-    );
-    assert_eq!(
-        from_str("1 year 2 months 4 weeks 3 days and 2 seconds ago").unwrap(),
-        Duration::seconds(-39_398_402)
-    );
-}
-
-#[test]
-#[should_panic]
-fn test_display_parse_duration_error_through_from_str() {
-    let invalid_input = "9223372036854775807 seconds and 1 second";
-    let _ = from_str(invalid_input).unwrap();
-}
-
-#[test]
-fn test_display_should_fail() {
-    let invalid_input = "Thu Jan 01 12:34:00 2015";
-    let error = from_str(invalid_input).unwrap_err();
-
-    assert_eq!(
-        format!("{error}"),
-        "Invalid input string: cannot be parsed as a relative time"
-    );
-}
-
-#[test]
-fn test_from_str_at_date_day() {
-    let today = Utc::now().date_naive();
-    let yesterday = today - Duration::days(1);
-    assert_eq!(
-        from_str_at_date(yesterday, "2 days").unwrap(),
-        Duration::days(1)
-    );
-}
-
-#[test]
-fn test_invalid_input_at_date() {
-    let today = Utc::now().date_naive();
-    let result = from_str_at_date(today, "foobar");
-    println!("{result:?}");
-    assert_eq!(result, Err(ParseDurationError::InvalidInput));
-
-    let result = from_str_at_date(today, "invalid 1r");
-    assert_eq!(result, Err(ParseDurationError::InvalidInput));
-}

From 299952166baeda7ed7fb27918ce48f98facd247c Mon Sep 17 00:00:00 2001
From: Terts Diepraam <terts.diepraam@gmail.com>
Date: Fri, 26 Jan 2024 21:51:01 +0100
Subject: [PATCH 02/15] start parsing date with winnow

---
 Cargo.lock        |  49 ++--------
 Cargo.toml        |   2 +-
 src/items/date.rs | 228 ++++++++++++++++++++++++++++++++++++++++++++++
 src/items/mod.rs  |  57 ++++++++++++
 src/lib.rs        |  22 +++--
 5 files changed, 311 insertions(+), 47 deletions(-)
 create mode 100644 src/items/date.rs
 create mode 100644 src/items/mod.rs

diff --git a/Cargo.lock b/Cargo.lock
index 0d099a3..085c66f 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2,15 +2,6 @@
 # It is not intended for manual editing.
 version = 3
 
-[[package]]
-name = "aho-corasick"
-version = "1.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "67fc08ce920c31afb70f013dcce1bfc3a3195de6a228474e45e1f145b36f8d04"
-dependencies = [
- "memchr",
-]
-
 [[package]]
 name = "android-tzdata"
 version = "0.1.1"
@@ -138,7 +129,7 @@ name = "parse_datetime"
 version = "0.4.0"
 dependencies = [
  "chrono",
- "regex",
+ "winnow",
 ]
 
 [[package]]
@@ -159,35 +150,6 @@ dependencies = [
  "proc-macro2",
 ]
 
-[[package]]
-name = "regex"
-version = "1.9.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b2eae68fc220f7cf2532e4494aded17545fce192d59cd996e0fe7887f4ceb575"
-dependencies = [
- "aho-corasick",
- "memchr",
- "regex-automata",
- "regex-syntax",
-]
-
-[[package]]
-name = "regex-automata"
-version = "0.3.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e9aaecc05d5c4b5f7da074b9a0d1a0867e71fd36e7fc0482d8bcfe8e8fc56290"
-dependencies = [
- "aho-corasick",
- "memchr",
- "regex-syntax",
-]
-
-[[package]]
-name = "regex-syntax"
-version = "0.7.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2ab07dc67230e4a4718e70fd5c20055a4334b121f1f9db8fe63ef39ce9b8c846"
-
 [[package]]
 name = "syn"
 version = "2.0.18"
@@ -346,3 +308,12 @@ name = "windows_x86_64_msvc"
 version = "0.48.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1a515f5799fe4961cb532f983ce2b23082366b898e52ffbce459c86f67c8378a"
+
+[[package]]
+name = "winnow"
+version = "0.5.34"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b7cf47b659b318dccbd69cc4797a39ae128f533dce7902a1096044d1967b9c16"
+dependencies = [
+ "memchr",
+]
diff --git a/Cargo.toml b/Cargo.toml
index 23f5f4f..c9c14e1 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -8,5 +8,5 @@ repository = "https://github.com/uutils/parse_datetime"
 readme = "README.md"
 
 [dependencies]
-regex = "1.9"
 chrono = { version="0.4", default-features=false, features=["std", "alloc", "clock"] }
+winnow = "0.5.34"
diff --git a/src/items/date.rs b/src/items/date.rs
new file mode 100644
index 0000000..12fe924
--- /dev/null
+++ b/src/items/date.rs
@@ -0,0 +1,228 @@
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+
+// spell-checker:ignore multispace
+
+//! 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, multispace0},
+    combinator::{alt, opt, preceded},
+    seq,
+    token::take,
+    PResult, Parser,
+};
+
+use crate::ParseDateTimeError;
+
+#[derive(PartialEq, Eq, Debug)]
+pub struct Date {
+    day: u32,
+    month: u32,
+    year: Option<u32>,
+}
+
+pub fn parse(input: &mut &str) -> PResult<Date> {
+    alt((iso, us, literal1, literal2)).parse_next(input)
+}
+
+/// Parse `YYYY-MM-DD` or `YY-MM-DD`
+fn iso(input: &mut &str) -> PResult<Date> {
+    seq!(Date {
+        year: year.map(Some),
+        _: (multispace0, '-', multispace0),
+        month: month,
+        _: (multispace0, '-', multispace0),
+        day: day,
+    })
+    .parse_next(input)
+}
+
+/// Parse `MM/DD/YYYY`, `MM/DD/YY` or `MM/DD`
+fn us(input: &mut &str) -> PResult<Date> {
+    seq!(Date {
+        month: month,
+        _: (multispace0, '/', multispace0),
+        day: day,
+        year: opt(preceded((multispace0, '/', multispace0), 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<Date> {
+    seq!(Date {
+        day: day,
+        _: (multispace0, opt('-'), multispace0),
+        month: literal_month,
+        year: opt(preceded((multispace0, opt('-'), multispace0), year)),
+    })
+    .parse_next(input)
+}
+
+/// Parse `November 14, 2022` and `Nov 14, 2022`
+fn literal2(input: &mut &str) -> PResult<Date> {
+    seq!(Date {
+        month: literal_month,
+        _: multispace0,
+        day: day,
+        // FIXME: GNU requires _some_ space between the day and the year,
+        // probably to distinguish with floats.
+        year: opt(preceded((multispace0, ",", multispace0), year)),
+    })
+    .parse_next(input)
+}
+
+fn year(input: &mut &str) -> PResult<u32> {
+    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<u32> {
+    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<u32> {
+    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<u32> {
+    alpha1
+        .try_map(|s: &str| {
+            let s = s.to_ascii_lowercase();
+            let month = match s.as_ref() {
+                "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 Err(ParseDateTimeError::InvalidInput),
+            };
+            Ok(month)
+        })
+        .parse_next(input)
+}
+
+#[cfg(test)]
+mod test {
+    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",
+            "11/14/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",
+            "NoVeMbEr 14, 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",
+            "November 14",
+            "Nov 14",
+            "14-nov",
+            "14nov",
+        ] {
+            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..c6d780d
--- /dev/null
+++ b/src/items/mod.rs
@@ -0,0 +1,57 @@
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+
+// spell-checker:ignore chrono
+
+//! 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]
+
+use chrono::{NaiveDateTime, NaiveTime, Weekday};
+use winnow::{combinator::alt, PResult, Parser};
+mod date;
+
+pub enum Item {
+    Date(date::Date),
+    TimeOfDay(NaiveTime),
+    _TimeZone,
+    Combined(NaiveDateTime),
+    Weekday(Weekday),
+    _Relative,
+    _PureNumber,
+}
+
+pub fn parse(input: &mut &str) -> PResult<Item> {
+    alt((date::parse.map(Item::Date),)).parse_next(input)
+}
+
+mod time {}
+
+mod time_zone {}
+
+mod combined {}
+
+mod weekday {}
+
+mod relative {}
+
+mod number {}
diff --git a/src/lib.rs b/src/lib.rs
index ea6e6d5..4ff0a91 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1,20 +1,25 @@
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
 
+// spell-checker:ignore datetime
+
 use std::error::Error;
 use std::fmt::{self, Display};
 
-use chrono::{DateTime, FixedOffset};
+use items::Item;
+use winnow::Parser;
+
+mod items;
 
 #[derive(Debug, PartialEq)]
-pub enum ParseDurationError {
+pub enum ParseDateTimeError {
     InvalidInput,
 }
 
-impl Display for ParseDurationError {
+impl Display for ParseDateTimeError {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
-            ParseDurationError::InvalidInput => {
+            ParseDateTimeError::InvalidInput => {
                 write!(
                     f,
                     "Invalid input string: cannot be parsed as a relative time"
@@ -24,8 +29,11 @@ impl Display for ParseDurationError {
     }
 }
 
-impl Error for ParseDurationError {}
+impl Error for ParseDateTimeError {}
 
-fn parse_datetime(s: &str) -> Result<DateTime<FixedOffset>, ParseDurationError> {
-    todo!()
+pub fn parse_datetime(mut input: &str) -> Result<Item, ParseDateTimeError> {
+    match items::parse.parse_next(&mut input) {
+        Ok(x) => Ok(x),
+        Err(_) => Err(ParseDateTimeError::InvalidInput),
+    }
 }

From 176516e410e84da32f1954d982567a53ce5d2e98 Mon Sep 17 00:00:00 2001
From: Terts Diepraam <terts.diepraam@gmail.com>
Date: Sat, 27 Jan 2024 00:33:04 +0100
Subject: [PATCH 03/15] start parsing time with winnow

---
 src/items/mod.rs  |  29 +++-
 src/items/time.rs | 386 ++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 408 insertions(+), 7 deletions(-)
 create mode 100644 src/items/time.rs

diff --git a/src/items/mod.rs b/src/items/mod.rs
index c6d780d..f262f1d 100644
--- a/src/items/mod.rs
+++ b/src/items/mod.rs
@@ -1,7 +1,7 @@
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
 
-// spell-checker:ignore chrono
+// spell-checker:ignore chrono multispace0
 
 //! From the GNU docs:
 //!
@@ -26,13 +26,20 @@
 //!  - [`relative`]
 //!  - [`number]
 
-use chrono::{NaiveDateTime, NaiveTime, Weekday};
-use winnow::{combinator::alt, PResult, Parser};
+use chrono::{NaiveDateTime, Weekday};
+use winnow::{
+    ascii::multispace0,
+    combinator::{alt, preceded},
+    error::ParserError,
+    stream::{AsChar, Stream, StreamIsPartial},
+    PResult, Parser,
+};
 mod date;
+mod time;
 
 pub enum Item {
     Date(date::Date),
-    TimeOfDay(NaiveTime),
+    Time(time::Time),
     _TimeZone,
     Combined(NaiveDateTime),
     Weekday(Weekday),
@@ -40,11 +47,19 @@ pub enum Item {
     _PureNumber,
 }
 
-pub fn parse(input: &mut &str) -> PResult<Item> {
-    alt((date::parse.map(Item::Date),)).parse_next(input)
+/// Allow spaces after a parser
+fn s<I, O, E>(p: impl Parser<I, O, E>) -> impl Parser<I, O, E>
+where
+    I: StreamIsPartial + Stream,
+    <I as Stream>::Token: AsChar + Clone,
+    E: ParserError<I>,
+{
+    preceded(multispace0, p)
 }
 
-mod time {}
+pub fn parse(input: &mut &str) -> PResult<Item> {
+    alt((date::parse.map(Item::Date), time::parse.map(Item::Time))).parse_next(input)
+}
 
 mod time_zone {}
 
diff --git a/src/items/time.rs b/src/items/time.rs
new file mode 100644
index 0000000..49ad76c
--- /dev/null
+++ b/src/items/time.rs
@@ -0,0 +1,386 @@
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+
+// spell-checker:ignore multispace Caseless 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, Caseless},
+    combinator::{alt, opt, preceded},
+    seq,
+    stream::AsChar,
+    token::take_while,
+    PResult, Parser,
+};
+
+use super::s;
+
+#[derive(PartialEq, Debug)]
+pub struct Time {
+    hour: i32,
+    minute: i32,
+    second: f64,
+    offset: Option<Offset>,
+}
+
+#[derive(PartialEq, Debug, Clone)]
+pub struct Offset {
+    negative: bool,
+    hours: u32,
+    minutes: u32,
+}
+
+#[derive(Clone)]
+enum Suffix {
+    Am,
+    Pm,
+    TimeZone(Offset),
+}
+
+pub fn parse(input: &mut &str) -> PResult<Time> {
+    // Hour followed by suffix is a special case where minutes are optional
+    alt((
+        (hour, suffix).map(|(h, s)| (h, 0, 0.0, Some(s))),
+        seq!(
+            hour,
+            _: colon,
+            minute,
+            opt(preceded(colon, second)).map(|s| s.unwrap_or(0.0)),
+            opt(suffix)
+        ),
+    ))
+    .verify_map(|(mut hour, minute, second, suffix)| {
+        let mut offset = None;
+        match suffix {
+            None => {}
+            // 12am should be noon
+            Some(Suffix::Am) => {
+                // With an AM/PM suffix 
+                if hour > 12 {
+                    return None;
+                }
+                if hour == 12 {
+                    hour = 0;
+                };
+            }
+            // 12pm should be noon
+            Some(Suffix::Pm) => {
+                if hour > 12 {
+                    return None;
+                } else if hour == 12 {
+                    hour = 12;
+                } else {
+                    hour += 12;
+                }
+            }
+            Some(Suffix::TimeZone(tz)) => offset = Some(tz),
+        };
+        Some(Time {
+            hour: hour as i32,
+            minute: minute as i32,
+            second,
+            offset,
+        })
+    })
+    .parse_next(input)
+}
+
+/// Parse a colon preceded by whitespace
+fn colon(input: &mut &str) -> PResult<()> {
+    s(':').void().parse_next(input)
+}
+
+/// Parse a number of hours (preceded by whitespace)
+fn hour(input: &mut &str) -> PResult<u32> {
+    s(dec_uint).verify(|x| *x < 24).parse_next(input)
+}
+
+/// Parse a number of minutes (preceded by whitespace)
+fn minute(input: &mut &str) -> PResult<u32> {
+    s(dec_uint).verify(|x| *x < 60).parse_next(input)
+}
+
+/// Parse a number of seconds (preceded by whitespace)
+fn second(input: &mut &str) -> PResult<f64> {
+    s(float).verify(|x| *x < 60.0).parse_next(input)
+}
+
+/// Parse a suffix of am, pm or an offset (preceded by whitespace)
+fn suffix(input: &mut &str) -> PResult<Suffix> {
+    alt((
+        s(Caseless("am")).value(Suffix::Am),
+        s(Caseless("a.m.")).value(Suffix::Am),
+        s(Caseless("pm")).value(Suffix::Pm),
+        s(Caseless("p.m.")).value(Suffix::Pm),
+        timezone.map(Suffix::TimeZone),
+    ))
+    .parse_next(input)
+}
+
+/// Parse a timezone starting with `+` or `-`
+fn timezone(input: &mut &str) -> PResult<Offset> {
+    seq!(plus_or_minus, alt((timezone_colon, timezone_colonless)))
+        .map(|(negative, (hours, minutes))| Offset {
+            negative,
+            hours,
+            minutes,
+        })
+        .parse_next(input)
+}
+
+/// Parse a timezone offset with a colon separating hours and minutes
+fn timezone_colon(input: &mut &str) -> PResult<(u32, u32)> {
+    seq!(
+        // There's an edge case here: GNU allows the hours to be omitted
+        s(take_while(0..=2, AsChar::is_dec_digit)).try_map(|x: &str| {
+            // parse will fail on empty input
+            if x == "" {
+                Ok(0)
+            } else {
+                x.parse()
+            }
+        }),
+        _: colon,
+        s(take_while(1..=2, AsChar::is_dec_digit)).try_map(|x: &str| x.parse()),
+    )
+    .parse_next(input)
+}
+
+/// Parse a timezone offset without colon
+fn timezone_colonless(input: &mut &str) -> PResult<(u32, u32)> {
+    s(take_while(0..=4, AsChar::is_dec_digit))
+        .verify_map(|x: &str| {
+            Some(match x.len() {
+                0 => (0, 0),
+                1 | 2 => (x.parse().ok()?, 0),
+                // The minutes are the last two characters here, for some reason.
+                3 => (x[..1].parse().ok()?, x[1..].parse().ok()?),
+                4 => (x[..2].parse().ok()?, x[2..].parse().ok()?),
+                _ => unreachable!("We only take up to 4 characters"),
+            })
+        })
+        .parse_next(input)
+}
+
+/// Parse the plus or minus character and return whether it was negative
+fn plus_or_minus(input: &mut &str) -> PResult<bool> {
+    s(alt(("+".value(false), "-".value(true)))).parse_next(input)
+}
+
+#[cfg(test)]
+mod test {
+    use super::{Offset, Time};
+    use crate::items::time::parse;
+
+    #[test]
+    fn simple() {
+        let reference = Time {
+            hour: 20,
+            minute: 2,
+            second: 0.0,
+            offset: None,
+        };
+
+        for mut s in [
+            "20:02:00.000000",
+            "20:02:00",
+            "20   :    02  :   00.000000",
+            "20:02",
+            "20  :   02",
+            "8:02pm",
+            "8:02PM",
+            "8:   02     pm",
+            "8:02P.M.",
+            "8:   02     p.m.",
+        ] {
+            let old_s = s.to_owned();
+            assert_eq!(parse(&mut s).unwrap(), reference, "Format string: {old_s}");
+        }
+    }
+
+    #[test]
+    fn hours_only() {
+        let reference = Time {
+            hour: 11,
+            minute: 0,
+            second: 0.0,
+            offset: None,
+        };
+
+        for mut s in ["11am", "11 am", "11AM", "11 AM", "11 A.M.", "11   :  00", "11:00:00"] {
+            let old_s = s.to_owned();
+            assert_eq!(parse(&mut s).unwrap(), reference, "Format string: {old_s}");
+        }
+    }
+
+    #[test]
+    fn noon() {
+        let reference = Time {
+            hour: 12,
+            minute: 0,
+            second: 0.0,
+            offset: None,
+        };
+
+        for mut s in ["12:00", "12pm", "12 pm", "12PM", "12 PM", "12 P.M."] {
+            let old_s = s.to_owned();
+            assert_eq!(parse(&mut s).unwrap(), reference, "Format string: {old_s}");
+        }
+    }
+
+    #[test]
+    fn midnight() {
+        let reference = Time {
+            hour: 0,
+            minute: 0,
+            second: 0.0,
+            offset: None,
+        };
+
+        for mut s in ["00:00", "12am"] {
+            let old_s = s.to_owned();
+            assert_eq!(parse(&mut s).unwrap(), reference, "Format string: {old_s}");
+        }
+    }
+
+    #[test]
+    fn offset_hours() {
+        let reference = Time {
+            hour: 1,
+            minute: 23,
+            second: 0.0,
+            offset: Some(Offset {
+                negative: false,
+                hours: 5,
+                minutes: 0,
+            }),
+        };
+
+        for mut s in [
+            "1:23+5",
+            "1:23 + 5",
+            "1:23+05",
+            "1:23 + 5 : 00",
+            "1:23+05:00",
+            "1:23+05:0",
+        ] {
+            let old_s = s.to_owned();
+            assert_eq!(parse(&mut s).unwrap(), reference, "Format string: {old_s}");
+        }
+    }
+
+    #[test]
+    fn offset_hours_and_minutes() {
+        let reference = Time {
+            hour: 3,
+            minute: 45,
+            second: 0.0,
+            offset: Some(Offset {
+                negative: false,
+                hours: 5,
+                minutes: 35,
+            }),
+        };
+
+        for mut s in [
+            "3:45+535",
+            "03:45+535",
+            "3   :  45  +  535",
+            "3:45+0535",
+            "3:45+5:35",
+            "3:45+05:35",
+            "3:45  + 05 : 35",
+        ] {
+            let old_s = s.to_owned();
+            assert_eq!(parse(&mut s).unwrap(), reference, "Format string: {old_s}");
+        }
+    }
+
+    #[test]
+    fn offset_minutes() {
+        let reference = Time {
+            hour: 3,
+            minute: 45,
+            second: 0.0,
+            offset: Some(Offset {
+                negative: false,
+                hours: 0,
+                minutes: 35,
+            }),
+        };
+
+        for mut s in [
+            "3:45+035",
+            "03:45+035",
+            "3   :  45  +  035",
+            "3:45+0035",
+            "3:45+0:35",
+            "3:45+00:35",
+            "3:45+:35",
+            "3:45  + 00 : 35",
+        ] {
+            let old_s = s.to_owned();
+            assert_eq!(parse(&mut s).unwrap(), reference, "Format string: {old_s}");
+        }
+    }
+
+    #[test]
+    fn offset_negative() {
+        let reference = Time {
+            hour: 3,
+            minute: 45,
+            second: 0.0,
+            offset: Some(Offset {
+                negative: true,
+                hours: 5,
+                minutes: 35,
+            }),
+        };
+
+        for mut s in [
+            "3:45-535",
+            "03:45-535",
+            "3   :  45  -  535",
+            "3:45-0535",
+            "3:45-5:35",
+            "3:45-05:35",
+            "3:45  - 05 : 35",
+        ] {
+            let old_s = s.to_owned();
+            assert_eq!(parse(&mut s).unwrap(), reference, "Format string: {old_s}");
+        }
+    }
+}

From b59d34d4572be403f278a712756769f22c149b02 Mon Sep 17 00:00:00 2001
From: Terts Diepraam <terts.diepraam@gmail.com>
Date: Sat, 27 Jan 2024 12:45:32 +0100
Subject: [PATCH 04/15] implement weekday parsing with Winnow

---
 src/items/mod.rs       |  24 +++-----
 src/items/time_zone.rs |  23 +++++++
 src/items/weekday.rs   | 134 +++++++++++++++++++++++++++++++++++++++++
 3 files changed, 167 insertions(+), 14 deletions(-)
 create mode 100644 src/items/time_zone.rs
 create mode 100644 src/items/weekday.rs

diff --git a/src/items/mod.rs b/src/items/mod.rs
index f262f1d..f5688f1 100644
--- a/src/items/mod.rs
+++ b/src/items/mod.rs
@@ -26,7 +26,15 @@
 //!  - [`relative`]
 //!  - [`number]
 
-use chrono::{NaiveDateTime, Weekday};
+mod date;
+mod time;
+mod time_zone;
+mod weekday;
+mod combined {}
+mod relative {}
+mod number {}
+
+use chrono::NaiveDateTime;
 use winnow::{
     ascii::multispace0,
     combinator::{alt, preceded},
@@ -34,15 +42,13 @@ use winnow::{
     stream::{AsChar, Stream, StreamIsPartial},
     PResult, Parser,
 };
-mod date;
-mod time;
 
 pub enum Item {
     Date(date::Date),
     Time(time::Time),
     _TimeZone,
     Combined(NaiveDateTime),
-    Weekday(Weekday),
+    Weekday(weekday::Weekday),
     _Relative,
     _PureNumber,
 }
@@ -60,13 +66,3 @@ where
 pub fn parse(input: &mut &str) -> PResult<Item> {
     alt((date::parse.map(Item::Date), time::parse.map(Item::Time))).parse_next(input)
 }
-
-mod time_zone {}
-
-mod combined {}
-
-mod weekday {}
-
-mod relative {}
-
-mod number {}
diff --git a/src/items/time_zone.rs b/src/items/time_zone.rs
new file mode 100644
index 0000000..a3b2c22
--- /dev/null
+++ b/src/items/time_zone.rs
@@ -0,0 +1,23 @@
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+
+// spell-checker:ignore multispace
+
+//! Parse a time zone items
+//!
+//! The GNU docs state:
+//!
+//! > Normally, dates are interpreted using the rules of the current time zone,
+//! > which in turn are specified by the TZ environment variable, or by a
+//! > system default if TZ is not set. To specify a different set of default
+//! > time zone rules that apply just to one date, start the date with a string
+//! > of the form ‘TZ="rule"’. The two quote characters (‘"’) must be present
+//! > in the date, and any quotes or backslashes within rule must be escaped by
+//! > a backslash.
+//!
+
+use winnow::PResult;
+
+pub fn parse(_input: &mut &str) -> PResult<()> {
+    todo!()
+}
diff --git a/src/items/weekday.rs b/src/items/weekday.rs
new file mode 100644
index 0000000..692e6cf
--- /dev/null
+++ b/src/items/weekday.rs
@@ -0,0 +1,134 @@
+//! The GNU docs state:
+//!
+//! > The explicit mention of a day of the week will forward the date (only if
+//! > necessary) to reach that day of the week in the future.
+//! >
+//! > Days of the week may be spelled out in full: ‘Sunday’, ‘Monday’,
+//! > ‘Tuesday’, ‘Wednesday’, ‘Thursday’, ‘Friday’ or ‘Saturday’. Days may be
+//! > abbreviated to their first three letters, optionally followed by a
+//! > period. The special abbreviations ‘Tues’ for ‘Tuesday’, ‘Wednes’ for
+//! > ‘Wednesday’ and ‘Thur’ or ‘Thurs’ for ‘Thursday’ are also allowed.
+//! >
+//! > A number may precede a day of the week item to move forward supplementary
+//! > weeks. It is best used in expression like ‘third monday’. In this
+//! > context, ‘last day’ or ‘next day’ is also acceptable; they move one week
+//! > before or after the day that day by itself would represent.
+//! >
+//! > A comma following a day of the week item is ignored.
+
+use winnow::{ascii::alpha1, combinator::opt, seq, PResult, Parser};
+
+use super::s;
+
+#[derive(PartialEq, Eq, Debug)]
+enum Day {
+    Monday,
+    Tuesday,
+    Wednesday,
+    Thursday,
+    Friday,
+    Saturday,
+    Sunday,
+}
+
+#[derive(PartialEq, Eq, Debug)]
+pub struct Weekday {
+    offset: i32,
+    day: Day,
+}
+
+pub fn parse(input: &mut &str) -> PResult<Weekday> {
+    seq!(Weekday {
+        offset: opt(offset).map(|o| o.unwrap_or_default()),
+        day: day,
+    })
+    .parse_next(input)
+}
+
+fn offset(input: &mut &str) -> PResult<i32> {
+    s(alpha1)
+        .verify_map(|s: &str| {
+            let s = s.to_ascii_lowercase();
+            Some(match s.as_ref() {
+                "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)
+}
+
+fn day(input: &mut &str) -> PResult<Day> {
+    s(alpha1)
+        .verify_map(|s: &str| {
+            let s = s.to_ascii_lowercase();
+            Some(match s.as_ref() {
+                "monday" | "mon" | "mon." => Day::Monday,
+                "tuesday" | "tue" | "tue." | "tues" => Day::Tuesday,
+                "wednesday" | "wed" | "wed." | "wednes" => Day::Wednesday,
+                "thursday" | "thu" | "thu." | "thur" | "thurs" => Day::Thursday,
+                "friday" | "fri" | "fri." => Day::Friday,
+                "saturday" | "sat" | "sat." => Day::Saturday,
+                "sunday" | "sun" | "sun." => Day::Sunday,
+                _ => return None,
+            })
+        })
+        .parse_next(input)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{parse, Day, Weekday};
+
+    #[test]
+    fn this_monday() {
+        for mut s in ["monday", "mon", "mon.", "this monday", "this mon", "this mon.", "this    monday"] {
+            assert_eq!(
+                parse(&mut s).unwrap(),
+                Weekday {
+                    offset: 0,
+                    day: Day::Monday,
+                }
+            );
+        }
+    }
+
+    #[test]
+    fn next_tuesday() {
+        for s in ["tuesday", "tue", "tue.", "tues", "TUE"] {
+            let s = format!("next {s}");
+            assert_eq!(
+                parse(&mut s.as_ref()).unwrap(),
+                Weekday {
+                    offset: 1,
+                    day: Day::Tuesday,
+                }
+            );
+        }
+    }
+
+    #[test]
+    fn last_wednesday() {
+        for s in ["wednesday", "wed", "wed.", "wednesday", "WED"] {
+            let s = format!("last {s}");
+            assert_eq!(
+                parse(&mut s.as_ref()).unwrap(),
+                Weekday {
+                    offset: -1,
+                    day: Day::Wednesday,
+                }
+            );
+        }
+    }
+}

From c154edd6b86a9a1fadeb6d045e934410e99afd16 Mon Sep 17 00:00:00 2001
From: Terts Diepraam <terts.diepraam@gmail.com>
Date: Sat, 27 Jan 2024 14:11:02 +0100
Subject: [PATCH 05/15] implement parsing comments

---
 src/items/date.rs      | 37 +++++++++++++-----------
 src/items/mod.rs       | 65 +++++++++++++++++++++++++++++++-----------
 src/items/relative.rs  |  8 ++++++
 src/items/time.rs      | 27 +++++++++++++++---
 src/items/time_zone.rs |  2 --
 src/items/weekday.rs   |  3 ++
 6 files changed, 103 insertions(+), 39 deletions(-)
 create mode 100644 src/items/relative.rs

diff --git a/src/items/date.rs b/src/items/date.rs
index 12fe924..f93db8d 100644
--- a/src/items/date.rs
+++ b/src/items/date.rs
@@ -1,10 +1,8 @@
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
 
-// spell-checker:ignore multispace
-
 //! Parse a date item (without time component)
-//! 
+//!
 //! The GNU docs say:
 //!
 //! > A calendar date item specifies a day of the year. It is specified
@@ -29,13 +27,14 @@
 //! > ‘September’.
 
 use winnow::{
-    ascii::{alpha1, dec_uint, multispace0},
+    ascii::{alpha1, dec_uint},
     combinator::{alt, opt, preceded},
     seq,
     token::take,
     PResult, Parser,
 };
 
+use super::s;
 use crate::ParseDateTimeError;
 
 #[derive(PartialEq, Eq, Debug)]
@@ -53,9 +52,9 @@ pub fn parse(input: &mut &str) -> PResult<Date> {
 fn iso(input: &mut &str) -> PResult<Date> {
     seq!(Date {
         year: year.map(Some),
-        _: (multispace0, '-', multispace0),
+        _: s('-'),
         month: month,
-        _: (multispace0, '-', multispace0),
+        _: s('-'),
         day: day,
     })
     .parse_next(input)
@@ -65,9 +64,9 @@ fn iso(input: &mut &str) -> PResult<Date> {
 fn us(input: &mut &str) -> PResult<Date> {
     seq!(Date {
         month: month,
-        _: (multispace0, '/', multispace0),
+        _: s('/'),
         day: day,
-        year: opt(preceded((multispace0, '/', multispace0), year)),
+        year: opt(preceded(s('/'), year)),
     })
     .parse_next(input)
 }
@@ -76,9 +75,9 @@ fn us(input: &mut &str) -> PResult<Date> {
 fn literal1(input: &mut &str) -> PResult<Date> {
     seq!(Date {
         day: day,
-        _: (multispace0, opt('-'), multispace0),
+        _: opt(s('-')),
         month: literal_month,
-        year: opt(preceded((multispace0, opt('-'), multispace0), year)),
+        year: opt(preceded(opt(s('-')), year)),
     })
     .parse_next(input)
 }
@@ -87,17 +86,16 @@ fn literal1(input: &mut &str) -> PResult<Date> {
 fn literal2(input: &mut &str) -> PResult<Date> {
     seq!(Date {
         month: literal_month,
-        _: multispace0,
         day: day,
         // FIXME: GNU requires _some_ space between the day and the year,
         // probably to distinguish with floats.
-        year: opt(preceded((multispace0, ",", multispace0), year)),
+        year: opt(preceded(s(","), year)),
     })
     .parse_next(input)
 }
 
 fn year(input: &mut &str) -> PResult<u32> {
-    alt((
+    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(
@@ -109,12 +107,12 @@ fn year(input: &mut &str) -> PResult<u32> {
                 }
             },
         ),
-    ))
+    )))
     .parse_next(input)
 }
 
 fn month(input: &mut &str) -> PResult<u32> {
-    dec_uint
+    s(dec_uint)
         .try_map(|x| {
             (x >= 1 && x <= 12)
                 .then_some(x)
@@ -124,7 +122,7 @@ fn month(input: &mut &str) -> PResult<u32> {
 }
 
 fn day(input: &mut &str) -> PResult<u32> {
-    dec_uint
+    s(dec_uint)
         .try_map(|x| {
             (x >= 1 && x <= 31)
                 .then_some(x)
@@ -135,7 +133,7 @@ fn day(input: &mut &str) -> PResult<u32> {
 
 /// Parse the name of a month (case-insensitive)
 fn literal_month(input: &mut &str) -> PResult<u32> {
-    alpha1
+    s(alpha1)
         .try_map(|s: &str| {
             let s = s.to_ascii_lowercase();
             let month = match s.as_ref() {
@@ -188,7 +186,9 @@ mod test {
             "2022-11-14",
             "2022    -  11  -   14",
             "22-11-14",
+            "22(comment 1)-(comment 2)11(comment 3)-(comment 4)14",
             "11/14/2022",
+            "11(comment 1)/(comment 2)14(comment 3)/(comment 4)2022",
             "11   /  14   /      2022",
             "11/14/22",
             "14 November 2022",
@@ -217,10 +217,13 @@ mod test {
             "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
index f5688f1..5eef04c 100644
--- a/src/items/mod.rs
+++ b/src/items/mod.rs
@@ -1,7 +1,7 @@
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
 
-// spell-checker:ignore chrono multispace0
+// spell-checker:ignore multispace0
 
 //! From the GNU docs:
 //!
@@ -31,38 +31,71 @@ mod time;
 mod time_zone;
 mod weekday;
 mod combined {}
-mod relative {}
+mod relative;
 mod number {}
 
-use chrono::NaiveDateTime;
 use winnow::{
     ascii::multispace0,
-    combinator::{alt, preceded},
+    combinator::{alt, delimited, preceded, repeat, separated},
     error::ParserError,
-    stream::{AsChar, Stream, StreamIsPartial},
+    token::none_of,
     PResult, Parser,
 };
 
 pub enum Item {
     Date(date::Date),
     Time(time::Time),
-    _TimeZone,
-    Combined(NaiveDateTime),
     Weekday(weekday::Weekday),
-    _Relative,
-    _PureNumber,
+    Relative(()),
+    TimeZone(()),
 }
 
-/// Allow spaces after a parser
-fn s<I, O, E>(p: impl Parser<I, O, E>) -> impl Parser<I, O, E>
+/// 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
-    I: StreamIsPartial + Stream,
-    <I as Stream>::Token: AsChar + Clone,
-    E: ParserError<I>,
+    E: ParserError<&'a str>,
 {
-    preceded(multispace0, p)
+    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, comment).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(input: &mut &str) -> PResult<Item> {
-    alt((date::parse.map(Item::Date), time::parse.map(Item::Time))).parse_next(input)
+    alt((
+        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)
 }
diff --git a/src/items/relative.rs b/src/items/relative.rs
new file mode 100644
index 0000000..3c9a013
--- /dev/null
+++ b/src/items/relative.rs
@@ -0,0 +1,8 @@
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+
+use winnow::PResult;
+
+pub fn parse(_input: &mut &str) -> PResult<()> {
+    todo!()
+}
\ No newline at end of file
diff --git a/src/items/time.rs b/src/items/time.rs
index 49ad76c..a8ca247 100644
--- a/src/items/time.rs
+++ b/src/items/time.rs
@@ -1,7 +1,7 @@
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
 
-// spell-checker:ignore multispace Caseless shhmm colonless
+// spell-checker:ignore Caseless shhmm colonless
 
 //! Parse a time item (without a date)
 //!
@@ -88,7 +88,7 @@ pub fn parse(input: &mut &str) -> PResult<Time> {
             None => {}
             // 12am should be noon
             Some(Suffix::Am) => {
-                // With an AM/PM suffix 
+                // With an AM/PM suffix
                 if hour > 12 {
                     return None;
                 }
@@ -217,6 +217,9 @@ mod test {
         for mut s in [
             "20:02:00.000000",
             "20:02:00",
+            "20: (A comment!)   02 (Another comment!)  :00",
+            "20:02  (A nested (comment!))  :00",
+            "20:02  (So (many (nested) comments!!!!))  :00",
             "20   :    02  :   00.000000",
             "20:02",
             "20  :   02",
@@ -240,7 +243,15 @@ mod test {
             offset: None,
         };
 
-        for mut s in ["11am", "11 am", "11AM", "11 AM", "11 A.M.", "11   :  00", "11:00:00"] {
+        for mut s in [
+            "11am",
+            "11 am",
+            "11AM",
+            "11 AM",
+            "11 A.M.",
+            "11   :  00",
+            "11:00:00",
+        ] {
             let old_s = s.to_owned();
             assert_eq!(parse(&mut s).unwrap(), reference, "Format string: {old_s}");
         }
@@ -255,7 +266,15 @@ mod test {
             offset: None,
         };
 
-        for mut s in ["12:00", "12pm", "12 pm", "12PM", "12 PM", "12 P.M."] {
+        for mut s in [
+            "12:00",
+            "12pm",
+            "12 pm",
+            "12 (A comment!) pm",
+            "12PM",
+            "12 PM",
+            "12 P.M.",
+        ] {
             let old_s = s.to_owned();
             assert_eq!(parse(&mut s).unwrap(), reference, "Format string: {old_s}");
         }
diff --git a/src/items/time_zone.rs b/src/items/time_zone.rs
index a3b2c22..603d4fc 100644
--- a/src/items/time_zone.rs
+++ b/src/items/time_zone.rs
@@ -1,8 +1,6 @@
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
 
-// spell-checker:ignore multispace
-
 //! Parse a time zone items
 //!
 //! The GNU docs state:
diff --git a/src/items/weekday.rs b/src/items/weekday.rs
index 692e6cf..aafbc25 100644
--- a/src/items/weekday.rs
+++ b/src/items/weekday.rs
@@ -1,3 +1,6 @@
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+
 //! The GNU docs state:
 //!
 //! > The explicit mention of a day of the week will forward the date (only if

From e821d8acdc7a3d04690436f0bc26e1f23599fd2a Mon Sep 17 00:00:00 2001
From: Terts Diepraam <terts.diepraam@gmail.com>
Date: Sat, 27 Jan 2024 14:15:32 +0100
Subject: [PATCH 06/15] add "wednes" to spell checker

---
 src/items/weekday.rs | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/items/weekday.rs b/src/items/weekday.rs
index aafbc25..40a5f99 100644
--- a/src/items/weekday.rs
+++ b/src/items/weekday.rs
@@ -1,6 +1,8 @@
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
 
+// spell-checker:ignore wednes
+
 //! The GNU docs state:
 //!
 //! > The explicit mention of a day of the week will forward the date (only if

From e9c7eadd26e454cca992c1c2290cb8c5b521bc24 Mon Sep 17 00:00:00 2001
From: Terts Diepraam <terts.diepraam@gmail.com>
Date: Sat, 27 Jan 2024 14:16:25 +0100
Subject: [PATCH 07/15] cargo fmt

---
 src/items/relative.rs |  2 +-
 src/items/weekday.rs  | 10 +++++++++-
 tests/simple.rs       |  1 +
 3 files changed, 11 insertions(+), 2 deletions(-)

diff --git a/src/items/relative.rs b/src/items/relative.rs
index 3c9a013..35725dd 100644
--- a/src/items/relative.rs
+++ b/src/items/relative.rs
@@ -5,4 +5,4 @@ use winnow::PResult;
 
 pub fn parse(_input: &mut &str) -> PResult<()> {
     todo!()
-}
\ No newline at end of file
+}
diff --git a/src/items/weekday.rs b/src/items/weekday.rs
index 40a5f99..8eb5763 100644
--- a/src/items/weekday.rs
+++ b/src/items/weekday.rs
@@ -98,7 +98,15 @@ mod tests {
 
     #[test]
     fn this_monday() {
-        for mut s in ["monday", "mon", "mon.", "this monday", "this mon", "this mon.", "this    monday"] {
+        for mut s in [
+            "monday",
+            "mon",
+            "mon.",
+            "this monday",
+            "this mon",
+            "this mon.",
+            "this    monday",
+        ] {
             assert_eq!(
                 parse(&mut s).unwrap(),
                 Weekday {
diff --git a/tests/simple.rs b/tests/simple.rs
index e69de29..8b13789 100644
--- a/tests/simple.rs
+++ b/tests/simple.rs
@@ -0,0 +1 @@
+

From 2bd196383d2222a7c4addb7a05f525fafc260e36 Mon Sep 17 00:00:00 2001
From: Terts Diepraam <terts.diepraam@gmail.com>
Date: Sat, 27 Jan 2024 17:12:25 +0100
Subject: [PATCH 08/15] lowercase everything and parse relative time items

---
 src/items/date.rs     |  33 ++++----
 src/items/mod.rs      |  32 +++++++-
 src/items/relative.rs | 184 +++++++++++++++++++++++++++++++++++++++++-
 src/items/time.rs     |  12 +--
 src/items/weekday.rs  |  34 ++------
 src/lib.rs            |   5 +-
 6 files changed, 238 insertions(+), 62 deletions(-)

diff --git a/src/items/date.rs b/src/items/date.rs
index f93db8d..1b18d54 100644
--- a/src/items/date.rs
+++ b/src/items/date.rs
@@ -134,9 +134,8 @@ fn day(input: &mut &str) -> PResult<u32> {
 /// Parse the name of a month (case-insensitive)
 fn literal_month(input: &mut &str) -> PResult<u32> {
     s(alpha1)
-        .try_map(|s: &str| {
-            let s = s.to_ascii_lowercase();
-            let month = match s.as_ref() {
+        .verify_map(|s: &str| {
+            Some(match s {
                 "january" | "jan" => 1,
                 "february" | "feb" => 2,
                 "march" | "mar" => 3,
@@ -149,9 +148,8 @@ fn literal_month(input: &mut &str) -> PResult<u32> {
                 "october" | "oct" => 10,
                 "november" | "nov" => 11,
                 "december" | "dec" => 12,
-                _ => return Err(ParseDateTimeError::InvalidInput),
-            };
-            Ok(month)
+                _ => return None,
+            })
         })
         .parse_next(input)
 }
@@ -191,15 +189,14 @@ mod test {
             "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 november 2022",
+            "14 nov 2022",
+            "november 14, 2022",
+            "november 14     ,     2022",
+            "nov 14, 2022",
             "14-nov-2022",
             "14nov2022",
             "14nov      2022",
-            "NoVeMbEr 14, 2022",
         ] {
             let old_s = s.to_owned();
             assert_eq!(parse(&mut s).unwrap(), reference, "Format string: {old_s}");
@@ -215,12 +212,12 @@ mod test {
         };
         for mut s in [
             "11/14",
-            "14 November",
-            "14 Nov",
-            "14(comment!)Nov",
-            "November 14",
-            "November(comment!)14",
-            "Nov 14",
+            "14 november",
+            "14 nov",
+            "14(comment!)nov",
+            "november 14",
+            "november(comment!)14",
+            "nov 14",
             "14-nov",
             "14nov",
             "14(comment????)nov",
diff --git a/src/items/mod.rs b/src/items/mod.rs
index 5eef04c..0371456 100644
--- a/src/items/mod.rs
+++ b/src/items/mod.rs
@@ -35,7 +35,7 @@ mod relative;
 mod number {}
 
 use winnow::{
-    ascii::multispace0,
+    ascii::{alpha1, dec_int, multispace0},
     combinator::{alt, delimited, preceded, repeat, separated},
     error::ParserError,
     token::none_of,
@@ -46,10 +46,38 @@ pub enum Item {
     Date(date::Date),
     Time(time::Time),
     Weekday(weekday::Weekday),
-    Relative(()),
+    Relative(relative::Relative),
     TimeZone(()),
 }
 
+fn offset(input: &mut &str) -> PResult<i32> {
+    alt((text_offset, s(dec_int))).parse_next(input)
+}
+
+fn text_offset(input: &mut &str) -> PResult<i32> {
+    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)
+}
+
+
 /// Allow spaces and comments before a parser
 ///
 /// Every token parser should be wrapped in this to allow spaces and comments.
diff --git a/src/items/relative.rs b/src/items/relative.rs
index 35725dd..deb8f14 100644
--- a/src/items/relative.rs
+++ b/src/items/relative.rs
@@ -1,8 +1,186 @@
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
 
-use winnow::PResult;
+//! 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’.
 
-pub fn parse(_input: &mut &str) -> PResult<()> {
-    todo!()
+use winnow::{
+    ascii::{alpha1, float},
+    combinator::{alt, opt},
+    PResult, Parser,
+};
+
+use super::{offset, 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<Relative> {
+    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<Relative> {
+    (
+        opt(alt((s(float), offset.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<Relative> {
+    (opt(offset), 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<bool> {
+    opt(s("ago")).map(|o| o.is_some()).parse_next(input)
+}
+
+fn integer_unit(input: &mut &str) -> PResult<Relative> {
+    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 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 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 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)),
+            ("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
index a8ca247..df57dd6 100644
--- a/src/items/time.rs
+++ b/src/items/time.rs
@@ -224,9 +224,8 @@ mod test {
             "20:02",
             "20  :   02",
             "8:02pm",
-            "8:02PM",
             "8:   02     pm",
-            "8:02P.M.",
+            "8:02p.m.",
             "8:   02     p.m.",
         ] {
             let old_s = s.to_owned();
@@ -246,9 +245,7 @@ mod test {
         for mut s in [
             "11am",
             "11 am",
-            "11AM",
-            "11 AM",
-            "11 A.M.",
+            "11 a.m.",
             "11   :  00",
             "11:00:00",
         ] {
@@ -271,9 +268,8 @@ mod test {
             "12pm",
             "12 pm",
             "12 (A comment!) pm",
-            "12PM",
-            "12 PM",
-            "12 P.M.",
+            "12 pm",
+            "12 p.m.",
         ] {
             let old_s = s.to_owned();
             assert_eq!(parse(&mut s).unwrap(), reference, "Format string: {old_s}");
diff --git a/src/items/weekday.rs b/src/items/weekday.rs
index 8eb5763..228493b 100644
--- a/src/items/weekday.rs
+++ b/src/items/weekday.rs
@@ -23,7 +23,7 @@
 
 use winnow::{ascii::alpha1, combinator::opt, seq, PResult, Parser};
 
-use super::s;
+use super::{s, offset};
 
 #[derive(PartialEq, Eq, Debug)]
 enum Day {
@@ -50,35 +50,10 @@ pub fn parse(input: &mut &str) -> PResult<Weekday> {
     .parse_next(input)
 }
 
-fn offset(input: &mut &str) -> PResult<i32> {
-    s(alpha1)
-        .verify_map(|s: &str| {
-            let s = s.to_ascii_lowercase();
-            Some(match s.as_ref() {
-                "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)
-}
-
 fn day(input: &mut &str) -> PResult<Day> {
     s(alpha1)
         .verify_map(|s: &str| {
-            let s = s.to_ascii_lowercase();
-            Some(match s.as_ref() {
+            Some(match s {
                 "monday" | "mon" | "mon." => Day::Monday,
                 "tuesday" | "tue" | "tue." | "tues" => Day::Tuesday,
                 "wednesday" | "wed" | "wed." | "wednes" => Day::Wednesday,
@@ -106,6 +81,7 @@ mod tests {
             "this mon",
             "this mon.",
             "this    monday",
+            "0 monday",
         ] {
             assert_eq!(
                 parse(&mut s).unwrap(),
@@ -119,7 +95,7 @@ mod tests {
 
     #[test]
     fn next_tuesday() {
-        for s in ["tuesday", "tue", "tue.", "tues", "TUE"] {
+        for s in ["tuesday", "tue", "tue.", "tues"] {
             let s = format!("next {s}");
             assert_eq!(
                 parse(&mut s.as_ref()).unwrap(),
@@ -133,7 +109,7 @@ mod tests {
 
     #[test]
     fn last_wednesday() {
-        for s in ["wednesday", "wed", "wed.", "wednesday", "WED"] {
+        for s in ["wednesday", "wed", "wed.", "wednesday"] {
             let s = format!("last {s}");
             assert_eq!(
                 parse(&mut s.as_ref()).unwrap(),
diff --git a/src/lib.rs b/src/lib.rs
index 4ff0a91..2b411ab 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -31,8 +31,9 @@ impl Display for ParseDateTimeError {
 
 impl Error for ParseDateTimeError {}
 
-pub fn parse_datetime(mut input: &str) -> Result<Item, ParseDateTimeError> {
-    match items::parse.parse_next(&mut input) {
+pub fn parse_datetime(input: &str) -> Result<Item, ParseDateTimeError> {
+    let input = input.to_ascii_lowercase();
+    match items::parse.parse_next(&mut input.as_ref()) {
         Ok(x) => Ok(x),
         Err(_) => Err(ParseDateTimeError::InvalidInput),
     }

From 4a9519ee69dcf57b632c6c3ae25bad168c2abe63 Mon Sep 17 00:00:00 2001
From: Terts Diepraam <terts.diepraam@gmail.com>
Date: Sat, 27 Jan 2024 17:14:31 +0100
Subject: [PATCH 09/15] remove Caseless from am/pm

This is no longer necessary because the entire input is lowercased
---
 src/items/time.rs | 20 +++++++-------------
 1 file changed, 7 insertions(+), 13 deletions(-)

diff --git a/src/items/time.rs b/src/items/time.rs
index df57dd6..b0e3450 100644
--- a/src/items/time.rs
+++ b/src/items/time.rs
@@ -1,7 +1,7 @@
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
 
-// spell-checker:ignore Caseless shhmm colonless
+// spell-checker:ignore shhmm colonless
 
 //! Parse a time item (without a date)
 //!
@@ -38,7 +38,7 @@
 //! > Either ‘am’/‘pm’ or a time zone correction may be specified, but not both.
 
 use winnow::{
-    ascii::{dec_uint, float, Caseless},
+    ascii::{dec_uint, float},
     combinator::{alt, opt, preceded},
     seq,
     stream::AsChar,
@@ -141,10 +141,10 @@ fn second(input: &mut &str) -> PResult<f64> {
 /// Parse a suffix of am, pm or an offset (preceded by whitespace)
 fn suffix(input: &mut &str) -> PResult<Suffix> {
     alt((
-        s(Caseless("am")).value(Suffix::Am),
-        s(Caseless("a.m.")).value(Suffix::Am),
-        s(Caseless("pm")).value(Suffix::Pm),
-        s(Caseless("p.m.")).value(Suffix::Pm),
+        s("am").value(Suffix::Am),
+        s("a.m.").value(Suffix::Am),
+        s("pm").value(Suffix::Pm),
+        s("p.m.").value(Suffix::Pm),
         timezone.map(Suffix::TimeZone),
     ))
     .parse_next(input)
@@ -242,13 +242,7 @@ mod test {
             offset: None,
         };
 
-        for mut s in [
-            "11am",
-            "11 am",
-            "11 a.m.",
-            "11   :  00",
-            "11:00:00",
-        ] {
+        for mut s in ["11am", "11 am", "11 a.m.", "11   :  00", "11:00:00"] {
             let old_s = s.to_owned();
             assert_eq!(parse(&mut s).unwrap(), reference, "Format string: {old_s}");
         }

From 3c066bf6e3b668502a09b603177644fd48f97d53 Mon Sep 17 00:00:00 2001
From: Terts Diepraam <terts.diepraam@gmail.com>
Date: Sat, 27 Jan 2024 20:09:53 +0100
Subject: [PATCH 10/15] combined datetime with Winnow

---
 src/items/combined.rs |  76 +++++++++++++++++++
 src/items/date.rs     |  12 +--
 src/items/mod.rs      |   7 +-
 src/items/time.rs     | 166 +++++++++++++++++++++++++-----------------
 src/items/weekday.rs  |   2 +-
 5 files changed, 187 insertions(+), 76 deletions(-)
 create mode 100644 src/items/combined.rs

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<DateTime> {
+    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
index 1b18d54..1d6e426 100644
--- a/src/items/date.rs
+++ b/src/items/date.rs
@@ -37,11 +37,11 @@ use winnow::{
 use super::s;
 use crate::ParseDateTimeError;
 
-#[derive(PartialEq, Eq, Debug)]
+#[derive(PartialEq, Eq, Clone, Debug)]
 pub struct Date {
-    day: u32,
-    month: u32,
-    year: Option<u32>,
+    pub day: u32,
+    pub month: u32,
+    pub year: Option<u32>,
 }
 
 pub fn parse(input: &mut &str) -> PResult<Date> {
@@ -49,7 +49,9 @@ pub fn parse(input: &mut &str) -> PResult<Date> {
 }
 
 /// Parse `YYYY-MM-DD` or `YY-MM-DD`
-fn iso(input: &mut &str) -> PResult<Date> {
+///
+/// This is also used by [`combined`](super::combined).
+pub fn iso(input: &mut &str) -> PResult<Date> {
     seq!(Date {
         year: year.map(Some),
         _: s('-'),
diff --git a/src/items/mod.rs b/src/items/mod.rs
index 0371456..a9a3b7c 100644
--- a/src/items/mod.rs
+++ b/src/items/mod.rs
@@ -26,12 +26,12 @@
 //!  - [`relative`]
 //!  - [`number]
 
+mod combined;
 mod date;
+mod relative;
 mod time;
 mod time_zone;
 mod weekday;
-mod combined {}
-mod relative;
 mod number {}
 
 use winnow::{
@@ -43,6 +43,7 @@ use winnow::{
 };
 
 pub enum Item {
+    DateTime(combined::DateTime),
     Date(date::Date),
     Time(time::Time),
     Weekday(weekday::Weekday),
@@ -77,7 +78,6 @@ fn text_offset(input: &mut &str) -> PResult<i32> {
         .parse_next(input)
 }
 
-
 /// Allow spaces and comments before a parser
 ///
 /// Every token parser should be wrapped in this to allow spaces and comments.
@@ -119,6 +119,7 @@ where
 /// Parse an item
 pub fn parse(input: &mut &str) -> PResult<Item> {
     alt((
+        combined::parse.map(Item::DateTime),
         date::parse.map(Item::Date),
         time::parse.map(Item::Time),
         relative::parse.map(Item::Relative),
diff --git a/src/items/time.rs b/src/items/time.rs
index b0e3450..772add5 100644
--- a/src/items/time.rs
+++ b/src/items/time.rs
@@ -48,12 +48,12 @@ use winnow::{
 
 use super::s;
 
-#[derive(PartialEq, Debug)]
+#[derive(PartialEq, Clone, Debug)]
 pub struct Time {
-    hour: i32,
-    minute: i32,
-    second: f64,
-    offset: Option<Offset>,
+    pub hour: u32,
+    pub minute: u32,
+    pub second: f64,
+    pub offset: Option<Offset>,
 }
 
 #[derive(PartialEq, Debug, Clone)]
@@ -67,53 +67,60 @@ pub struct Offset {
 enum Suffix {
     Am,
     Pm,
-    TimeZone(Offset),
 }
 
 pub fn parse(input: &mut &str) -> PResult<Time> {
-    // Hour followed by suffix is a special case where minutes are optional
+    alt((am_pm_time, iso)).parse_next(input)
+}
+
+/// Parse an ISO 8601 time string
+///
+/// Also used by the [`combined`](super::combined) module
+pub fn iso(input: &mut &str) -> PResult<Time> {
     alt((
-        (hour, suffix).map(|(h, s)| (h, 0, 0.0, Some(s))),
-        seq!(
+        (hour24, timezone).map(|(hour, offset)| Time {
             hour,
+            minute: 0,
+            second: 0.0,
+            offset: Some(offset),
+        }),
+        seq!( Time {
+            hour: hour24,
             _: colon,
-            minute,
-            opt(preceded(colon, second)).map(|s| s.unwrap_or(0.0)),
-            opt(suffix)
-        ),
+            minute: minute,
+            second: opt(preceded(colon, second)).map(|s| s.unwrap_or(0.0)),
+            offset: opt(timezone)
+        }),
     ))
-    .verify_map(|(mut hour, minute, second, suffix)| {
-        let mut offset = None;
-        match suffix {
-            None => {}
-            // 12am should be noon
-            Some(Suffix::Am) => {
-                // With an AM/PM suffix
-                if hour > 12 {
-                    return None;
-                }
-                if hour == 12 {
-                    hour = 0;
-                };
-            }
-            // 12pm should be noon
-            Some(Suffix::Pm) => {
-                if hour > 12 {
-                    return None;
-                } else if hour == 12 {
-                    hour = 12;
-                } else {
-                    hour += 12;
-                }
-            }
-            Some(Suffix::TimeZone(tz)) => offset = Some(tz),
-        };
-        Some(Time {
-            hour: hour as i32,
-            minute: minute as i32,
-            second,
-            offset,
-        })
+    .parse_next(input)
+}
+
+/// Parse a time ending with AM or PM
+///
+/// The hours are restricted to 12 or lower in this format
+fn am_pm_time(input: &mut &str) -> PResult<Time> {
+    seq!(
+        hour12,
+        opt(preceded(colon, minute)),
+        opt(preceded(colon, second)),
+        alt((
+            s("am").value(Suffix::Am),
+            s("a.m.").value(Suffix::Am),
+            s("pm").value(Suffix::Pm),
+            s("p.m.").value(Suffix::Pm)
+        )),
+    )
+    .map(|(h, m, s, suffix)| {
+        let mut h = h % 12;
+        if let Suffix::Pm = suffix {
+            h += 12;
+        }
+        Time {
+            hour: h,
+            minute: m.unwrap_or(0),
+            second: s.unwrap_or(0.0),
+            offset: None,
+        }
     })
     .parse_next(input)
 }
@@ -123,11 +130,16 @@ fn colon(input: &mut &str) -> PResult<()> {
     s(':').void().parse_next(input)
 }
 
-/// Parse a number of hours (preceded by whitespace)
-fn hour(input: &mut &str) -> PResult<u32> {
+/// Parse a number of hours in `0..24` (preceded by whitespace)
+fn hour24(input: &mut &str) -> PResult<u32> {
     s(dec_uint).verify(|x| *x < 24).parse_next(input)
 }
 
+/// Parse a number of hours in `0..=12` (preceded by whitespace)
+fn hour12(input: &mut &str) -> PResult<u32> {
+    s(dec_uint).verify(|x| *x <= 12).parse_next(input)
+}
+
 /// Parse a number of minutes (preceded by whitespace)
 fn minute(input: &mut &str) -> PResult<u32> {
     s(dec_uint).verify(|x| *x < 60).parse_next(input)
@@ -138,18 +150,6 @@ fn second(input: &mut &str) -> PResult<f64> {
     s(float).verify(|x| *x < 60.0).parse_next(input)
 }
 
-/// Parse a suffix of am, pm or an offset (preceded by whitespace)
-fn suffix(input: &mut &str) -> PResult<Suffix> {
-    alt((
-        s("am").value(Suffix::Am),
-        s("a.m.").value(Suffix::Am),
-        s("pm").value(Suffix::Pm),
-        s("p.m.").value(Suffix::Pm),
-        timezone.map(Suffix::TimeZone),
-    ))
-    .parse_next(input)
-}
-
 /// Parse a timezone starting with `+` or `-`
 fn timezone(input: &mut &str) -> PResult<Offset> {
     seq!(plus_or_minus, alt((timezone_colon, timezone_colonless)))
@@ -229,7 +229,11 @@ mod test {
             "8:   02     p.m.",
         ] {
             let old_s = s.to_owned();
-            assert_eq!(parse(&mut s).unwrap(), reference, "Format string: {old_s}");
+            assert_eq!(
+                parse(&mut s).ok(),
+                Some(reference.clone()),
+                "Format string: {old_s}"
+            );
         }
     }
 
@@ -244,7 +248,11 @@ mod test {
 
         for mut s in ["11am", "11 am", "11 a.m.", "11   :  00", "11:00:00"] {
             let old_s = s.to_owned();
-            assert_eq!(parse(&mut s).unwrap(), reference, "Format string: {old_s}");
+            assert_eq!(
+                parse(&mut s).ok(),
+                Some(reference.clone()),
+                "Format string: {old_s}"
+            );
         }
     }
 
@@ -266,7 +274,11 @@ mod test {
             "12 p.m.",
         ] {
             let old_s = s.to_owned();
-            assert_eq!(parse(&mut s).unwrap(), reference, "Format string: {old_s}");
+            assert_eq!(
+                parse(&mut s).ok(),
+                Some(reference.clone()),
+                "Format string: {old_s}"
+            );
         }
     }
 
@@ -281,7 +293,11 @@ mod test {
 
         for mut s in ["00:00", "12am"] {
             let old_s = s.to_owned();
-            assert_eq!(parse(&mut s).unwrap(), reference, "Format string: {old_s}");
+            assert_eq!(
+                parse(&mut s).ok(),
+                Some(reference.clone()),
+                "Format string: {old_s}"
+            );
         }
     }
 
@@ -307,7 +323,11 @@ mod test {
             "1:23+05:0",
         ] {
             let old_s = s.to_owned();
-            assert_eq!(parse(&mut s).unwrap(), reference, "Format string: {old_s}");
+            assert_eq!(
+                parse(&mut s).ok(),
+                Some(reference.clone()),
+                "Format string: {old_s}"
+            );
         }
     }
 
@@ -334,7 +354,11 @@ mod test {
             "3:45  + 05 : 35",
         ] {
             let old_s = s.to_owned();
-            assert_eq!(parse(&mut s).unwrap(), reference, "Format string: {old_s}");
+            assert_eq!(
+                parse(&mut s).ok(),
+                Some(reference.clone()),
+                "Format string: {old_s}"
+            );
         }
     }
 
@@ -362,7 +386,11 @@ mod test {
             "3:45  + 00 : 35",
         ] {
             let old_s = s.to_owned();
-            assert_eq!(parse(&mut s).unwrap(), reference, "Format string: {old_s}");
+            assert_eq!(
+                parse(&mut s).ok(),
+                Some(reference.clone()),
+                "Format string: {old_s}"
+            );
         }
     }
 
@@ -389,7 +417,11 @@ mod test {
             "3:45  - 05 : 35",
         ] {
             let old_s = s.to_owned();
-            assert_eq!(parse(&mut s).unwrap(), reference, "Format string: {old_s}");
+            assert_eq!(
+                parse(&mut s).ok(),
+                Some(reference.clone()),
+                "Format string: {old_s}"
+            );
         }
     }
 }
diff --git a/src/items/weekday.rs b/src/items/weekday.rs
index 228493b..b719c07 100644
--- a/src/items/weekday.rs
+++ b/src/items/weekday.rs
@@ -23,7 +23,7 @@
 
 use winnow::{ascii::alpha1, combinator::opt, seq, PResult, Parser};
 
-use super::{s, offset};
+use super::{offset, s};
 
 #[derive(PartialEq, Eq, Debug)]
 enum Day {

From 7a2d747eb6a9abd32f69ed16da2e1d450ed28eae Mon Sep 17 00:00:00 2001
From: Terts Diepraam <terts.diepraam@gmail.com>
Date: Sat, 27 Jan 2024 20:17:57 +0100
Subject: [PATCH 11/15] call all test modules "tests"

---
 src/items/date.rs | 2 +-
 src/items/time.rs | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/items/date.rs b/src/items/date.rs
index 1d6e426..88c4a04 100644
--- a/src/items/date.rs
+++ b/src/items/date.rs
@@ -157,7 +157,7 @@ fn literal_month(input: &mut &str) -> PResult<u32> {
 }
 
 #[cfg(test)]
-mod test {
+mod tests {
     use super::{parse, Date};
 
     // Test cases from the GNU docs:
diff --git a/src/items/time.rs b/src/items/time.rs
index 772add5..b472ccb 100644
--- a/src/items/time.rs
+++ b/src/items/time.rs
@@ -130,7 +130,7 @@ fn colon(input: &mut &str) -> PResult<()> {
     s(':').void().parse_next(input)
 }
 
-/// Parse a number of hours in `0..24` (preceded by whitespace)
+/// Parse a number of hours in `0..24`(preceded by whitespace)
 fn hour24(input: &mut &str) -> PResult<u32> {
     s(dec_uint).verify(|x| *x < 24).parse_next(input)
 }
@@ -201,7 +201,7 @@ fn plus_or_minus(input: &mut &str) -> PResult<bool> {
 }
 
 #[cfg(test)]
-mod test {
+mod tests {
     use super::{Offset, Time};
     use crate::items::time::parse;
 

From f76952ce7775a586919d2c5b29e20eb280bac7f5 Mon Sep 17 00:00:00 2001
From: Terts Diepraam <terts.diepraam@gmail.com>
Date: Sun, 28 Jan 2024 20:49:10 +0100
Subject: [PATCH 12/15] ignore hyphens not followed by a digit

---
 src/items/date.rs    |  4 +++-
 src/items/mod.rs     | 26 ++++++++++++++++++++++----
 src/items/time.rs    |  4 +++-
 src/items/weekday.rs |  1 +
 4 files changed, 29 insertions(+), 6 deletions(-)

diff --git a/src/items/date.rs b/src/items/date.rs
index 88c4a04..f6f3096 100644
--- a/src/items/date.rs
+++ b/src/items/date.rs
@@ -186,8 +186,10 @@ mod tests {
             "2022-11-14",
             "2022    -  11  -   14",
             "22-11-14",
-            "22(comment 1)-(comment 2)11(comment 3)-(comment 4)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",
diff --git a/src/items/mod.rs b/src/items/mod.rs
index a9a3b7c..d6e9bc6 100644
--- a/src/items/mod.rs
+++ b/src/items/mod.rs
@@ -36,9 +36,10 @@ mod number {}
 
 use winnow::{
     ascii::{alpha1, dec_int, multispace0},
-    combinator::{alt, delimited, preceded, repeat, separated},
+    combinator::{alt, delimited, not, peek, preceded, repeat, separated},
     error::ParserError,
-    token::none_of,
+    stream::AsChar,
+    token::{none_of, take_while},
     PResult, Parser,
 };
 
@@ -97,7 +98,24 @@ fn space<'a, E>(input: &mut &'a str) -> PResult<(), E>
 where
     E: ParserError<&'a str>,
 {
-    separated(0.., multispace0, comment).parse_next(input)
+    separated(0.., multispace0, alt((comment, ignored_hyphen))).parse_next(input)
+}
+
+/// A hyphen 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.
+fn ignored_hyphen<'a, E>(input: &mut &'a str) -> PResult<(), E>
+where
+    E: ParserError<&'a str>,
+{
+    ('-', multispace0, peek(not(take_while(1, AsChar::is_dec_digit))))
+        .void()
+        .parse_next(input)
 }
 
 /// Parse a comment
@@ -124,7 +142,7 @@ pub fn parse(input: &mut &str) -> PResult<Item> {
         time::parse.map(Item::Time),
         relative::parse.map(Item::Relative),
         weekday::parse.map(Item::Weekday),
-        time_zone::parse.map(Item::TimeZone),
+        // time_zone::parse.map(Item::TimeZone),
     ))
     .parse_next(input)
 }
diff --git a/src/items/time.rs b/src/items/time.rs
index b472ccb..8782575 100644
--- a/src/items/time.rs
+++ b/src/items/time.rs
@@ -217,6 +217,7 @@ mod tests {
         for mut s in [
             "20:02:00.000000",
             "20:02:00",
+            "20----:02--(these hyphens are ignored)--:00",
             "20: (A comment!)   02 (Another comment!)  :00",
             "20:02  (A nested (comment!))  :00",
             "20:02  (So (many (nested) comments!!!!))  :00",
@@ -246,7 +247,7 @@ mod tests {
             offset: None,
         };
 
-        for mut s in ["11am", "11 am", "11 a.m.", "11   :  00", "11:00:00"] {
+        for mut s in ["11am", "11 am", "11 - am", "11 a.m.", "11   :  00", "11:00:00"] {
             let old_s = s.to_owned();
             assert_eq!(
                 parse(&mut s).ok(),
@@ -346,6 +347,7 @@ mod tests {
 
         for mut s in [
             "3:45+535",
+            "3:45-+535",
             "03:45+535",
             "3   :  45  +  535",
             "3:45+0535",
diff --git a/src/items/weekday.rs b/src/items/weekday.rs
index b719c07..94252c5 100644
--- a/src/items/weekday.rs
+++ b/src/items/weekday.rs
@@ -81,6 +81,7 @@ mod tests {
             "this mon",
             "this mon.",
             "this    monday",
+            "this - monday",
             "0 monday",
         ] {
             assert_eq!(

From 88c8c88f8779b6f022d49afb2c477cd1b56639ac Mon Sep 17 00:00:00 2001
From: Terts Diepraam <terts.diepraam@gmail.com>
Date: Sun, 28 Jan 2024 21:17:59 +0100
Subject: [PATCH 13/15] ignore plusses like we ignore hyphens

---
 src/items/mod.rs       | 34 ++++++++++++++++++++++---------
 src/items/number.rs    | 45 ++++++++++++++++++++++++++++++++++++++++++
 src/items/relative.rs  | 10 +++++++---
 src/items/time.rs      | 17 ++++++++++++----
 src/items/time_zone.rs |  7 -------
 src/items/weekday.rs   |  4 ++--
 6 files changed, 92 insertions(+), 25 deletions(-)
 create mode 100644 src/items/number.rs

diff --git a/src/items/mod.rs b/src/items/mod.rs
index d6e9bc6..436b999 100644
--- a/src/items/mod.rs
+++ b/src/items/mod.rs
@@ -35,8 +35,8 @@ mod weekday;
 mod number {}
 
 use winnow::{
-    ascii::{alpha1, dec_int, multispace0},
-    combinator::{alt, delimited, not, peek, preceded, repeat, separated},
+    ascii::{alpha1, dec_uint, multispace0},
+    combinator::{alt, delimited, not, opt, peek, preceded, repeat, separated},
     error::ParserError,
     stream::AsChar,
     token::{none_of, take_while},
@@ -52,11 +52,21 @@ pub enum Item {
     TimeZone(()),
 }
 
-fn offset(input: &mut &str) -> PResult<i32> {
-    alt((text_offset, s(dec_int))).parse_next(input)
+fn ordinal(input: &mut &str) -> PResult<i32> {
+    alt((text_ordinal, number_ordinal)).parse_next(input)
 }
 
-fn text_offset(input: &mut &str) -> PResult<i32> {
+fn number_ordinal(input: &mut &str) -> PResult<i32> {
+    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<i32> {
     s(alpha1)
         .verify_map(|s: &str| {
             Some(match s {
@@ -98,10 +108,10 @@ fn space<'a, E>(input: &mut &'a str) -> PResult<(), E>
 where
     E: ParserError<&'a str>,
 {
-    separated(0.., multispace0, alt((comment, ignored_hyphen))).parse_next(input)
+    separated(0.., multispace0, alt((comment, ignored_hyphen_or_plus))).parse_next(input)
 }
 
-/// A hyphen is ignored when it is not followed by a digit
+/// 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
@@ -109,11 +119,17 @@ where
 /// - (comment) 12 weeks
 /// ```
 /// The last comment should be ignored.
-fn ignored_hyphen<'a, E>(input: &mut &'a str) -> PResult<(), E>
+///
+/// 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>,
 {
-    ('-', multispace0, peek(not(take_while(1, AsChar::is_dec_digit))))
+    (
+        alt(('-', '+')),
+        multispace0,
+        peek(not(take_while(1, AsChar::is_dec_digit))),
+    )
         .void()
         .parse_next(input)
 }
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<Number> {
+    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<Number> {
+    todo!()
+}
+
+fn time_number(input: &mut &str) -> PResult<Number> {
+    todo!()
+}
+
+fn year_number(input: &mut &str) -> PResult<Number> {
+    todo!()
+}
diff --git a/src/items/relative.rs b/src/items/relative.rs
index deb8f14..062a7ab 100644
--- a/src/items/relative.rs
+++ b/src/items/relative.rs
@@ -37,7 +37,7 @@ use winnow::{
     PResult, Parser,
 };
 
-use super::{offset, s};
+use super::{ordinal, s};
 
 #[derive(Clone, Copy, Debug, PartialEq)]
 pub enum Relative {
@@ -78,7 +78,7 @@ pub fn parse(input: &mut &str) -> PResult<Relative> {
 
 fn seconds(input: &mut &str) -> PResult<Relative> {
     (
-        opt(alt((s(float), offset.map(|x| x as f64)))),
+        opt(alt((s(float), ordinal.map(|x| x as f64)))),
         s(alpha1).verify(|s: &str| matches!(s, "seconds" | "second" | "sec" | "secs")),
         ago,
     )
@@ -87,7 +87,7 @@ fn seconds(input: &mut &str) -> PResult<Relative> {
 }
 
 fn other(input: &mut &str) -> PResult<Relative> {
-    (opt(offset), integer_unit, ago)
+    (opt(ordinal), integer_unit, ago)
         .map(|(n, unit, ago)| unit.mul(n.unwrap_or(1) * if ago { -1 } else { 1 }))
         .parse_next(input)
 }
@@ -128,6 +128,7 @@ mod tests {
             ("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
@@ -143,6 +144,7 @@ mod tests {
             ("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)),
@@ -150,6 +152,7 @@ mod tests {
             ("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)),
@@ -157,6 +160,7 @@ mod tests {
             ("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)),
diff --git a/src/items/time.rs b/src/items/time.rs
index 8782575..7d58896 100644
--- a/src/items/time.rs
+++ b/src/items/time.rs
@@ -164,8 +164,7 @@ fn timezone(input: &mut &str) -> PResult<Offset> {
 /// Parse a timezone offset with a colon separating hours and minutes
 fn timezone_colon(input: &mut &str) -> PResult<(u32, u32)> {
     seq!(
-        // There's an edge case here: GNU allows the hours to be omitted
-        s(take_while(0..=2, AsChar::is_dec_digit)).try_map(|x: &str| {
+        s(take_while(1..=2, AsChar::is_dec_digit)).try_map(|x: &str| {
             // parse will fail on empty input
             if x == "" {
                 Ok(0)
@@ -217,7 +216,10 @@ mod tests {
         for mut s in [
             "20:02:00.000000",
             "20:02:00",
+            "20:02+:00",
+            "20:02-:00",
             "20----:02--(these hyphens are ignored)--:00",
+            "20++++:02++(these plusses are ignored)++:00",
             "20: (A comment!)   02 (Another comment!)  :00",
             "20:02  (A nested (comment!))  :00",
             "20:02  (So (many (nested) comments!!!!))  :00",
@@ -247,7 +249,15 @@ mod tests {
             offset: None,
         };
 
-        for mut s in ["11am", "11 am", "11 - am", "11 a.m.", "11   :  00", "11:00:00"] {
+        for mut s in [
+            "11am",
+            "11 am",
+            "11 - am",
+            "11 + am",
+            "11 a.m.",
+            "11   :  00",
+            "11:00:00",
+        ] {
             let old_s = s.to_owned();
             assert_eq!(
                 parse(&mut s).ok(),
@@ -384,7 +394,6 @@ mod tests {
             "3:45+0035",
             "3:45+0:35",
             "3:45+00:35",
-            "3:45+:35",
             "3:45  + 00 : 35",
         ] {
             let old_s = s.to_owned();
diff --git a/src/items/time_zone.rs b/src/items/time_zone.rs
index 603d4fc..123c9d7 100644
--- a/src/items/time_zone.rs
+++ b/src/items/time_zone.rs
@@ -12,10 +12,3 @@
 //! > of the form ‘TZ="rule"’. The two quote characters (‘"’) must be present
 //! > in the date, and any quotes or backslashes within rule must be escaped by
 //! > a backslash.
-//!
-
-use winnow::PResult;
-
-pub fn parse(_input: &mut &str) -> PResult<()> {
-    todo!()
-}
diff --git a/src/items/weekday.rs b/src/items/weekday.rs
index 94252c5..f204726 100644
--- a/src/items/weekday.rs
+++ b/src/items/weekday.rs
@@ -23,7 +23,7 @@
 
 use winnow::{ascii::alpha1, combinator::opt, seq, PResult, Parser};
 
-use super::{offset, s};
+use super::{ordinal, s};
 
 #[derive(PartialEq, Eq, Debug)]
 enum Day {
@@ -44,7 +44,7 @@ pub struct Weekday {
 
 pub fn parse(input: &mut &str) -> PResult<Weekday> {
     seq!(Weekday {
-        offset: opt(offset).map(|o| o.unwrap_or_default()),
+        offset: opt(ordinal).map(|o| o.unwrap_or_default()),
         day: day,
     })
     .parse_next(input)

From e83a8d118c8dc8885301f744bf0970505c9792c7 Mon Sep 17 00:00:00 2001
From: Terts Diepraam <terts.diepraam@gmail.com>
Date: Sun, 28 Jan 2024 21:27:44 +0100
Subject: [PATCH 14/15] move ordinal to separate module

---
 src/items/mod.rs      | 38 +----------------------------------
 src/items/ordinal.rs  | 46 +++++++++++++++++++++++++++++++++++++++++++
 src/items/relative.rs |  2 +-
 src/items/weekday.rs  |  2 +-
 4 files changed, 49 insertions(+), 39 deletions(-)
 create mode 100644 src/items/ordinal.rs

diff --git a/src/items/mod.rs b/src/items/mod.rs
index 436b999..62687fc 100644
--- a/src/items/mod.rs
+++ b/src/items/mod.rs
@@ -28,6 +28,7 @@
 
 mod combined;
 mod date;
+mod ordinal;
 mod relative;
 mod time;
 mod time_zone;
@@ -52,43 +53,6 @@ pub enum Item {
     TimeZone(()),
 }
 
-fn ordinal(input: &mut &str) -> PResult<i32> {
-    alt((text_ordinal, number_ordinal)).parse_next(input)
-}
-
-fn number_ordinal(input: &mut &str) -> PResult<i32> {
-    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<i32> {
-    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)
-}
-
 /// Allow spaces and comments before a parser
 ///
 /// Every token parser should be wrapped in this to allow spaces and comments.
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<i32> {
+    alt((text_ordinal, number_ordinal)).parse_next(input)
+}
+
+fn number_ordinal(input: &mut &str) -> PResult<i32> {
+    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<i32> {
+    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
index 062a7ab..7e7cb81 100644
--- a/src/items/relative.rs
+++ b/src/items/relative.rs
@@ -37,7 +37,7 @@ use winnow::{
     PResult, Parser,
 };
 
-use super::{ordinal, s};
+use super::{ordinal::ordinal, s};
 
 #[derive(Clone, Copy, Debug, PartialEq)]
 pub enum Relative {
diff --git a/src/items/weekday.rs b/src/items/weekday.rs
index f204726..c3ae24c 100644
--- a/src/items/weekday.rs
+++ b/src/items/weekday.rs
@@ -23,7 +23,7 @@
 
 use winnow::{ascii::alpha1, combinator::opt, seq, PResult, Parser};
 
-use super::{ordinal, s};
+use super::{ordinal::ordinal, s};
 
 #[derive(PartialEq, Eq, Debug)]
 enum Day {

From 5e88d773542078d5b2148430849377b582b85582 Mon Sep 17 00:00:00 2001
From: Terts Diepraam <terts.diepraam@gmail.com>
Date: Sun, 28 Jan 2024 21:53:06 +0100
Subject: [PATCH 15/15] add first parsing of multiple items

---
 src/items/mod.rs | 36 +++++++++++++++++++++++++++++++++---
 src/lib.rs       |  8 ++++----
 2 files changed, 37 insertions(+), 7 deletions(-)

diff --git a/src/items/mod.rs b/src/items/mod.rs
index 62687fc..347cdf0 100644
--- a/src/items/mod.rs
+++ b/src/items/mod.rs
@@ -36,14 +36,15 @@ mod weekday;
 mod number {}
 
 use winnow::{
-    ascii::{alpha1, dec_uint, multispace0},
-    combinator::{alt, delimited, not, opt, peek, preceded, repeat, separated},
+    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),
@@ -115,7 +116,7 @@ where
 }
 
 /// Parse an item
-pub fn parse(input: &mut &str) -> PResult<Item> {
+pub fn parse_one(input: &mut &str) -> PResult<Item> {
     alt((
         combined::parse.map(Item::DateTime),
         date::parse.map(Item::Date),
@@ -126,3 +127,32 @@ pub fn parse(input: &mut &str) -> PResult<Item> {
     ))
     .parse_next(input)
 }
+
+pub fn parse(input: &mut &str) -> Option<Vec<Item>> {
+    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/lib.rs b/src/lib.rs
index 2b411ab..ea5ef55 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -31,10 +31,10 @@ impl Display for ParseDateTimeError {
 
 impl Error for ParseDateTimeError {}
 
-pub fn parse_datetime(input: &str) -> Result<Item, ParseDateTimeError> {
+pub fn parse_datetime(input: &str) -> Result<Vec<Item>, ParseDateTimeError> {
     let input = input.to_ascii_lowercase();
-    match items::parse.parse_next(&mut input.as_ref()) {
-        Ok(x) => Ok(x),
-        Err(_) => Err(ParseDateTimeError::InvalidInput),
+    match items::parse(&mut input.as_ref()) {
+        Some(x) => Ok(x),
+        None => Err(ParseDateTimeError::InvalidInput),
     }
 }