fix(gix-date): add parse_raw()

When parsing arbitrary date inputs from the user with gix_date::parse(),
the non-strict gix_date::parse_header() would accept a variety of inputs
that do not match any of the known/accepted formats, but would
nonetheless be accepted as being "close enough" to a raw date as found
in git commit headers.

The new parse_raw() function takes a stricter approach to parsing raw
dates as found in commit headers, only accepting inputs that
unambiguously match a valid raw date.

The gix_date::parse() function is updated to use the new parse_raw()
function instead of the less-strict parse_header(). This has the effect
of making gix_date::parse() avoid mis-parsing various inputs that would
otherwise have been accepted by gix_date::parse_header(). For example
"28 Jan 2005".

Author: jpgrayson

gix-date/src/lib.rs

@@ -13,7 +13,7 @@ pub mod time;
 
 ///
 pub mod parse;
-pub use parse::function::{parse, parse_header};
+pub use parse::function::{parse, parse_header, parse_raw};
 
 /// A timestamp with timezone.
 #[derive(Default, PartialEq, Eq, Debug, Hash, Ord, PartialOrd, Clone, Copy)]

gix-date/src/parse.rs

@@ -165,7 +165,7 @@ pub(crate) mod function {
             Time::new(val, 0)
         } else if let Some(val) = relative::parse(input, now).transpose()? {
             Time::new(val.timestamp().as_second(), val.offset().seconds())
-        } else if let Some(val) = parse_header(input) {
+        } else if let Some(val) = parse_raw(input) {
             // Format::Raw
             val
         } else {
@@ -236,6 +236,52 @@ pub(crate) mod function {
         Some(time)
     }
 
+    /// Strictly parse the raw commit header format like `1745582210 +0200`.
+    ///
+    /// Some strict rules include:
+    ///
+    /// - The timezone offset must be present.
+    /// - The timezone offset must have a sign; either `+` or `-`.
+    /// - The timezone offset hours must be less than or equal to 14.
+    /// - The timezone offset minutes must be exactly 0, 15, 30, or 45.
+    /// - The timezone offset seconds may be present, but 0 is the only valid value.
+    /// - Only whitespace may suffix the timezone offset.
+    ///
+    /// But this function isn't perfectly strict insofar as it allows arbitrary
+    /// whitespace before and after the seconds and offset components.
+    ///
+    /// The goal is to only accept inputs that _unambiguously_ look like
+    /// git's raw date format.
+    pub fn parse_raw(input: &str) -> Option<Time> {
+        let mut split = input.split_whitespace();
+        let seconds = split.next()?.parse::<SecondsSinceUnixEpoch>().ok()?;
+        let offset_str = split.next()?;
+        if split.next().is_some() {
+            return None;
+        }
+        let offset_len = offset_str.len();
+        if offset_len != 5 && offset_len != 7 {
+            return None;
+        }
+        let sign: i32 = match offset_str.get(..1)? {
+            "-" => Some(-1),
+            "+" => Some(1),
+            _ => None,
+        }?;
+        let hours: u8 = offset_str.get(1..3)?.parse().ok()?;
+        let minutes: u8 = offset_str.get(3..5)?.parse().ok()?;
+        let offset_seconds: u8 = if offset_len == 7 {
+            offset_str.get(5..7)?.parse().ok()?
+        } else {
+            0
+        };
+        if hours > 14 || (minutes != 0 && minutes != 15 && minutes != 30 && minutes != 45) || offset_seconds != 0 {
+            return None;
+        }
+        let offset: i32 = sign * ((hours as i32) * 3600 + (minutes as i32) * 60);
+        Some(Time { seconds, offset })
+    }
+
     /// This is just like `Zoned::strptime`, but it allows parsing datetimes
     /// whose weekdays are inconsistent with the date. While the day-of-week
     /// still must be parsed, it is otherwise ignored. This seems to be

gix-date/tests/time/mod.rs

@@ -101,7 +101,7 @@ mod write_to {
             assert_eq!(output.as_bstr(), expected);
             assert_eq!(time.size(), output.len());
 
-            let actual = gix_date::parse(&output.as_bstr().to_string(), None).expect("round-trippable");
+            let actual = output.as_bstr().to_string().parse::<Time>().expect("round-trippable");
             assert_eq!(time, actual);
         }
         Ok(())

gix-date/tests/time/parse.rs

@@ -83,22 +83,27 @@ fn raw() -> gix_testtools::Result {
     );
 
     assert_eq!(
-        gix_date::parse("1313584730 +051800", None)?,
+        gix_date::parse("1313584730 +051500", None)?,
         Time {
             seconds: 1313584730,
-            offset: 19080,
+            offset: 18900,
         },
         "seconds for time-offsets work as well"
     );
 
     assert_eq!(
-        gix_date::parse("1313584730 +051842", None)?,
+        gix_date::parse("1313584730 -0230", None)?,
         Time {
             seconds: 1313584730,
-            offset: 19122,
+            offset: -150 * 60,
         },
     );
 
+    assert!(gix_date::parse("1313584730 +1500", None).is_err());
+    assert!(gix_date::parse("1313584730 +000001", None).is_err());
+    assert!(gix_date::parse("1313584730 +0001", None).is_err());
+    assert!(gix_date::parse("1313584730 +000100", None).is_err());
+
     let expected = Time {
         seconds: 1660874655,
         offset: -28800,
@@ -117,6 +122,39 @@ fn raw() -> gix_testtools::Result {
     Ok(())
 }
 
+#[test]
+fn bad_raw_strict() {
+    for bad_date_str in [
+        "123456 !0600",
+        "123456 0600",
+        "123456 +060",
+        "123456 -060",
+        "123456 +06000",
+        "123456 --060",
+        "123456 -+060",
+        "123456 --0600",
+        "123456 +-06000",
+        "123456 +-0600",
+        "123456 +-060",
+        "123456 +10030",
+        "123456 06000",
+        "123456  0600",
+        "123456 +0600 extra",
+        "123456 +0600 2005",
+        "123456+0600",
+        "123456 + 600",
+        "123456 -1500",
+        "123456 +1500",
+        "123456 +6600",
+        "123456 +0660",
+        "123456 +060010",
+        "123456 -060010",
+        "123456 +0075",
+    ] {
+        assert!(gix_date::parse_raw(bad_date_str).is_none());
+    }
+}
+
 #[test]
 fn bad_raw() {
     for bad_date_str in [