Merge branch 'git_date_relative'

git-date/src/parse.rs

@@ -115,15 +115,17 @@ mod relative {
 
     fn duration(period: &str, multiplier: i64) -> Option<Duration> {
         let period = period.strip_suffix('s').unwrap_or(period);
-        Some(match period {
-            "second" => Duration::seconds(multiplier),
-            "minute" => Duration::minutes(multiplier),
-            "hour" => Duration::hours(multiplier),
-            "day" => Duration::days(multiplier),
-            "week" => Duration::weeks(multiplier),
-            // TODO months & years
+        let seconds: i64 = match period {
+            "second" => 1,
+            "minute" => 60,
+            "hour" => 60 * 60,
+            "day" => 24 * 60 * 60,
+            "week" => 7 * 24 * 60 * 60,
+            // TODO months & years? YES
+            // Ignore values you don't know, assume seconds then (so does git)
             _ => return None,
-        })
+        };
+        seconds.checked_mul(multiplier).map(Duration::seconds)
     }
 
     #[cfg(test)]

git-date/tests/fixtures/generate_git_date_baseline.sh

@@ -39,8 +39,3 @@ baseline '123456789'
 # raw
 baseline '1660874655 +0800'
 
-# failing
-
-# empty_input
-baseline ""
-

git-date/tests/time/parse.rs

@@ -1,12 +1,12 @@
-use std::{collections::HashMap, str::FromStr, time::SystemTime};
+use std::{collections::HashMap, time::SystemTime};
 
 use bstr::{BString, ByteSlice};
 use git_date::{time::Sign, Time};
 use once_cell::sync::Lazy;
 
 type Result<T = ()> = std::result::Result<T, Box<dyn std::error::Error>>;
 
-static BASELINE: Lazy<HashMap<BString, (usize, BString)>> = Lazy::new(|| {
+static BASELINE: Lazy<HashMap<BString, (usize, u32)>> = Lazy::new(|| {
     let base = git_testtools::scripted_fixture_repo_read_only("generate_git_date_baseline.sh").unwrap();
 
     (|| -> Result<_> {
@@ -15,7 +15,13 @@ static BASELINE: Lazy<HashMap<BString, (usize, BString)>> = Lazy::new(|| {
         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();
+            let output: u32 = lines
+                .next()
+                .expect("three lines per baseline")
+                .to_str()
+                .expect("valid utf")
+                .parse()
+                .expect("valid epoch value");
             map.insert(date_str.into(), (exit_code, output));
         }
         Ok(map)
@@ -34,8 +40,7 @@ fn baseline() {
         );
         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:?}")
+            assert_eq!(actual, *output, "{pattern:?} disagrees with baseline: {actual:?}")
         }
     }
 }
@@ -93,8 +98,7 @@ mod relative {
     use time::{Duration, OffsetDateTime};
 
     #[test]
-    #[should_panic] // TODO: fix
-    fn large_offsets_can_panic() {
+    fn large_offsets() {
         git_date::parse("999999999999999 weeks ago", Some(std::time::UNIX_EPOCH)).ok();
     }
 

git-prompt/src/unix.rs

@@ -9,11 +9,11 @@ pub(crate) mod imp {
     };
 
     use nix::sys::{termios, termios::Termios};
-    use parking_lot::{lock_api::MutexGuard, Mutex, RawMutex};
+    use parking_lot::{const_mutex, lock_api::MutexGuard, Mutex, RawMutex};
 
     use crate::{unix::TTY_PATH, Error, Mode, Options};
 
-    static TERM_STATE: Mutex<Option<Termios>> = Mutex::new(None);
+    static TERM_STATE: Mutex<Option<Termios>> = const_mutex(None);
 
     /// Ask the user given a `prompt`, returning the result.
     pub(crate) fn ask(prompt: &str, Options { mode, .. }: &Options<'_>) -> Result<String, Error> {