From 43b6c064bfa407d1a2cabf09aad1cc8334dec651 Mon Sep 17 00:00:00 2001
From: Svetlin Stefanov <s.m.stefanov@gmail.com>
Date: Tue, 23 Aug 2022 22:55:03 +0200
Subject: [PATCH 01/11] Draft.

---
 git-date/Cargo.toml          |  2 +-
 git-date/src/parse.rs        | 41 +++++++++++++++++++++++++++++++++++-
 git-date/tests/time/parse.rs | 35 ++++++++++++++++++++++++++++++
 3 files changed, 76 insertions(+), 2 deletions(-)

diff --git a/git-date/Cargo.toml b/git-date/Cargo.toml
index ee21c19a3ba..efa275e0782 100644
--- a/git-date/Cargo.toml
+++ b/git-date/Cargo.toml
@@ -18,7 +18,7 @@ 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"] }
 
 document-features = { version = "0.2.0", optional = true }
 
diff --git a/git-date/src/parse.rs b/git-date/src/parse.rs
index 40f8ae3cb77..7a61b4f83e5 100644
--- a/git-date/src/parse.rs
+++ b/git-date/src/parse.rs
@@ -1,4 +1,6 @@
+use crate::time::format::{RFC2822, SHORT};
 use crate::Time;
+use time::{Date, OffsetDateTime};
 
 #[allow(missing_docs)]
 pub fn parse(input: &str) -> Option<Time> {
@@ -6,6 +8,43 @@ pub fn parse(input: &str) -> Option<Time> {
     if input == "1979-02-26 18:30:00" {
         Some(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();
+            Some(Time::new(val.unix_timestamp() as u32, val.offset().whole_seconds()))
+        } else if let Ok(val) = OffsetDateTime::parse(input, RFC2822) {
+            Some(Time::new(val.unix_timestamp() as u32, val.offset().whole_seconds()))
+        } else if let Some(val) = relative::parse(input) {
+            Some(Time::new(val.unix_timestamp() as u32, val.offset().whole_seconds()))
+        } else {
+            None
+        };
+    }
+}
+
+mod relative {
+    use std::str::FromStr;
+    use time::{Duration, OffsetDateTime};
+
+    pub(crate) fn parse(input: &str) -> Option<OffsetDateTime> {
+        let split: Vec<&str> = input.split_whitespace().collect();
+        if split.len() != 3 || *split.last().expect("slice has length 3") != "ago" {
+            return None;
+        }
+        let multiplier = i64::from_str(split[0]).ok()?;
+        let period = period_to_seconds(split[1])?;
+        Some(OffsetDateTime::now_utc().checked_sub(Duration::seconds(multiplier * period))?)
+    }
+
+    fn period_to_seconds(period: &str) -> Option<i64> {
+        let period = period.strip_suffix("s").unwrap_or(period);
+        return match period {
+            "second" => Some(1),
+            "minute" => Some(60),
+            "hour" => Some(60 * 60),
+            "day" => Some(24 * 60 * 60),
+            "week" => Some(7 * 24 * 60 * 60),
+            // TODO months & years
+            _ => None,
+        };
     }
 }
diff --git a/git-date/tests/time/parse.rs b/git-date/tests/time/parse.rs
index c281eb3883c..c231958d367 100644
--- a/git-date/tests/time/parse.rs
+++ b/git-date/tests/time/parse.rs
@@ -1,5 +1,6 @@
 use git_date::time::Sign;
 use git_date::Time;
+use time::OffsetDateTime;
 
 #[test]
 fn special_time_is_ok_for_now() {
@@ -12,3 +13,37 @@ fn special_time_is_ok_for_now() {
         }
     );
 }
+
+#[test]
+fn parse() {
+    assert_eq!(
+        git_date::parse("1979-02-26"),
+        Some(Time {
+            seconds_since_unix_epoch: 288835200,
+            offset_in_seconds: 0,
+            sign: Sign::Plus,
+        }),
+        "could not parse with SHORT format"
+    );
+
+    assert_eq!(
+        git_date::parse("Thu, 18 Aug 2022 12:45:06 +0800"),
+        Some(Time {
+            seconds_since_unix_epoch: 1660797906,
+            offset_in_seconds: 28800,
+            sign: Sign::Plus,
+        }),
+        "could not parse with RFC2822 format"
+    );
+
+    let two_weeks_ago = git_date::parse("2 weeks ago").expect("valid time");
+    assert_eq!(Sign::Plus, two_weeks_ago.sign);
+    assert_eq!(0, two_weeks_ago.offset_in_seconds);
+    assert_eq!(
+        OffsetDateTime::from_unix_timestamp(two_weeks_ago.seconds_since_unix_epoch as i64)
+            .expect("valid datetime")
+            .iso_week(),
+        OffsetDateTime::now_utc().iso_week() - 2,
+        "weeks numbers differ"
+    );
+}

From 95b490230ebfbd4c2f04edd7074d5a0f5e2429ec Mon Sep 17 00:00:00 2001
From: Svetlin Stefanov <s.m.stefanov@gmail.com>
Date: Tue, 23 Aug 2022 23:35:20 +0200
Subject: [PATCH 02/11] Draft.

---
 git-date/src/parse.rs | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/git-date/src/parse.rs b/git-date/src/parse.rs
index 7a61b4f83e5..1d62efe5c09 100644
--- a/git-date/src/parse.rs
+++ b/git-date/src/parse.rs
@@ -26,12 +26,12 @@ mod relative {
     use time::{Duration, OffsetDateTime};
 
     pub(crate) fn parse(input: &str) -> Option<OffsetDateTime> {
-        let split: Vec<&str> = input.split_whitespace().collect();
-        if split.len() != 3 || *split.last().expect("slice has length 3") != "ago" {
+        let mut split = input.split_whitespace();
+        let multiplier = i64::from_str(split.next()?).ok()?;
+        let period = period_to_seconds(split.next()?)?;
+        if split.next()? != "ago" {
             return None;
         }
-        let multiplier = i64::from_str(split[0]).ok()?;
-        let period = period_to_seconds(split[1])?;
         Some(OffsetDateTime::now_utc().checked_sub(Duration::seconds(multiplier * period))?)
     }
 

From 3e6e0f9ebdf7ab87c689be074ae1eecfea4485f0 Mon Sep 17 00:00:00 2001
From: Sebastian Thiel <sebastian.thiel@icloud.com>
Date: Wed, 24 Aug 2022 09:49:00 +0800
Subject: [PATCH 03/11] refactor

specific test names
---
 git-date/tests/time/parse.rs | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/git-date/tests/time/parse.rs b/git-date/tests/time/parse.rs
index c231958d367..a66b648c415 100644
--- a/git-date/tests/time/parse.rs
+++ b/git-date/tests/time/parse.rs
@@ -15,7 +15,7 @@ fn special_time_is_ok_for_now() {
 }
 
 #[test]
-fn parse() {
+fn short() {
     assert_eq!(
         git_date::parse("1979-02-26"),
         Some(Time {
@@ -25,7 +25,10 @@ fn parse() {
         }),
         "could not parse with SHORT format"
     );
+}
 
+#[test]
+fn rfc2822() {
     assert_eq!(
         git_date::parse("Thu, 18 Aug 2022 12:45:06 +0800"),
         Some(Time {
@@ -35,7 +38,10 @@ fn parse() {
         }),
         "could not parse with RFC2822 format"
     );
+}
 
+#[test]
+fn relative() {
     let two_weeks_ago = git_date::parse("2 weeks ago").expect("valid time");
     assert_eq!(Sign::Plus, two_weeks_ago.sign);
     assert_eq!(0, two_weeks_ago.offset_in_seconds);

From b747a60b62c533b3919124e628f31e6bbef9c838 Mon Sep 17 00:00:00 2001
From: Svetlin Stefanov <s.m.stefanov@gmail.com>
Date: Fri, 26 Aug 2022 21:57:13 +0200
Subject: [PATCH 04/11] Add git baseline.

---
 Cargo.lock                   |  1 +
 git-date/Cargo.toml          |  1 +
 git-date/src/parse.rs        | 35 ++++++++++++++++++++++++++++++++++-
 git-date/tests/time/parse.rs | 33 +++++++++++++++++++++++++++++++++
 4 files changed, 69 insertions(+), 1 deletion(-)

diff --git a/Cargo.lock b/Cargo.lock
index 993f80025e3..39770b74561 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1180,6 +1180,7 @@ dependencies = [
  "document-features",
  "git-testtools",
  "itoa 1.0.3",
+ "once_cell",
  "serde",
  "time",
 ]
diff --git a/git-date/Cargo.toml b/git-date/Cargo.toml
index efa275e0782..c7b122a08de 100644
--- a/git-date/Cargo.toml
+++ b/git-date/Cargo.toml
@@ -24,6 +24,7 @@ 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
diff --git a/git-date/src/parse.rs b/git-date/src/parse.rs
index 1d62efe5c09..00d9acc9709 100644
--- a/git-date/src/parse.rs
+++ b/git-date/src/parse.rs
@@ -1,5 +1,7 @@
-use crate::time::format::{RFC2822, SHORT};
+use crate::time::format::{DEFAULT, ISO8601, ISO8601_STRICT, RFC2822, SHORT};
+use crate::time::Sign;
 use crate::Time;
+use std::str::FromStr;
 use time::{Date, OffsetDateTime};
 
 #[allow(missing_docs)]
@@ -13,6 +15,18 @@ pub fn parse(input: &str) -> Option<Time> {
             Some(Time::new(val.unix_timestamp() as u32, val.offset().whole_seconds()))
         } else if let Ok(val) = OffsetDateTime::parse(input, RFC2822) {
             Some(Time::new(val.unix_timestamp() as u32, val.offset().whole_seconds()))
+        } else if let Ok(val) = OffsetDateTime::parse(input, ISO8601) {
+            Some(Time::new(val.unix_timestamp() as u32, val.offset().whole_seconds()))
+        } else if let Ok(val) = OffsetDateTime::parse(input, ISO8601_STRICT) {
+            Some(Time::new(val.unix_timestamp() as u32, val.offset().whole_seconds()))
+        } else if let Ok(val) = OffsetDateTime::parse(input, DEFAULT) {
+            Some(Time::new(val.unix_timestamp() as u32, val.offset().whole_seconds()))
+        } else if let Ok(val) = u32::from_str(input) {
+            // Format::Unix
+            Some(Time::new(val, 0))
+        } else if let Ok(val) = parse_raw(input) {
+            // Format::Raw
+            Some(val)
         } else if let Some(val) = relative::parse(input) {
             Some(Time::new(val.unix_timestamp() as u32, val.offset().whole_seconds()))
         } else {
@@ -21,6 +35,25 @@ pub fn parse(input: &str) -> Option<Time> {
     }
 }
 
+fn parse_raw(input: &str) -> Result<Time, ()> {
+    let mut split = input.split_whitespace();
+    let seconds_since_unix_epoch: u32 = split.next().ok_or(())?.parse().map_err(|_| ())?;
+    let offset = split.next().ok_or(())?;
+    if offset.len() != 5 {
+        return Err(());
+    }
+    let sign = if &offset[..1] == "-" { Sign::Plus } else { Sign::Minus };
+    let hours: i32 = offset[1..3].parse().map_err(|_| ())?;
+    let minutes: i32 = offset[3..5].parse().map_err(|_| ())?;
+    let offset_in_seconds = hours * 3600 + minutes * 60;
+    let time = Time {
+        seconds_since_unix_epoch,
+        offset_in_seconds,
+        sign,
+    };
+    Ok(time)
+}
+
 mod relative {
     use std::str::FromStr;
     use time::{Duration, OffsetDateTime};
diff --git a/git-date/tests/time/parse.rs b/git-date/tests/time/parse.rs
index a66b648c415..d9eb9e1c40e 100644
--- a/git-date/tests/time/parse.rs
+++ b/git-date/tests/time/parse.rs
@@ -1,7 +1,40 @@
+use bstr::{BString, ByteSlice};
 use git_date::time::Sign;
 use git_date::Time;
+use once_cell::sync::Lazy;
+use std::collections::HashMap;
 use time::OffsetDateTime;
 
+type Result<T = ()> = std::result::Result<T, Box<dyn std::error::Error>>;
+
+static BASELINE: Lazy<HashMap<BString, usize>> = 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("two lines per baseline").to_str()?.parse()?;
+            map.insert(date_str.into(), exit_code);
+        }
+        Ok(map)
+    })()
+    .unwrap()
+});
+
+#[test]
+fn baseline() {
+    for (pattern, exit_code) in BASELINE.iter() {
+        let res = git_date::parse(pattern.to_str().expect("valid pattern"));
+        assert_eq!(
+            res.is_some(),
+            *exit_code == 0,
+            "{pattern:?} disagrees with baseline: {res:?}"
+        )
+    }
+}
+
 #[test]
 fn special_time_is_ok_for_now() {
     assert_eq!(

From 6c40ac1e39fbefba640fc9cb4fd3ef419a149e99 Mon Sep 17 00:00:00 2001
From: Svetlin Stefanov <s.m.stefanov@gmail.com>
Date: Fri, 26 Aug 2022 22:31:44 +0200
Subject: [PATCH 05/11] Add fixtures.

---
 .../fixtures/generate_git_date_baseline.sh    |  39 ++++++++++++++++++
 .../generate_git_date_baseline.tar.xz         | Bin 0 -> 9160 bytes
 2 files changed, 39 insertions(+)
 create mode 100644 git-date/tests/fixtures/generate_git_date_baseline.sh
 create mode 100644 git-date/tests/fixtures/generated-archives/generate_git_date_baseline.tar.xz

diff --git a/git-date/tests/fixtures/generate_git_date_baseline.sh b/git-date/tests/fixtures/generate_git_date_baseline.sh
new file mode 100644
index 00000000000..cf415dc979b
--- /dev/null
+++ b/git-date/tests/fixtures/generate_git_date_baseline.sh
@@ -0,0 +1,39 @@
+#!/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=$?
+#    git ls-files "$pathspec" && status=0 || status=$?
+    {
+        echo "$test_date"
+        echo "$status"
+    } >> baseline.git
+}
+
+# success
+
+# date formats following to https://git-scm.com/docs/git-log#Documentation/git-log.txt---dateltformatgt
+# short
+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 ""
+
diff --git a/git-date/tests/fixtures/generated-archives/generate_git_date_baseline.tar.xz b/git-date/tests/fixtures/generated-archives/generate_git_date_baseline.tar.xz
new file mode 100644
index 0000000000000000000000000000000000000000..dc0ffc1198dabb581474e2df6ce830b811d0d2ed
GIT binary patch
literal 9160
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
Sl%?FU#Ao{g000001X)_ns@!7$

literal 0
HcmV?d00001


From 67c8c6a9666161a3a0cd01203e0fb1da22336939 Mon Sep 17 00:00:00 2001
From: Svetlin Stefanov <s.m.stefanov@gmail.com>
Date: Fri, 26 Aug 2022 23:16:22 +0200
Subject: [PATCH 06/11] `parse` returns Result.

---
 Cargo.lock            |  1 +
 git-date/Cargo.toml   |  1 +
 git-date/src/parse.rs | 57 ++++++++++++++++++++++++++++---------------
 3 files changed, 39 insertions(+), 20 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 39770b74561..471622bb2c9 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1182,6 +1182,7 @@ dependencies = [
  "itoa 1.0.3",
  "once_cell",
  "serde",
+ "thiserror",
  "time",
 ]
 
diff --git a/git-date/Cargo.toml b/git-date/Cargo.toml
index c7b122a08de..67bfc1aa266 100644
--- a/git-date/Cargo.toml
+++ b/git-date/Cargo.toml
@@ -19,6 +19,7 @@ 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", "parsing"] }
+thiserror = "1.0.32"
 
 document-features = { version = "0.2.0", optional = true }
 
diff --git a/git-date/src/parse.rs b/git-date/src/parse.rs
index 00d9acc9709..bc44502892c 100644
--- a/git-date/src/parse.rs
+++ b/git-date/src/parse.rs
@@ -1,9 +1,23 @@
 use crate::time::format::{DEFAULT, ISO8601, ISO8601_STRICT, RFC2822, SHORT};
 use crate::time::Sign;
 use crate::Time;
+use std::num::ParseIntError;
 use std::str::FromStr;
 use time::{Date, OffsetDateTime};
 
+#[derive(thiserror::Error, Debug)]
+#[allow(missing_docs)]
+pub enum Error {
+    #[error("Date string can not be parsed")]
+    InvalidDateString,
+    #[error("Timezone offset can not be parsed")]
+    InvalidTzOffset,
+    #[error("Relative period can not be parsed")]
+    InvalidPeriod,
+    #[error("Integer string can not be parsed")]
+    InvalidInteger(#[from] ParseIntError),
+}
+
 #[allow(missing_docs)]
 pub fn parse(input: &str) -> Option<Time> {
     // TODO: actual implementation, this is just to not constantly fail
@@ -27,7 +41,7 @@ pub fn parse(input: &str) -> Option<Time> {
         } else if let Ok(val) = parse_raw(input) {
             // Format::Raw
             Some(val)
-        } else if let Some(val) = relative::parse(input) {
+        } else if let Ok(val) = relative::parse(input) {
             Some(Time::new(val.unix_timestamp() as u32, val.offset().whole_seconds()))
         } else {
             None
@@ -35,16 +49,16 @@ pub fn parse(input: &str) -> Option<Time> {
     }
 }
 
-fn parse_raw(input: &str) -> Result<Time, ()> {
+fn parse_raw(input: &str) -> Result<Time, Error> {
     let mut split = input.split_whitespace();
-    let seconds_since_unix_epoch: u32 = split.next().ok_or(())?.parse().map_err(|_| ())?;
-    let offset = split.next().ok_or(())?;
+    let seconds_since_unix_epoch: u32 = split.next().ok_or(Error::InvalidDateString)?.parse()?;
+    let offset = split.next().ok_or(Error::InvalidDateString)?;
     if offset.len() != 5 {
-        return Err(());
+        return Err(Error::InvalidTzOffset);
     }
     let sign = if &offset[..1] == "-" { Sign::Plus } else { Sign::Minus };
-    let hours: i32 = offset[1..3].parse().map_err(|_| ())?;
-    let minutes: i32 = offset[3..5].parse().map_err(|_| ())?;
+    let hours: i32 = offset[1..3].parse()?;
+    let minutes: i32 = offset[3..5].parse()?;
     let offset_in_seconds = hours * 3600 + minutes * 60;
     let time = Time {
         seconds_since_unix_epoch,
@@ -55,29 +69,32 @@ fn parse_raw(input: &str) -> Result<Time, ()> {
 }
 
 mod relative {
+    use crate::parse::Error;
     use std::str::FromStr;
     use time::{Duration, OffsetDateTime};
 
-    pub(crate) fn parse(input: &str) -> Option<OffsetDateTime> {
+    pub(crate) fn parse(input: &str) -> Result<OffsetDateTime, Error> {
         let mut split = input.split_whitespace();
-        let multiplier = i64::from_str(split.next()?).ok()?;
-        let period = period_to_seconds(split.next()?)?;
-        if split.next()? != "ago" {
-            return None;
+        let multiplier = i64::from_str(split.next().ok_or(Error::InvalidDateString)?)?;
+        let period = period_to_seconds(split.next().ok_or(Error::InvalidDateString)?)?;
+        if split.next().ok_or(Error::InvalidDateString)? != "ago" {
+            return Err(Error::InvalidDateString);
         }
-        Some(OffsetDateTime::now_utc().checked_sub(Duration::seconds(multiplier * period))?)
+        Ok(OffsetDateTime::now_utc()
+            .checked_sub(Duration::seconds(multiplier * period))
+            .ok_or(Error::InvalidDateString)?)
     }
 
-    fn period_to_seconds(period: &str) -> Option<i64> {
+    fn period_to_seconds(period: &str) -> Result<i64, Error> {
         let period = period.strip_suffix("s").unwrap_or(period);
         return match period {
-            "second" => Some(1),
-            "minute" => Some(60),
-            "hour" => Some(60 * 60),
-            "day" => Some(24 * 60 * 60),
-            "week" => Some(7 * 24 * 60 * 60),
+            "second" => Ok(1),
+            "minute" => Ok(60),
+            "hour" => Ok(60 * 60),
+            "day" => Ok(24 * 60 * 60),
+            "week" => Ok(7 * 24 * 60 * 60),
             // TODO months & years
-            _ => None,
+            _ => Err(Error::InvalidPeriod),
         };
     }
 }

From 5c3b7334289ef71a9dbcc021f1989eb8e021fc7f Mon Sep 17 00:00:00 2001
From: Svetlin Stefanov <s.m.stefanov@gmail.com>
Date: Mon, 29 Aug 2022 21:18:42 +0200
Subject: [PATCH 07/11] Add output to baseline.

---
 .../fixtures/generate_git_date_baseline.sh    |  11 +++++++++--
 .../generate_git_date_baseline.tar.xz         | Bin 9160 -> 9188 bytes
 git-date/tests/time/parse.rs                  |  17 ++++++++++++-----
 3 files changed, 21 insertions(+), 7 deletions(-)

diff --git a/git-date/tests/fixtures/generate_git_date_baseline.sh b/git-date/tests/fixtures/generate_git_date_baseline.sh
index cf415dc979b..0d76ede8e83 100644
--- a/git-date/tests/fixtures/generate_git_date_baseline.sh
+++ b/git-date/tests/fixtures/generate_git_date_baseline.sh
@@ -7,18 +7,25 @@ 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=$?
-#    git ls-files "$pathspec" && 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
-baseline '2022-08-22'
+# ODO
+#baseline '2022-08-22'
 # rfc2822
 baseline 'Thu, 18 Aug 2022 12:45:06 +0800'
 # iso8601
diff --git a/git-date/tests/fixtures/generated-archives/generate_git_date_baseline.tar.xz b/git-date/tests/fixtures/generated-archives/generate_git_date_baseline.tar.xz
index dc0ffc1198dabb581474e2df6ce830b811d0d2ed..a99fe103bc08631fda75303d0c27e127c604be79 100644
GIT binary patch
delta 301
zcmV+|0n+}+N90G4908-T9jPLJgGZsGLVBtG(w!Jv_J{dg0I}!4n93Hx$A=1Uqn>t$
z>1F^)Z#-Cm&K%XTZkJ?JT*w@4uDCtdr{>H50jRevN*+p!iqlX>sRE(;8Y@=CSnHqG
z(P(FKhclB4$IKI%OFAI{_OeETk}<2y5mjeUD21=bGSp96MNRIgSW6^-M5s$a%VD@f
z_Gh6dC2OV%T&TS1$IR&Ek}~}<t5s56k1U2SsH(0W=>Q{k*LOk&^+O`8oe(zwv@Ii!
zRhPTUi?a~*GTtAQ#K8O7HbIA?BisI<1e6}$d@C9QhDuf4Z`0t4mK_lN1*~QT4RA~O
ze*55OD9YLrhL+s;0000Wfq4eIQutbQ00F;8fbaqUO;)j}vBYQl0ssI200dcDnk<c)

delta 273
zcmV+s0q*|fN61Hz907;19jPLJh+J$ePV=?x$N7Hbf{3X=$?We+ab<)9^7@SyPCeoa
z55zyEtj<UCh_Hg7jH)<C!<kROe>+2NX&OsJ07So}>_b}th3fXCKFlHDEjMZ>Yr@EY
z6xP-XJSCW!7!!$h$(h}g7Ea9nW6jbRgX@xH$4|z-JeeDw)75p)C|0k3MAp%InujR7
z(lN#U$NN||Xk{%&sWcPrJglhFX<}sD=wC|`V&Yv324#iA@VLpm$&D<SJbdhqJcdrW
z+#pUtFNkfo`OLe*M!pEzsxO&s0cz&;_s-7v2_MJZ$9-r30000~SM9@3O*G*E0i#EN
X@B#p>l%?FU#Ao{g0000400dcD45^0c

diff --git a/git-date/tests/time/parse.rs b/git-date/tests/time/parse.rs
index d9eb9e1c40e..96476ffecd9 100644
--- a/git-date/tests/time/parse.rs
+++ b/git-date/tests/time/parse.rs
@@ -3,11 +3,12 @@ use git_date::time::Sign;
 use git_date::Time;
 use once_cell::sync::Lazy;
 use std::collections::HashMap;
+use std::str::FromStr;
 use time::OffsetDateTime;
 
 type Result<T = ()> = std::result::Result<T, Box<dyn std::error::Error>>;
 
-static BASELINE: Lazy<HashMap<BString, usize>> = Lazy::new(|| {
+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<_> {
@@ -15,8 +16,9 @@ static BASELINE: Lazy<HashMap<BString, usize>> = Lazy::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("two lines per baseline").to_str()?.parse()?;
-            map.insert(date_str.into(), exit_code);
+            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)
     })()
@@ -25,13 +27,18 @@ static BASELINE: Lazy<HashMap<BString, usize>> = Lazy::new(|| {
 
 #[test]
 fn baseline() {
-    for (pattern, exit_code) in BASELINE.iter() {
+    for (pattern, (exit_code, output)) in BASELINE.iter() {
         let res = git_date::parse(pattern.to_str().expect("valid pattern"));
         assert_eq!(
             res.is_some(),
             *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: {res:?}")
+        }
     }
 }
 

From 206f3923f5da2e9e26677e917550e6e5baa2913a Mon Sep 17 00:00:00 2001
From: Svetlin Stefanov <s.m.stefanov@gmail.com>
Date: Mon, 29 Aug 2022 22:57:30 +0200
Subject: [PATCH 08/11] `parse()` returns Result.

---
 git-date/src/parse.rs                     | 55 +++++++++++------------
 git-date/tests/time/parse.rs              | 16 +++----
 git-repository/src/repository/identity.rs |  4 +-
 git-revision/src/spec/parse/function.rs   |  2 +-
 4 files changed, 38 insertions(+), 39 deletions(-)

diff --git a/git-date/src/parse.rs b/git-date/src/parse.rs
index bc44502892c..3f551e80d1d 100644
--- a/git-date/src/parse.rs
+++ b/git-date/src/parse.rs
@@ -10,6 +10,7 @@ use time::{Date, OffsetDateTime};
 pub enum Error {
     #[error("Date string can not be parsed")]
     InvalidDateString,
+
     #[error("Timezone offset can not be parsed")]
     InvalidTzOffset,
     #[error("Relative period can not be parsed")]
@@ -19,53 +20,53 @@ pub enum Error {
 }
 
 #[allow(missing_docs)]
-pub fn parse(input: &str) -> Option<Time> {
+pub fn parse(input: &str) -> 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 {
         return if let Ok(val) = Date::parse(input, SHORT) {
             let val = val.with_hms(0, 0, 0).expect("date is in range").assume_utc();
-            Some(Time::new(val.unix_timestamp() as u32, val.offset().whole_seconds()))
+            Ok(Time::new(val.unix_timestamp() as u32, val.offset().whole_seconds()))
         } else if let Ok(val) = OffsetDateTime::parse(input, RFC2822) {
-            Some(Time::new(val.unix_timestamp() as u32, val.offset().whole_seconds()))
+            Ok(Time::new(val.unix_timestamp() as u32, val.offset().whole_seconds()))
         } else if let Ok(val) = OffsetDateTime::parse(input, ISO8601) {
-            Some(Time::new(val.unix_timestamp() as u32, val.offset().whole_seconds()))
+            Ok(Time::new(val.unix_timestamp() as u32, val.offset().whole_seconds()))
         } else if let Ok(val) = OffsetDateTime::parse(input, ISO8601_STRICT) {
-            Some(Time::new(val.unix_timestamp() as u32, val.offset().whole_seconds()))
+            Ok(Time::new(val.unix_timestamp() as u32, val.offset().whole_seconds()))
         } else if let Ok(val) = OffsetDateTime::parse(input, DEFAULT) {
-            Some(Time::new(val.unix_timestamp() as u32, val.offset().whole_seconds()))
+            Ok(Time::new(val.unix_timestamp() as u32, val.offset().whole_seconds()))
         } else if let Ok(val) = u32::from_str(input) {
             // Format::Unix
-            Some(Time::new(val, 0))
-        } else if let Ok(val) = parse_raw(input) {
+            Ok(Time::new(val, 0))
+        } else if let Some(val) = parse_raw(input) {
             // Format::Raw
-            Some(val)
-        } else if let Ok(val) = relative::parse(input) {
-            Some(Time::new(val.unix_timestamp() as u32, val.offset().whole_seconds()))
+            Ok(val)
+        } else if let Some(val) = relative::parse(input) {
+            Ok(Time::new(val.unix_timestamp() as u32, val.offset().whole_seconds()))
         } else {
-            None
+            Err(Error::InvalidDateString)
         };
     }
 }
 
-fn parse_raw(input: &str) -> Result<Time, Error> {
+fn parse_raw(input: &str) -> Option<Time> {
     let mut split = input.split_whitespace();
-    let seconds_since_unix_epoch: u32 = split.next().ok_or(Error::InvalidDateString)?.parse()?;
-    let offset = split.next().ok_or(Error::InvalidDateString)?;
+    let seconds_since_unix_epoch: u32 = split.next()?.parse().ok()?;
+    let offset = split.next()?;
     if offset.len() != 5 {
-        return Err(Error::InvalidTzOffset);
+        return None;
     }
     let sign = if &offset[..1] == "-" { Sign::Plus } else { Sign::Minus };
-    let hours: i32 = offset[1..3].parse()?;
-    let minutes: i32 = offset[3..5].parse()?;
+    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,
     };
-    Ok(time)
+    Some(time)
 }
 
 mod relative {
@@ -73,16 +74,14 @@ mod relative {
     use std::str::FromStr;
     use time::{Duration, OffsetDateTime};
 
-    pub(crate) fn parse(input: &str) -> Result<OffsetDateTime, Error> {
+    pub(crate) fn parse(input: &str) -> Option<OffsetDateTime> {
         let mut split = input.split_whitespace();
-        let multiplier = i64::from_str(split.next().ok_or(Error::InvalidDateString)?)?;
-        let period = period_to_seconds(split.next().ok_or(Error::InvalidDateString)?)?;
-        if split.next().ok_or(Error::InvalidDateString)? != "ago" {
-            return Err(Error::InvalidDateString);
+        let multiplier = i64::from_str(split.next()?).ok()?;
+        let period = period_to_seconds(split.next()?).ok()?;
+        if split.next()? != "ago" {
+            return None;
         }
-        Ok(OffsetDateTime::now_utc()
-            .checked_sub(Duration::seconds(multiplier * period))
-            .ok_or(Error::InvalidDateString)?)
+        OffsetDateTime::now_utc().checked_sub(Duration::seconds(multiplier * period))
     }
 
     fn period_to_seconds(period: &str) -> Result<i64, Error> {
diff --git a/git-date/tests/time/parse.rs b/git-date/tests/time/parse.rs
index 96476ffecd9..17db2bd76d3 100644
--- a/git-date/tests/time/parse.rs
+++ b/git-date/tests/time/parse.rs
@@ -30,14 +30,14 @@ fn baseline() {
     for (pattern, (exit_code, output)) in BASELINE.iter() {
         let res = git_date::parse(pattern.to_str().expect("valid pattern"));
         assert_eq!(
-            res.is_some(),
+            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: {res:?}")
+            assert_eq!(actual, expected, "{pattern:?} disagrees with baseline: {actual:?}")
         }
     }
 }
@@ -57,12 +57,12 @@ fn special_time_is_ok_for_now() {
 #[test]
 fn short() {
     assert_eq!(
-        git_date::parse("1979-02-26"),
-        Some(Time {
+        git_date::parse("1979-02-26").expect("parsed date"),
+        Time {
             seconds_since_unix_epoch: 288835200,
             offset_in_seconds: 0,
             sign: Sign::Plus,
-        }),
+        },
         "could not parse with SHORT format"
     );
 }
@@ -70,12 +70,12 @@ fn short() {
 #[test]
 fn rfc2822() {
     assert_eq!(
-        git_date::parse("Thu, 18 Aug 2022 12:45:06 +0800"),
-        Some(Time {
+        git_date::parse("Thu, 18 Aug 2022 12:45:06 +0800").expect("parsed rfc2822 string"),
+        Time {
             seconds_since_unix_epoch: 1660797906,
             offset_in_seconds: 28800,
             sign: Sign::Plus,
-        }),
+        },
         "could not parse with RFC2822 format"
     );
 }
diff --git a/git-repository/src/repository/identity.rs b/git-repository/src/repository/identity.rs
index a61cb0ec5ab..30bcfb1824a 100644
--- a/git-repository/src/repository/identity.rs
+++ b/git-repository/src/repository/identity.rs
@@ -125,13 +125,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).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).ok());
 
             user_email = user_email.or_else(|| env_var("EMAIL")); // NOTE: we don't have permission for this specific one…
         }
diff --git a/git-revision/src/spec/parse/function.rs b/git-revision/src/spec/parse/function.rs
index 20f527206c2..b40b61298f7 100644
--- a/git-revision/src/spec/parse/function.rs
+++ b/git-revision/src/spec/parse/function.rs
@@ -435,7 +435,7 @@ where
                 let time = nav
                     .to_str()
                     .ok()
-                    .and_then(git_date::parse)
+                    .and_then(|v| git_date::parse(v).ok())
                     .ok_or_else(|| Error::Time { input: nav.into() })?;
                 delegate
                     .reflog(delegate::ReflogLookup::Date(time))

From cce7616835f1dff29b2c74bd96b5238d55167d5f Mon Sep 17 00:00:00 2001
From: Svetlin Stefanov <s.m.stefanov@gmail.com>
Date: Mon, 29 Aug 2022 23:08:09 +0200
Subject: [PATCH 09/11] Fallible timestamp cast i64 -> u32.

---
 git-date/src/parse.rs | 35 ++++++++++++++++++++++++-----------
 1 file changed, 24 insertions(+), 11 deletions(-)

diff --git a/git-date/src/parse.rs b/git-date/src/parse.rs
index 3f551e80d1d..1bb402e0b93 100644
--- a/git-date/src/parse.rs
+++ b/git-date/src/parse.rs
@@ -1,7 +1,8 @@
 use crate::time::format::{DEFAULT, ISO8601, ISO8601_STRICT, RFC2822, SHORT};
 use crate::time::Sign;
 use crate::Time;
-use std::num::ParseIntError;
+use std::convert::TryInto;
+use std::num::TryFromIntError;
 use std::str::FromStr;
 use time::{Date, OffsetDateTime};
 
@@ -10,13 +11,10 @@ use time::{Date, OffsetDateTime};
 pub enum Error {
     #[error("Date string can not be parsed")]
     InvalidDateString,
-
-    #[error("Timezone offset can not be parsed")]
-    InvalidTzOffset,
     #[error("Relative period can not be parsed")]
     InvalidPeriod,
-    #[error("Integer string can not be parsed")]
-    InvalidInteger(#[from] ParseIntError),
+    #[error("Dates past 2038 can not be represented.")]
+    InvalidDate(#[from] TryFromIntError),
 }
 
 #[allow(missing_docs)]
@@ -27,15 +25,30 @@ pub fn parse(input: &str) -> Result<Time, Error> {
     } else {
         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() as u32, val.offset().whole_seconds()))
+            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() as u32, val.offset().whole_seconds()))
+            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() as u32, val.offset().whole_seconds()))
+            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() as u32, val.offset().whole_seconds()))
+            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() as u32, val.offset().whole_seconds()))
+            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))

From 9ad1a5fa2ce54e978396ff3eaa7061a8edd10d4a Mon Sep 17 00:00:00 2001
From: Svetlin Stefanov <s.m.stefanov@gmail.com>
Date: Tue, 30 Aug 2022 00:02:11 +0200
Subject: [PATCH 10/11] `parse` is pure function.

---
 git-date/src/parse.rs                     | 31 ++++++++++++++---------
 git-date/tests/time/parse.rs              | 25 ++++++++++--------
 git-repository/src/repository/identity.rs |  5 ++--
 git-revision/src/spec/parse/function.rs   |  3 ++-
 4 files changed, 38 insertions(+), 26 deletions(-)

diff --git a/git-date/src/parse.rs b/git-date/src/parse.rs
index 1bb402e0b93..edb728f905f 100644
--- a/git-date/src/parse.rs
+++ b/git-date/src/parse.rs
@@ -4,6 +4,7 @@ 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)]
@@ -15,10 +16,12 @@ pub enum Error {
     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) -> Result<Time, Error> {
+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" {
         Ok(Time::new(42, 1800))
@@ -55,8 +58,11 @@ pub fn parse(input: &str) -> Result<Time, Error> {
         } else if let Some(val) = parse_raw(input) {
             // Format::Raw
             Ok(val)
-        } else if let Some(val) = relative::parse(input) {
-            Ok(Time::new(val.unix_timestamp() as u32, val.offset().whole_seconds()))
+        } 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)
         };
@@ -85,26 +91,27 @@ fn parse_raw(input: &str) -> Option<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) -> Option<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 = period_to_seconds(split.next()?).ok()?;
+        let period = split.next()?;
         if split.next()? != "ago" {
             return None;
         }
-        OffsetDateTime::now_utc().checked_sub(Duration::seconds(multiplier * period))
+        OffsetDateTime::from(now).checked_sub(duration(period, multiplier).ok()?)
     }
 
-    fn period_to_seconds(period: &str) -> Result<i64, Error> {
+    fn duration(period: &str, multiplier: i64) -> Result<Duration, Error> {
         let period = period.strip_suffix("s").unwrap_or(period);
         return match period {
-            "second" => Ok(1),
-            "minute" => Ok(60),
-            "hour" => Ok(60 * 60),
-            "day" => Ok(24 * 60 * 60),
-            "week" => Ok(7 * 24 * 60 * 60),
+            "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),
         };
diff --git a/git-date/tests/time/parse.rs b/git-date/tests/time/parse.rs
index 17db2bd76d3..9036a5a4ba2 100644
--- a/git-date/tests/time/parse.rs
+++ b/git-date/tests/time/parse.rs
@@ -4,7 +4,8 @@ use git_date::Time;
 use once_cell::sync::Lazy;
 use std::collections::HashMap;
 use std::str::FromStr;
-use time::OffsetDateTime;
+use std::time::SystemTime;
+use time::{Duration, OffsetDateTime};
 
 type Result<T = ()> = std::result::Result<T, Box<dyn std::error::Error>>;
 
@@ -28,7 +29,7 @@ static BASELINE: Lazy<HashMap<BString, (usize, BString)>> = Lazy::new(|| {
 #[test]
 fn baseline() {
     for (pattern, (exit_code, output)) in BASELINE.iter() {
-        let res = git_date::parse(pattern.to_str().expect("valid pattern"));
+        let res = git_date::parse(pattern.to_str().expect("valid pattern"), Some(SystemTime::now()));
         assert_eq!(
             res.is_ok(),
             *exit_code == 0,
@@ -45,7 +46,7 @@ fn baseline() {
 #[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,
@@ -57,7 +58,7 @@ fn special_time_is_ok_for_now() {
 #[test]
 fn short() {
     assert_eq!(
-        git_date::parse("1979-02-26").expect("parsed date"),
+        git_date::parse("1979-02-26", Some(SystemTime::now())).expect("parsed date"),
         Time {
             seconds_since_unix_epoch: 288835200,
             offset_in_seconds: 0,
@@ -70,7 +71,7 @@ fn short() {
 #[test]
 fn rfc2822() {
     assert_eq!(
-        git_date::parse("Thu, 18 Aug 2022 12:45:06 +0800").expect("parsed rfc2822 string"),
+        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,
@@ -82,14 +83,16 @@ fn rfc2822() {
 
 #[test]
 fn relative() {
-    let two_weeks_ago = git_date::parse("2 weeks ago").expect("valid time");
+    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")
-            .iso_week(),
-        OffsetDateTime::now_utc().iso_week() - 2,
-        "weeks numbers differ"
+        OffsetDateTime::from_unix_timestamp(two_weeks_ago.seconds_since_unix_epoch as i64).expect("valid datetime"),
+        expected,
+        "relative times differ"
     );
 }
diff --git a/git-repository/src/repository/identity.rs b/git-repository/src/repository/identity.rs
index 30bcfb1824a..b54a1996888 100644
--- a/git-repository/src/repository/identity.rs
+++ b/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).ok());
+                .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).ok());
+                .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…
         }
diff --git a/git-revision/src/spec/parse/function.rs b/git-revision/src/spec/parse/function.rs
index b40b61298f7..c749207bfa3 100644
--- a/git-revision/src/spec/parse/function.rs
+++ b/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(|v| git_date::parse(v).ok())
+                    .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))

From 1eac4de99de250e770b48054fd5bc6b806418e4d Mon Sep 17 00:00:00 2001
From: Svetlin Stefanov <s.m.stefanov@gmail.com>
Date: Wed, 31 Aug 2022 21:07:11 +0200
Subject: [PATCH 11/11] PR comments.

---
 git-date/src/parse.rs        | 4 ++--
 git-date/tests/time/parse.rs | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/git-date/src/parse.rs b/git-date/src/parse.rs
index edb728f905f..ff7444fb31d 100644
--- a/git-date/src/parse.rs
+++ b/git-date/src/parse.rs
@@ -26,7 +26,7 @@ pub fn parse(input: &str, now: Option<SystemTime>) -> Result<Time, Error> {
     if input == "1979-02-26 18:30:00" {
         Ok(Time::new(42, 1800))
     } else {
-        return if let Ok(val) = Date::parse(input, SHORT) {
+        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()?,
@@ -65,7 +65,7 @@ pub fn parse(input: &str, now: Option<SystemTime>) -> Result<Time, Error> {
             ))
         } else {
             Err(Error::InvalidDateString)
-        };
+        }
     }
 }
 
diff --git a/git-date/tests/time/parse.rs b/git-date/tests/time/parse.rs
index 9036a5a4ba2..046f0638703 100644
--- a/git-date/tests/time/parse.rs
+++ b/git-date/tests/time/parse.rs
@@ -71,7 +71,7 @@ fn short() {
 #[test]
 fn rfc2822() {
     assert_eq!(
-        git_date::parse("Thu, 18 Aug 2022 12:45:06 +0800", Some(SystemTime::now())).expect("parsed rfc2822 string"),
+        git_date::parse("Thu, 18 Aug 2022 12:45:06 +0800", None).expect("parsed rfc2822 string"),
         Time {
             seconds_since_unix_epoch: 1660797906,
             offset_in_seconds: 28800,