fix: add support for 'any' unit, when parsing <count> <unit> ago.

Similar to Git, any unit is allowed and will default to seconds, like `60 flurps ago`
will mean a minute in the past.

gix-date/src/parse.rs

@@ -156,7 +156,7 @@ mod relative {
             "month" => Span::new().try_months(units),
             "year" => Span::new().try_years(units),
             // Ignore values you don't know, assume seconds then (so does git)
-            _ => return None,
+            _anything => Span::new().try_seconds(units),
         };
         Some(result.map_err(|_| Error::RelativeTimeConversion))
     }

gix-date/tests/time/parse.rs

@@ -184,6 +184,7 @@ mod relative {
         // For comparison, a few are the same as in: https://github.com/git/git/blob/master/t/t0006-date.sh
         let cases = [
             ("5 seconds ago", 5.seconds()),
+            ("12345 florx ago", 12_345.seconds()), // Anything parses as seconds
             ("5 minutes ago", 5.minutes()),
             ("5 hours ago", 5.hours()),
             ("5 days ago", 5.days()),
@@ -226,21 +227,33 @@ mod relative {
             let time = gix_date::parse(input, Some(now)).expect("relative time string should parse to a Time");
             (input, time)
         });
-        assert_eq!(with_times.map(|_| Sign::Plus), with_times.map(|(_, time)| time.sign));
-        assert_eq!(with_times.map(|_| 0), with_times.map(|(_, time)| time.offset));
+        assert_eq!(
+            with_times.map(|(_, time)| time.sign),
+            with_times.map(|_| Sign::Plus),
+            "Despite being in the past, the dates produced are positive, as they are still post-epoch"
+        );
+        assert_eq!(
+            with_times.map(|(_, time)| time.offset),
+            with_times.map(|_| 0),
+            "They don't pick up local time"
+        );
 
         let with_expected = cases.map(|(input, span)| {
-            let expected = Zoned::try_from(now)
-                .expect("test needs to convert current time to a timestamp")
-                // account for the loss of precision when creating `Time` with seconds
-                .round(
-                    jiff::ZonedRound::new()
-                        .smallest(jiff::Unit::Second)
-                        .mode(jiff::RoundMode::Trunc),
-                )
-                .expect("test needs to truncate current timestamp to seconds")
-                .saturating_sub(span)
-                .timestamp();
+            let expected = Zoned::new(
+                now.try_into().expect("system time is representable"),
+                // As relative dates are always UTC in Git, we do the same, and must
+                // compare to UTC as well or else time might be off due to daylight savings, etc.
+                jiff::tz::TimeZone::UTC,
+            )
+            // account for the loss of precision when creating `Time` with seconds
+            .round(
+                jiff::ZonedRound::new()
+                    .smallest(jiff::Unit::Second)
+                    .mode(jiff::RoundMode::Trunc),
+            )
+            .expect("test needs to truncate current timestamp to seconds")
+            .saturating_sub(span)
+            .timestamp();
 
             (input, expected)
         });