formalize grammar of timestamp strings and use nom to parse them

New feature: the parser now supports timestamp strings containing
an internal decimal point (either '.' or ',').

Author: yuankunzhang

src/parse/mod.rs

@@ -1,10 +1,12 @@
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
 use relative_time::relative_times;
+use timestamp::timestamp;
 use weekday::weekday;
 
 mod primitive;
 mod relative_time;
+mod timestamp;
 mod weekday;
 
 // TODO: more specific errors?
@@ -22,6 +24,13 @@ pub(crate) fn parse_relative_times(input: &str) -> Result<Vec<RelativeTime>, Par
         .map_err(|_| ParseError)
 }
 
+/// Parses a string of timestamp into a `f64` value (the seconds since epoch).
+pub(crate) fn parse_timestamp(input: &str) -> Result<f64, ParseError> {
+    timestamp(input)
+        .map(|(_, timestamp)| timestamp)
+        .map_err(|_| ParseError)
+}
+
 /// Parses a string of weekday into a `WeekdayItem` struct.
 pub(crate) fn parse_weekday(input: &str) -> Result<WeekdayItem, ParseError> {
     weekday(input)

src/parse/primitive.rs

@@ -69,7 +69,7 @@ pub(super) fn integer(input: &str) -> IResult<&str, i64> {
 /// sign characters and whitespace characters. All but the last sign character
 /// is ignored, and the last sign character is returned as the result. This
 /// quirky behavior is to stay consistent with GNU date.
-fn sign(input: &str) -> IResult<&str, char> {
+pub(super) fn sign(input: &str) -> IResult<&str, char> {
     fold_many1(
         terminated(one_of("+-"), multispace0),
         || '+',

src/parse/timestamp.rs

@@ -0,0 +1,73 @@
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+
+//! Module to parser timestamp strings.
+//!
+//! Grammar definition:
+//!
+//! ```ebnf
+//! timestamp = "@" seconds ;
+//!
+//! seconds = [ sign ] , { digit } , [ ("." | ",") , { digit } ] ;
+//! ```
+
+use nom::{
+    bytes::complete::tag,
+    character::complete::{digit1, one_of},
+    combinator::{all_consuming, map_res, opt, recognize},
+    sequence::preceded,
+    IResult, Parser,
+};
+
+use super::primitive::sign;
+
+pub(super) fn timestamp(input: &str) -> IResult<&str, f64> {
+    all_consuming(preceded(tag("@"), seconds)).parse(input)
+}
+
+fn seconds(input: &str) -> IResult<&str, f64> {
+    let (rest, sign) = opt(sign).parse(input)?;
+    let (rest, num) = map_res(
+        recognize((digit1, opt((one_of(".,"), digit1)))),
+        |s: &str| {
+            s.replace(",", ".")
+                .parse::<f64>()
+                .map_err(|_| "invalid seconds")
+        },
+    )
+    .parse(rest)?;
+
+    let num = if sign == Some('-') { -num } else { num };
+    Ok((rest, num))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_timestamp() {
+        assert!(timestamp("invalid").is_err());
+
+        assert_eq!(timestamp("@-1234.567"), Ok(("", -1234.567)));
+        assert_eq!(timestamp("@1234,567"), Ok(("", 1234.567)));
+        assert_eq!(timestamp("@- 1234.567"), Ok(("", -1234.567)));
+        assert_eq!(timestamp("@-+- 1234,567"), Ok(("", -1234.567)));
+        assert_eq!(timestamp("@1234"), Ok(("", 1234.0)));
+        assert_eq!(timestamp("@-1234"), Ok(("", -1234.0)));
+    }
+
+    #[test]
+    fn test_seconds() {
+        assert!(seconds("").is_err());
+        assert!(seconds("invalid").is_err());
+
+        assert_eq!(seconds("-1234.567"), Ok(("", -1234.567)));
+        assert_eq!(seconds("1234,567"), Ok(("", 1234.567)));
+        assert_eq!(seconds("- 1234.567"), Ok(("", -1234.567)));
+        assert_eq!(seconds("-+- 1234,567"), Ok(("", -1234.567)));
+        assert_eq!(seconds("1234"), Ok(("", 1234.0)));
+        assert_eq!(seconds("-1234"), Ok(("", -1234.0)));
+        assert_eq!(seconds("1234.567abc"), Ok(("abc", 1234.567)));
+    }
+}

src/parse/weekday.rs

@@ -14,7 +14,7 @@
 //!     | "wednesday" | "wednes" | "wed"
 //!     | "thursday" | "thurs" | "thur" | "thu"
 //!     | "friday" | "fri"
-//!     | "saturday" | "sat"
+//!     | "saturday" | "sat" ;
 //! ```
 
 use chrono::Weekday;

src/parse_timestamp.rs

@@ -1,84 +1,13 @@
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
-use core::fmt;
-use std::error::Error;
-use std::fmt::Display;
-use std::num::ParseIntError;
-
-use nom::branch::alt;
-use nom::character::complete::{char, digit1};
-use nom::combinator::all_consuming;
-use nom::multi::fold_many0;
-use nom::sequence::preceded;
-use nom::{self, IResult, Parser};
-
-#[derive(Debug, PartialEq)]
-pub enum ParseTimestampError {
-    InvalidNumber(ParseIntError),
-    InvalidInput,
-}
-
-impl Display for ParseTimestampError {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-            Self::InvalidInput => {
-                write!(f, "Invalid input string: cannot be parsed as a timestamp")
-            }
-            Self::InvalidNumber(err) => {
-                write!(f, "Invalid timestamp number: {err}")
-            }
-        }
-    }
-}
-
-impl Error for ParseTimestampError {}
-
-// TODO is this necessary
-impl From<ParseIntError> for ParseTimestampError {
-    fn from(err: ParseIntError) -> Self {
-        Self::InvalidNumber(err)
-    }
-}
-
-type NomError<'a> = nom::Err<nom::error::Error<&'a str>>;
-
-impl<'a> From<NomError<'a>> for ParseTimestampError {
-    fn from(_err: NomError<'a>) -> Self {
-        Self::InvalidInput
-    }
-}
-
-pub(crate) fn parse_timestamp(s: &str) -> Result<i64, ParseTimestampError> {
-    let s = s.trim().to_lowercase();
-    let s = s.as_str();
-
-    let res: IResult<&str, (char, &str)> = all_consuming(preceded(
-        char('@'),
-        (
-            // Note: to stay compatible with gnu date this code allows
-            // multiple + and - and only considers the last one
-            fold_many0(
-                // parse either + or -
-                alt((char('+'), char('-'))),
-                // start with a +
-                || '+',
-                // whatever we get (+ or -), update the accumulator to that value
-                |_, c| c,
-            ),
-            digit1,
-        ),
-    ))
-    .parse(s);
-
-    let (_, (sign, number_str)) = res?;
-
-    let mut number = number_str.parse::<i64>()?;
-
-    if sign == '-' {
-        number *= -1;
-    }
-
-    Ok(number)
+use crate::{parse, ParseDateTimeError};
+
+pub(crate) fn parse_timestamp(s: &str) -> Result<i64, ParseDateTimeError> {
+    // If the timestamp contains excess precision, it is truncated toward minus
+    // infinity.
+    parse::parse_timestamp(s)
+        .map(|f| f.floor() as i64)
+        .map_err(|_| ParseDateTimeError::InvalidInput)
 }
 
 #[cfg(test)]
@@ -100,6 +29,10 @@ mod tests {
         assert_eq!(parse_timestamp("@+++-12"), Ok(-12));
         assert_eq!(parse_timestamp("@+----+12"), Ok(12));
         assert_eq!(parse_timestamp("@++++-123"), Ok(-123));
+
+        // with excess precision
+        assert_eq!(parse_timestamp("@1234.567"), Ok(1234));
+        assert_eq!(parse_timestamp("@-1234,567"), Ok(-1235));
     }
 
     #[test]