git-date parse draft

git-date/Cargo.toml

@@ -18,12 +18,14 @@ serde1 = ["serde", "bstr/serde1"]
 bstr = { version = "0.2.13", default-features = false, features = ["std"]}
 serde = { version = "1.0.114", optional = true, default-features = false, features = ["derive"]}
 itoa = "1.0.1"
-time = { version = "0.3.2", default-features = false, features = ["local-offset", "formatting", "macros"] }
+time = { version = "0.3.2", default-features = false, features = ["local-offset", "formatting", "macros", "parsing"] }
+thiserror = "1.0.32"
 
 document-features = { version = "0.2.0", optional = true }
 
 [dev-dependencies]
 git-testtools = { path = "../tests/tools"}
+once_cell = "1.12.0"
 
 [package.metadata.docs.rs]
 all-features = true

git-date/src/parse.rs

@@ -1,11 +1,119 @@
+use crate::time::format::{DEFAULT, ISO8601, ISO8601_STRICT, RFC2822, SHORT};
+use crate::time::Sign;
 use crate::Time;
+use std::convert::TryInto;
+use std::num::TryFromIntError;
+use std::str::FromStr;
+use std::time::SystemTime;
+use time::{Date, OffsetDateTime};
 
+#[derive(thiserror::Error, Debug)]
 #[allow(missing_docs)]
-pub fn parse(input: &str) -> Option<Time> {
+pub enum Error {
+    #[error("Date string can not be parsed")]
+    InvalidDateString,
+    #[error("Relative period can not be parsed")]
+    InvalidPeriod,
+    #[error("Dates past 2038 can not be represented.")]
+    InvalidDate(#[from] TryFromIntError),
+    #[error("Current time is missing.")]
+    MissingCurrentTime,
+}
+
+#[allow(missing_docs)]
+pub fn parse(input: &str, now: Option<SystemTime>) -> Result<Time, Error> {
     // TODO: actual implementation, this is just to not constantly fail
     if input == "1979-02-26 18:30:00" {
-        Some(Time::new(42, 1800))
+        Ok(Time::new(42, 1800))
     } else {
-        None
+        return if let Ok(val) = Date::parse(input, SHORT) {
+            let val = val.with_hms(0, 0, 0).expect("date is in range").assume_utc();
+            Ok(Time::new(
+                val.unix_timestamp().try_into()?,
+                val.offset().whole_seconds(),
+            ))
+        } else if let Ok(val) = OffsetDateTime::parse(input, RFC2822) {
+            Ok(Time::new(
+                val.unix_timestamp().try_into()?,
+                val.offset().whole_seconds(),
+            ))
+        } else if let Ok(val) = OffsetDateTime::parse(input, ISO8601) {
+            Ok(Time::new(
+                val.unix_timestamp().try_into()?,
+                val.offset().whole_seconds(),
+            ))
+        } else if let Ok(val) = OffsetDateTime::parse(input, ISO8601_STRICT) {
+            Ok(Time::new(
+                val.unix_timestamp().try_into()?,
+                val.offset().whole_seconds(),
+            ))
+        } else if let Ok(val) = OffsetDateTime::parse(input, DEFAULT) {
+            Ok(Time::new(
+                val.unix_timestamp().try_into()?,
+                val.offset().whole_seconds(),
+            ))
+        } else if let Ok(val) = u32::from_str(input) {
+            // Format::Unix
+            Ok(Time::new(val, 0))
+        } else if let Some(val) = parse_raw(input) {
+            // Format::Raw
+            Ok(val)
+        } else if let Some(val) = relative::parse(input, now.ok_or(Error::MissingCurrentTime)?) {
+            Ok(Time::new(
+                val.unix_timestamp().try_into()?,
+                val.offset().whole_seconds(),
+            ))
+        } else {
+            Err(Error::InvalidDateString)
+        };
+    }
+}
+
+fn parse_raw(input: &str) -> Option<Time> {
+    let mut split = input.split_whitespace();
+    let seconds_since_unix_epoch: u32 = split.next()?.parse().ok()?;
+    let offset = split.next()?;
+    if offset.len() != 5 {
+        return None;
+    }
+    let sign = if &offset[..1] == "-" { Sign::Plus } else { Sign::Minus };
+    let hours: i32 = offset[1..3].parse().ok()?;
+    let minutes: i32 = offset[3..5].parse().ok()?;
+    let offset_in_seconds = hours * 3600 + minutes * 60;
+    let time = Time {
+        seconds_since_unix_epoch,
+        offset_in_seconds,
+        sign,
+    };
+    Some(time)
+}
+
+mod relative {
+    use crate::parse::Error;
+    use std::str::FromStr;
+    use std::time::SystemTime;
+    use time::{Duration, OffsetDateTime};
+
+    pub(crate) fn parse(input: &str, now: SystemTime) -> Option<OffsetDateTime> {
+        let mut split = input.split_whitespace();
+        let multiplier = i64::from_str(split.next()?).ok()?;
+        let period = split.next()?;
+        if split.next()? != "ago" {
+            return None;
+        }
+        OffsetDateTime::from(now).checked_sub(duration(period, multiplier).ok()?)
+    }
+
+    fn duration(period: &str, multiplier: i64) -> Result<Duration, Error> {
+        let period = period.strip_suffix("s").unwrap_or(period);
+        return match period {
+            "second" => Ok(Duration::seconds(multiplier)),
+            "minute" => Ok(Duration::minutes(multiplier)),
+            "hour" => Ok(Duration::hours(multiplier)),
+            "day" => Ok(Duration::days(multiplier)),
+            "week" => Ok(Duration::weeks(multiplier)),
+            // TODO months & years
+            _ => Err(Error::InvalidPeriod),
+        };
     }
 }

git-date/tests/fixtures/generate_git_date_baseline.sh

@@ -0,0 +1,46 @@
+#!/bin/bash
+set -eu -o pipefail
+
+git init;
+
+function baseline() {
+    local test_date=$1 # first argument is the date to test
+
+    git -c section.key="$test_date" config --type=expiry-date section.key && status=0 || status=$?
+    {
+        echo "$test_date"
+        echo "$status"
+        if [ $status == 0 ]
+        then
+          git -c section.key="$test_date" config --type=expiry-date section.key
+        else
+          echo "-1"
+        fi
+    } >> baseline.git
+}
+
+# success
+
+# date formats following to https://git-scm.com/docs/git-log#Documentation/git-log.txt---dateltformatgt
+
+# short
+# ODO
+#baseline '2022-08-22'
+# rfc2822
+baseline 'Thu, 18 Aug 2022 12:45:06 +0800'
+# iso8601
+baseline '2022-08-17 22:04:58 +0200'
+# iso8601_strict
+baseline '2022-08-17T21:43:13+08:00'
+# default
+baseline 'Thu Sep 04 2022 10:45:06 -0400'
+# unix
+baseline '123456789'
+# raw
+baseline '1660874655 +0800'
+
+# failing
+
+# empty_input
+baseline ""
+

git-date/tests/time/parse.rs

@@ -1,14 +1,98 @@
+use bstr::{BString, ByteSlice};
 use git_date::time::Sign;
 use git_date::Time;
+use once_cell::sync::Lazy;
+use std::collections::HashMap;
+use std::str::FromStr;
+use std::time::SystemTime;
+use time::{Duration, OffsetDateTime};
+
+type Result<T = ()> = std::result::Result<T, Box<dyn std::error::Error>>;
+
+static BASELINE: Lazy<HashMap<BString, (usize, BString)>> = Lazy::new(|| {
+    let base = git_testtools::scripted_fixture_repo_read_only("generate_git_date_baseline.sh").unwrap();
+
+    (|| -> Result<_> {
+        let mut map = HashMap::new();
+        let baseline = std::fs::read(base.join("baseline.git"))?;
+        let mut lines = baseline.lines();
+        while let Some(date_str) = lines.next() {
+            let exit_code = lines.next().expect("three lines per baseline").to_str()?.parse()?;
+            let output = lines.next().expect("three lines per baseline").into();
+            map.insert(date_str.into(), (exit_code, output));
+        }
+        Ok(map)
+    })()
+    .unwrap()
+});
+
+#[test]
+fn baseline() {
+    for (pattern, (exit_code, output)) in BASELINE.iter() {
+        let res = git_date::parse(pattern.to_str().expect("valid pattern"), Some(SystemTime::now()));
+        assert_eq!(
+            res.is_ok(),
+            *exit_code == 0,
+            "{pattern:?} disagrees with baseline: {res:?}"
+        );
+        if *exit_code == 0 {
+            let actual = res.unwrap().seconds_since_unix_epoch;
+            let expected = u32::from_str(output.to_str().expect("valid utf")).expect("valid epoch value");
+            assert_eq!(actual, expected, "{pattern:?} disagrees with baseline: {actual:?}")
+        }
+    }
+}
 
 #[test]
 fn special_time_is_ok_for_now() {
     assert_eq!(
-        git_date::parse("1979-02-26 18:30:00").unwrap(),
+        git_date::parse("1979-02-26 18:30:00", Some(SystemTime::now())).unwrap(),
         Time {
             seconds_since_unix_epoch: 42,
             offset_in_seconds: 1800,
             sign: Sign::Plus,
         }
     );
 }
+
+#[test]
+fn short() {
+    assert_eq!(
+        git_date::parse("1979-02-26", Some(SystemTime::now())).expect("parsed date"),
+        Time {
+            seconds_since_unix_epoch: 288835200,
+            offset_in_seconds: 0,
+            sign: Sign::Plus,
+        },
+        "could not parse with SHORT format"
+    );
+}
+
+#[test]
+fn rfc2822() {
+    assert_eq!(
+        git_date::parse("Thu, 18 Aug 2022 12:45:06 +0800", Some(SystemTime::now())).expect("parsed rfc2822 string"),
+        Time {
+            seconds_since_unix_epoch: 1660797906,
+            offset_in_seconds: 28800,
+            sign: Sign::Plus,
+        },
+        "could not parse with RFC2822 format"
+    );
+}
+
+#[test]
+fn relative() {
+    let now = Some(SystemTime::now());
+    let two_weeks_ago = git_date::parse("2 weeks ago", now).expect("valid time");
+    assert_eq!(Sign::Plus, two_weeks_ago.sign);
+    assert_eq!(0, two_weeks_ago.offset_in_seconds);
+    let expected = OffsetDateTime::from(now.unwrap()).saturating_sub(Duration::weeks(2));
+    // account for the loss of precision when creating `Time` with seconds
+    let expected = expected.replace_nanosecond(0).unwrap();
+    assert_eq!(
+        OffsetDateTime::from_unix_timestamp(two_weeks_ago.seconds_since_unix_epoch as i64).expect("valid datetime"),
+        expected,
+        "relative times differ"
+    );
+}

git-repository/src/repository/identity.rs

@@ -1,4 +1,5 @@
 use std::borrow::Cow;
+use std::time::SystemTime;
 
 use crate::{bstr::BString, permission};
 
@@ -125,13 +126,13 @@ impl Personas {
             committer_email = committer_email.or_else(|| env_var("GIT_COMMITTER_EMAIL"));
             committer_date = std::env::var("GIT_COMMITTER_DATE")
                 .ok()
-                .and_then(|date| git_date::parse(&date));
+                .and_then(|date| git_date::parse(&date, Some(SystemTime::now())).ok());
 
             author_name = author_name.or_else(|| env_var("GIT_AUTHOR_NAME"));
             author_email = author_email.or_else(|| env_var("GIT_AUTHOR_EMAIL"));
             author_date = std::env::var("GIT_AUTHOR_DATE")
                 .ok()
-                .and_then(|date| git_date::parse(&date));
+                .and_then(|date| git_date::parse(&date, Some(SystemTime::now())).ok());
 
             user_email = user_email.or_else(|| env_var("EMAIL")); // NOTE: we don't have permission for this specific one…
         }

git-revision/src/spec/parse/function.rs

@@ -1,3 +1,4 @@
+use std::time::SystemTime;
 use std::{convert::TryInto, str::FromStr};
 
 use bstr::{BStr, BString, ByteSlice, ByteVec};
@@ -435,7 +436,7 @@ where
                 let time = nav
                     .to_str()
                     .ok()
-                    .and_then(git_date::parse)
+                    .and_then(|v| git_date::parse(v, Some(SystemTime::now())).ok())
                     .ok_or_else(|| Error::Time { input: nav.into() })?;
                 delegate
                     .reflog(delegate::ReflogLookup::Date(time))