refactor

- make `parse_raw()` private as it will proabbloy be merged into `parse_header()` one day.
- add more tests for good measure

Author: Byron

gix-date/src/lib.rs

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

gix-date/src/parse.rs

@@ -252,7 +252,7 @@ pub(crate) mod function {
     ///
     /// The goal is to only accept inputs that _unambiguously_ look like
     /// git's raw date format.
-    pub fn parse_raw(input: &str) -> Option<Time> {
+    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()?;
@@ -279,7 +279,7 @@ pub(crate) mod function {
             return None;
         }
         let offset: i32 = sign * ((hours as i32) * 3600 + (minutes as i32) * 60);
-        Some(Time { seconds, offset })
+        Time { seconds, offset }.into()
     }
 
     /// This is just like `Zoned::strptime`, but it allows parsing datetimes
@@ -298,6 +298,75 @@ pub(crate) mod function {
         static P: rfc2822::DateTimeParser = rfc2822::DateTimeParser::new().relaxed_weekday(true);
         P.parse_zoned(input)
     }
+
+    #[cfg(test)]
+    mod tests {
+        use super::*;
+
+        #[test]
+        fn parse_raw_valid() {
+            // These examples show how it's more loose than it has to be,
+            // merely as a side effect of the implementation.
+            for (valid, expected_seconds, expected_offset) in [
+                ("12345 +0000", 12345, 0),
+                ("-1234567 +0000", -1234567, 0),
+                ("+1234567 -000000", 1234567, 0),
+                ("   +0    -000000    ", 0, 0),
+                ("\t-0\t-0000\t", 0, 0),
+                ("\n-0\r\n-0000\n", 0, 0),
+            ] {
+                assert_eq!(
+                    parse_raw(valid),
+                    Some(Time {
+                        seconds: expected_seconds,
+                        offset: expected_offset
+                    }),
+                    "should succeed: '{valid}'"
+                );
+            }
+        }
+
+        #[test]
+        fn parse_raw_invalid() {
+            for (bad_date_str, message) in [
+                ("123456 !0600", "invalid sign - must be + or -"),
+                ("123456 0600", "missing offset sign"),
+                ("123456 +060", "positive offset too short"),
+                ("123456 -060", "negative offset too short"),
+                ("123456 +06000", "not enough offset seconds"),
+                ("123456 --060", "duplicate offset sign with correct offset length"),
+                ("123456 -+060", "multiple offset signs with correct offset length"),
+                ("123456 --0600", "multiple offset signs, but incorrect offset length"),
+                ("123456 +-06000", "multiple offset signs with correct offset length"),
+                ("123456 +-0600", "multiple offset signs with incorrect offset length"),
+                ("123456 +-060", "multiple offset signs with correct offset length"),
+                ("123456 +10030", "invalid offset length with one 'second' field"),
+                ("123456 06000", "invalid offset length, missing sign"),
+                ("123456 +0600 extra", "extra field past offset"),
+                ("123456 +0600 2005", "extra field past offset that looks like year"),
+                ("123456+0600", "missing space between unix timestamp and offset"),
+                (
+                    "123456 + 600",
+                    "extra spaces between sign and offset (which also is too short)",
+                ),
+                ("123456 -1500", "negative offset hours out of bounds"),
+                ("123456 +1500", "positive offset hours out of bounds"),
+                ("123456 +6600", "positive offset hours out of bounds"),
+                ("123456 +0660", "invalid offset minutes"),
+                ("123456 +060010", "positive offset seconds is allowed but only if zero"),
+                ("123456 -060010", "negative offset seconds is allowed but only if zero"),
+                ("123456 +0075", "positive offset minutes invalid"),
+                ("++123456 +0000", "duplicate timestamp sign"),
+                ("--123456 +0000", "duplicate timestamp sign"),
+                ("1234567 -+1+1+0", "unsigned offset parsing rejects '+'"),
+            ] {
+                assert!(
+                    parse_raw(bad_date_str).is_none(),
+                    "should fail: '{bad_date_str}': {message}"
+                );
+            }
+        }
+    }
 }
 
 mod relative {

gix-date/tests/time/parse.rs

@@ -122,39 +122,6 @@ 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 [