feat: Expose parsing for Time

`gix_date::Time` can be parsed in two ways:
* From raw bytes (in the data format Git adheres too)
* From the date format used in gix config

Add utility constructors for these two cases.

When parsing from raw bytes, also support a format like `<sign><HH><MM><SS>`
since this is a situation that happens in the wild and that Git can handle.

Author: Pierre Chevalier

gix-date/src/lib.rs

@@ -15,7 +15,11 @@ pub mod time;
 
 ///
 pub mod parse;
+use bstr::{BStr, ByteSlice};
 pub use parse::function::parse;
+use parse::function::parse_raw;
+use parse::Error;
+use std::time::SystemTime;
 
 /// A timestamp with timezone.
 #[derive(PartialEq, Eq, Debug, Hash, Ord, PartialOrd, Clone, Copy)]
@@ -29,6 +33,19 @@ pub struct Time {
     pub sign: time::Sign,
 }
 
+impl Time {
+    /// Parse date in config format into a Time
+    pub fn from_config(i: &BStr) -> Result<Self, Error> {
+        let s = i.as_bstr().to_str().expect("Input must be ascii");
+        parse(s, Some(SystemTime::now()))
+    }
+    /// Parse raw bytes into a Time
+    pub fn from_bytes(i: &BStr) -> Result<Self, Error> {
+        let s = i.as_bstr().to_str().expect("Input must be ascii");
+        parse_raw(s).ok_or(Error::InvalidDateString { input: s.into() })
+    }
+}
+
 /// The amount of seconds since unix epoch.
 ///
 /// Note that negative dates represent times before the unix epoch.

gix-date/src/parse.rs

@@ -60,11 +60,11 @@ pub(crate) mod function {
         })
     }
 
-    fn parse_raw(input: &str) -> Option<Time> {
+    pub(crate) fn parse_raw(input: &str) -> Option<Time> {
         let mut split = input.split_whitespace();
         let seconds: SecondsSinceUnixEpoch = split.next()?.parse().ok()?;
         let offset = split.next()?;
-        if offset.len() != 5 || split.next().is_some() {
+        if (offset.len() != 5) && (offset.len() != 7) || split.next().is_some() {
             return None;
         }
         let sign = match offset.get(..1)? {
@@ -74,7 +74,12 @@ pub(crate) mod function {
         }?;
         let hours: i32 = offset.get(1..3)?.parse().ok()?;
         let minutes: i32 = offset.get(3..5)?.parse().ok()?;
-        let mut offset_in_seconds = hours * 3600 + minutes * 60;
+        let offset_seconds: i32 = if offset.len() == 7 {
+            offset.get(5..7)?.parse().ok()?
+        } else {
+            0
+        };
+        let mut offset_in_seconds = hours * 3600 + minutes * 60 + offset_seconds;
         if sign == Sign::Minus {
             offset_in_seconds *= -1;
         }

gix-date/tests/time/parse.rs

@@ -76,6 +76,24 @@ fn raw() {
         },
     );
 
+    assert_eq!(
+        gix_date::parse("1313584730 +051800", None).unwrap(),
+        Time {
+            seconds: 1313584730,
+            offset: 19080,
+            sign: Sign::Plus,
+        },
+    );
+
+    assert_eq!(
+        gix_date::parse("1313584730 +051842", None).unwrap(),
+        Time {
+            seconds: 1313584730,
+            offset: 19122,
+            sign: Sign::Plus,
+        },
+    );
+
     let expected = Time {
         seconds: 1660874655,
         offset: -28800,
@@ -88,6 +106,7 @@ fn raw() {
         "  1660874655 -0800  ",
         "  1660874655  -0800  ",
         "1660874655\t-0800",
+        "1660874655\t-080000",
     ] {
         assert_eq!(gix_date::parse(date_str, None).unwrap(), expected);
     }