fix(offset): treat a numeric offset after a time of day as a zone correction

src/items/mod.rs

@@ -876,4 +876,48 @@ mod tests {
         // duplicate check. GNU rejects it too.
         assert!(parse(&mut "j +05:00").is_err());
     }
+
+    /// A numeric offset after a time of day is a time zone correction, even
+    /// when a relative item follows it. GNU `date` reads
+    /// `2026-08-27 12:00 +3 hours` as the zone `+03:00` plus a bare `hours`
+    /// (which means one hour), i.e. 10:00 UTC.
+    #[test]
+    fn numeric_offset_before_relative_item() {
+        for (expected, input) in [
+            ("2026-08-27 10:00:00", "2026-08-27 12:00 +3 hours"),
+            ("2026-08-27 10:00:00", "2026-08-27 12:00 +3 hour"),
+            ("2026-08-27 10:00:00", "2026-08-27 12:00 +3hours"),
+            ("2026-08-27 10:00:00", "2026-08-27 12:00 + 3 hours"),
+            ("2026-08-27 10:00:00", "2026-08-27 12:00 +03 hours"),
+            ("2026-08-27 10:00:00", "2026-08-27 12:00 +0300 hours"),
+            ("2026-08-27 10:00:00", "2026-08-27 12:00:00 +3 hours"),
+            ("2026-08-27 10:05:00", "2026-08-27 12:00 +3 hours 5 minutes"),
+            ("2026-08-27 08:00:00", "2026-08-27 12:00 +3 hours ago"),
+            ("2026-08-28 09:00:00", "2026-08-27 12:00 +3 days"),
+            ("2026-08-27 09:01:00", "2026-08-27 12:00 +3 minutes"),
+            ("2026-08-27 16:00:00", "2026-08-27 12:00 -3 hours"),
+            ("2026-08-27 00:00:00", "2026-08-27 12:00 +13 hours"),
+            // A named zone already fills the zone slot, so the numeric value
+            // stays a relative item.
+            ("2026-08-27 15:00:00", "2026-08-27 12:00 utc +3 hours"),
+            // Without a time of day there is no zone slot to fill either.
+            ("2026-08-27 03:00:00", "2026-08-27 +3 hours"),
+            // A fractional number is never a zone correction.
+            ("2026-08-27 12:00:01", "2026-08-27 12:00 +1.5 seconds"),
+        ] {
+            let parsed = parse(&mut &*input)
+                .map(at_utc)
+                .expect("parsing failed during tests")
+                .with_time_zone(TimeZone::UTC);
+            assert_eq!(
+                expected,
+                parsed.strftime("%Y-%m-%d %H:%M:%S").to_string(),
+                "{input}"
+            );
+        }
+
+        // `+30` is not a valid zone correction, and GNU rejects the whole
+        // input rather than falling back to a relative item.
+        assert!(parse(&mut "2026-08-27 12:00 +30 hours").is_err());
+    }
 }

src/items/offset.rs

@@ -31,7 +31,7 @@ use winnow::{
     combinator::{alt, peek},
     error::{ContextError, ErrMode},
     stream::{AsChar, Stream},
-    token::take_while,
+    token::{one_of, take_while},
     ModalResult, Parser,
 };
 
@@ -191,6 +191,26 @@ pub(super) fn parse_local(input: &mut &str) -> ModalResult<()> {
         .parse_next(input)
 }
 
+/// Parse the zone correction that follows a time of day.
+///
+/// Unlike [`timezone_offset`], a relative unit after the number does not
+/// disqualify it: GNU reads `12:00 +3 hours` as the zone `+03:00` plus a bare
+/// `hours`. A fractional number is never a correction (`12:00 +1.5 seconds`).
+pub(super) fn time_zone_correction(input: &mut &str) -> ModalResult<Offset> {
+    let has_fraction = peek((
+        plus_or_minus::<ErrMode<ContextError>>,
+        s(dec_uint_str),
+        '.',
+        one_of(AsChar::is_dec_digit),
+    ))
+    .parse_next(input)
+    .is_ok();
+    if has_fraction {
+        return Err(ErrMode::Backtrack(ContextError::new()));
+    }
+    alt((timezone_offset_colon, timezone_offset_colonless)).parse_next(input)
+}
+
 /// Parse a timezone starting with `+` or `-`.
 pub(super) fn timezone_offset(input: &mut &str) -> ModalResult<Offset> {
     // Like GNU, read "+8 years" as a relative item, not as "+8" and "years".

src/items/time.rs

@@ -45,7 +45,7 @@ use winnow::{
 
 use super::{
     epoch::sec_and_nsec,
-    offset::{timezone_offset, Offset},
+    offset::{time_zone_correction, timezone_offset, Offset},
     primitive::{colon, ctx_err, dec_uint, s},
 };
 
@@ -99,7 +99,7 @@ pub(super) fn iso(input: &mut &str) -> ModalResult<Time> {
             colon,
             minute,
             opt(preceded(colon, second)),
-            opt(timezone_offset),
+            opt(time_zone_correction),
         )
             .map(|(hour, _, minute, sec_nsec, offset)| Time {
                 hour,

tests/time.rs

@@ -121,6 +121,7 @@ fn test_time_correction_with_overflow(#[case] input: &str, #[case] expected: &st
 #[case("10:59am+01")]
 #[case("10:59+01pm")]
 #[case("23:59:59+00:00:00")]
+#[case("2026-08-27 12:00 +30 hours")]
 fn test_time_invalid(#[case] input: &str) {
     let result = parse_datetime::parse_datetime(input);
     assert_eq!(
@@ -316,3 +317,23 @@ fn test_relative_fractional_seconds(#[case] input: &str, #[case] expected: &str)
 
     check_time(input, expected, "%H:%M:%S.%N", Some(base));
 }
+
+// Expected values from GNU date 9.11 with TZ=UTC: a numeric offset right after
+// a time of day is a zone correction, and the relative unit that follows is a
+// bare unit, i.e. one of it.
+#[rstest]
+#[case::hours("2026-08-27 12:00 +3 hours", "2026-08-27 10:00:00")]
+#[case::hours_glued("2026-08-27 12:00 +3hours", "2026-08-27 10:00:00")]
+#[case::hhmm("2026-08-27 12:00 +0300 hours", "2026-08-27 10:00:00")]
+#[case::hours_ago("2026-08-27 12:00 +3 hours ago", "2026-08-27 08:00:00")]
+#[case::minutes("2026-08-27 12:00 +3 minutes", "2026-08-27 09:01:00")]
+#[case::days("2026-08-27 12:00 +3 days", "2026-08-28 09:00:00")]
+#[case::minus("2026-08-27 12:00 -3 hours", "2026-08-27 16:00:00")]
+#[case::two_items("2026-08-27 12:00 +3 hours 5 minutes", "2026-08-27 10:05:00")]
+#[case::named_zone_first("2026-08-27 12:00 utc +3 hours", "2026-08-27 15:00:00")]
+#[case::bare_hour("2026-08-27 12 +3 hours", "2026-08-27 15:00:00")]
+#[case::no_time_of_day("2026-08-27 +3 hours", "2026-08-27 03:00:00")]
+#[case::fraction("2026-08-27 12:00 +1.5 seconds", "2026-08-27 12:00:01")]
+fn test_time_correction_before_relative(#[case] input: &str, #[case] expected: &str) {
+    check_time(input, expected, "%Y-%m-%d %H:%M:%S", None);
+}