Restore the old API and add the missing combinators

Author: dhilst

Cargo.lock

@@ -12,3 +12,17 @@ regex = "1.10.4"
 chrono = { version="0.4.38", default-features=false, features=["std", "alloc", "clock"] }
 nom = "8.0.0"
 winnow = "0.5.34"
+num-traits = "0.2.19"
+
+[dev-dependencies]
+anyhow = "1.0.86"
+#winnow = { version="0.5.34", features = ["debug"] }
+
+[features]
+debug = ["winnow/debug"]
+
+[[bin]]
+path = "bin/main.rs"
+name = "parse_datetime"
+test = false
+bench = false

Cargo.toml

@@ -0,0 +1,6 @@
+use parse_datetime::parse_datetime;
+
+fn main() {
+    let date: String = std::env::args().nth(1).unwrap_or("".to_string());
+    println!("{}", parse_datetime(&date).unwrap().format("%+"))
+}

bin/main.rs

@@ -14,6 +14,9 @@ chrono = { version="0.4", default-features=false, features=["std", "alloc", "clo
 [dependencies.parse_datetime]
 path = "../"
 
+[features]
+debug = ["parse_datetime/debug"]
+
 [[bin]]
 name = "fuzz_parse_datetime"
 path = "fuzz_targets/parse_datetime.rs"

fuzz/Cargo.toml

@@ -1,8 +1,134 @@
 #![no_main]
+#![allow(dead_code)]
 
-use libfuzzer_sys::fuzz_target;
+use std::fmt::{Debug, Display};
+use std::io::{self, Write};
 
-fuzz_target!(|data: &[u8]| {
-    let s = std::str::from_utf8(data).unwrap_or("");
-    let _ = parse_datetime::parse_datetime(s);
+use libfuzzer_sys::arbitrary::{self, Arbitrary};
+
+#[macro_use]
+extern crate libfuzzer_sys;
+
+#[derive(Debug)]
+struct Format(&'static str);
+
+// These are formats to test the compatibility with GNU
+const FORMATS: &[&str] = &["%G-%m-%d %H:%M:%S", "%b %d %Y %H:%M:%S"];
+
+impl<'a> Arbitrary<'a> for Format {
+    fn arbitrary(u: &mut arbitrary::Unstructured<'a>) -> arbitrary::Result<Self> {
+        Ok(Format(u.choose(FORMATS)?))
+    }
+}
+
+struct Input {
+    year: u32,
+    month: u32,
+    day: u32,
+    hour: u32,
+    minute: u32,
+    second: u32,
+    format: Format,
+}
+
+impl<'a> Arbitrary<'a> for Input {
+    fn arbitrary(
+        u: &mut libfuzzer_sys::arbitrary::Unstructured<'a>,
+    ) -> libfuzzer_sys::arbitrary::Result<Self> {
+        let year = u.arbitrary::<u32>()?;
+        let month = u.arbitrary::<u32>()?;
+        let day = u.arbitrary::<u32>()?;
+        let hour = u.arbitrary::<u32>()?;
+        let minute = u.arbitrary::<u32>()?;
+        let second = u.arbitrary::<u32>()?;
+        let format = u.arbitrary::<Format>()?;
+
+        // GNU max    2147485547
+        // chrono max 262143
+        // chrono outputs + before the year if it is >9999
+        if !(1..=9999).contains(&year)
+            || !(1..=12).contains(&month)
+            || !(1..=31).contains(&day)
+            || !(0..24).contains(&hour)
+            || !(0..60).contains(&minute)
+            || !(0..60).contains(&second)
+        {
+            return Err(crate::arbitrary::Error::IncorrectFormat);
+        }
+
+        Ok(Input {
+            year,
+            month,
+            day,
+            hour,
+            minute,
+            second,
+            format,
+        })
+    }
+}
+
+impl Input {
+    fn format(&self) -> String {
+        let Input {
+            year,
+            month,
+            day,
+            hour,
+            minute,
+            second,
+            format,
+        } = self;
+        let as_string = format!("{year:04}-{month:02}-{day:02} {hour:02}:{minute:02}:{second:02}");
+        std::process::Command::new("date")
+            .arg("-d")
+            .arg(as_string)
+            .arg(format!("+{}", &format.0))
+            .output()
+            .map(|mut output| {
+                output.stdout.pop(); // remove trailing \n
+                String::from_utf8(output.stdout).expect("from_utf8")
+            })
+            .expect("gnu date")
+    }
+}
+
+impl Display for Input {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self.format())
+    }
+}
+
+impl Debug for Input {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self.format())
+    }
+}
+
+fuzz_target!(|input: Input| {
+    let fmt = input.format.0;
+    let gnu = std::process::Command::new("date")
+        .arg("-d")
+        .arg(input.format())
+        .arg(format!("+{fmt}"))
+        .output()
+        .map(|mut output| {
+            output.stdout.pop(); // remove trailing \n
+            String::from_utf8(output.stdout).expect("from_utf8")
+        });
+    let us = parse_datetime::parse_datetime(&input.format()).map(|d| d.format(fmt).to_string());
+
+    match (us, gnu) {
+        (Ok(us), Ok(gnu)) => assert_eq!(
+            us, gnu,
+            "\n\nGNU Incompatibility found for the input: {input}\nExpected: {gnu}\nFound:    {us}\n\n"
+        ),
+        (Err(_), Err(_)) => (),
+        (Ok(us), Err(e)) => {
+            panic!("Expecting to fail, but succeeded for input `{input}`, gnu error: {e}, parsed date: {us}")
+        }
+        (Err(_), Ok(gnu)) => {
+            panic!("Expecting to succeed, but failed for input `{input}`, gnu output: {gnu}")
+        }
+    };
 });

fuzz/fuzz_targets/parse_datetime.rs

@@ -13,9 +13,13 @@
 //! > 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.
+#![allow(deprecated)]
 
-use winnow::{combinator::alt, seq, PResult, Parser};
+use winnow::ascii::dec_uint;
+use winnow::token::take;
+use winnow::{combinator::alt, seq, trace::trace, PResult, Parser};
 
+use crate::items::combined;
 use crate::items::space;
 
 use super::{
@@ -24,22 +28,56 @@ use super::{
     time::{self, Time},
 };
 
-#[derive(PartialEq, Debug, Clone)]
+#[derive(PartialEq, Debug, Clone, Default)]
 pub struct DateTime {
-    date: Date,
-    time: Time,
+    pub(crate) date: Date,
+    pub(crate) time: Time,
 }
 
 pub fn parse(input: &mut &str) -> PResult<DateTime> {
+    alt((
+        parse_basic,
+        //parse_8digits
+    ))
+    .parse_next(input)
+}
+
+fn parse_basic(input: &mut &str) -> PResult<DateTime> {
     seq!(DateTime {
-        date: date::iso,
+        date: trace("date iso", date::iso),
         // Note: the `T` is lowercased by the main parse function
         _: alt((s('t').void(), (' ', space).void())),
-        time: time::iso,
+        time: trace("time iso", time::iso),
     })
     .parse_next(input)
 }
 
+#[allow(dead_code)]
+fn parse_8digits(input: &mut &str) -> PResult<DateTime> {
+    s((
+        take(2usize).and_then(dec_uint),
+        take(2usize).and_then(dec_uint),
+        take(2usize).and_then(dec_uint),
+        take(2usize).and_then(dec_uint),
+    ))
+    .map(
+        |(hour, minute, day, month): (u32, u32, u32, u32)| combined::DateTime {
+            date: date::Date {
+                day,
+                month,
+                year: None,
+            },
+            time: time::Time {
+                hour,
+                minute,
+                second: 0.0,
+                offset: None,
+            },
+        },
+    )
+    .parse_next(input)
+}
+
 #[cfg(test)]
 mod tests {
     use super::{parse, DateTime};

src/items/combined.rs

@@ -30,14 +30,14 @@ use winnow::{
     ascii::{alpha1, dec_uint},
     combinator::{alt, opt, preceded},
     seq,
-    token::take,
+    trace::trace,
     PResult, Parser,
 };
 
 use super::s;
 use crate::ParseDateTimeError;
 
-#[derive(PartialEq, Eq, Clone, Debug)]
+#[derive(PartialEq, Eq, Clone, Debug, Default)]
 pub struct Date {
     pub day: u32,
     pub month: u32,
@@ -96,27 +96,24 @@ fn literal2(input: &mut &str) -> PResult<Date> {
     .parse_next(input)
 }
 
-fn year(input: &mut &str) -> PResult<u32> {
-    s(alt((
-        take(4usize).try_map(|x: &str| x.parse()),
-        take(3usize).try_map(|x: &str| x.parse()),
-        take(2usize).try_map(|x: &str| x.parse()).map(
-            |x: u32| {
-                if x <= 68 {
-                    x + 2000
-                } else {
-                    x + 1900
-                }
-            },
-        ),
-    )))
+pub fn year(input: &mut &str) -> PResult<u32> {
+    trace(
+        "year",
+        dec_uint.try_map(|x| {
+            (0..=2147485547)
+                .contains(&x)
+                .then_some(x)
+                .ok_or(ParseDateTimeError::InvalidInput)
+        }),
+    )
     .parse_next(input)
 }
 
 fn month(input: &mut &str) -> PResult<u32> {
     s(dec_uint)
         .try_map(|x| {
-            (x >= 1 && x <= 12)
+            (1..=12)
+                .contains(&x)
                 .then_some(x)
                 .ok_or(ParseDateTimeError::InvalidInput)
         })
@@ -126,7 +123,8 @@ fn month(input: &mut &str) -> PResult<u32> {
 fn day(input: &mut &str) -> PResult<u32> {
     s(dec_uint)
         .try_map(|x| {
-            (x >= 1 && x <= 31)
+            (1..=31)
+                .contains(&x)
                 .then_some(x)
                 .ok_or(ParseDateTimeError::InvalidInput)
         })
@@ -229,4 +227,24 @@ mod tests {
             assert_eq!(parse(&mut s).unwrap(), reference);
         }
     }
+
+    #[test]
+    fn test_year() {
+        use super::year;
+
+        // the minimun input length is 2
+        assert!(year(&mut "0").is_err());
+        // 2-characters are converted to 19XX/20XX
+        assert_eq!(year(&mut "00").unwrap(), 2000u32);
+        assert_eq!(year(&mut "68").unwrap(), 2068u32);
+        assert_eq!(year(&mut "69").unwrap(), 1969u32);
+        assert_eq!(year(&mut "99").unwrap(), 1999u32);
+        // 3,4-characters are converted verbatim
+        assert_eq!(year(&mut "468").unwrap(), 468u32);
+        assert_eq!(year(&mut "469").unwrap(), 469u32);
+        assert_eq!(year(&mut "1568").unwrap(), 1568u32);
+        assert_eq!(year(&mut "1569").unwrap(), 1569u32);
+        // consumes at most 4 characters from the input
+        assert_eq!(year(&mut "1234567").unwrap(), 1234u32);
+    }
 }