Handle negative spans

Author: zanieb

crates/uv-resolver/src/exclude_newer.rs

@@ -194,20 +194,14 @@ impl From<Timestamp> for ExcludeNewerValue {
 /// - `[-+]?\s*[0-9]+\s*[A-Za-z]` → friendly duration (e.g., `2 weeks`, `-30 days`)
 /// - `[-+]?[0-9]{4}-` → date/timestamp (e.g., `2024-01-01`)
 /// - Otherwise → generic error with examples
-fn format_exclude_newer_error(
-    input: &str,
-    date_err: jiff::Error,
-    span_err: jiff::Error,
-) -> String {
+fn format_exclude_newer_error(input: &str, date_err: jiff::Error, span_err: jiff::Error) -> String {
     let trimmed = input.trim();
 
     // Check for ISO 8601 duration: [-+]?[Pp]
     // e.g., "P2W", "+P1D", "-P30D"
     let after_sign = trimmed.trim_start_matches(['+', '-']);
     if after_sign.starts_with('P') || after_sign.starts_with('p') {
-        return format!(
-            "`{input}` could not be parsed as an ISO 8601 duration: {span_err}"
-        );
+        return format!("`{input}` could not be parsed as an ISO 8601 duration: {span_err}");
     }
 
     // Check for friendly duration: [-+]?\s*[0-9]+\s*[A-Za-z]
@@ -227,9 +221,7 @@ fn format_exclude_newer_error(
         }
         // Check if next character is a letter (unit designator)
         if chars.peek().is_some_and(|c| c.is_ascii_alphabetic()) {
-            return format!(
-                "`{input}` could not be parsed as a relative duration: {span_err}"
-            );
+            return format!("`{input}` could not be parsed as a relative duration: {span_err}");
         }
     }
 
@@ -243,9 +235,7 @@ fn format_exclude_newer_error(
         && chars.next().is_some_and(|c| c == '-');
 
     if looks_like_date {
-        return format!(
-            "`{input}` could not be parsed as a valid date: {date_err}"
-        );
+        return format!("`{input}` could not be parsed as a valid date: {date_err}");
     }
 
     // Fallback: generic error showing both possibilities
@@ -327,7 +317,10 @@ impl FromStr for ExcludeNewerValue {
 
                 // We're using a UTC timezone so there are no transitions (e.g., DST) and days are
                 // always 24 hours. This means that we can also allow weeks as a unit.
-                let cutoff = now.checked_sub(span).map_err(|err| {
+                //
+                // Note we use `span.abs()` so `1 day ago` has the same effect as `1 day` instead
+                // of resulting in a future date.
+                let cutoff = now.checked_sub(span.abs()).map_err(|err| {
                     format!("Duration `{input}` is too large to subtract from current time: {err}")
                 })?;
 
@@ -623,4 +616,5 @@ mod tests {
         assert_eq!(entry.package.as_ref(), "requests");
         // Just verify it parsed without error - the timestamp will be relative to now
     }
+
 }

crates/uv/tests/it/lock_exclude_newer_relative.rs

@@ -1137,6 +1137,109 @@ fn lock_exclude_newer_mixed_relative_global_absolute_package() -> Result<()> {
     Ok(())
 }
 
+/// Test that negative durations produce the same timestamp as positive durations.
+/// This ensures that `span.abs()` is applied correctly, so "-1 day" and "1 day" both
+/// result in a cutoff 1 day in the past (not 1 day in the future for negative).
+#[test]
+fn lock_exclude_newer_negative_duration_same_as_positive() -> Result<()> {
+    let context = TestContext::new("3.12");
+    let pyproject_toml = context.temp_dir.child("pyproject.toml");
+    pyproject_toml.write_str(
+        r#"
+        [project]
+        name = "project"
+        version = "0.1.0"
+        requires-python = ">=3.12"
+        dependencies = ["iniconfig"]
+        "#,
+    )?;
+
+    // Lock with positive duration "7 days"
+    uv_snapshot!(context.filters(), context
+        .lock()
+        .env_remove(EnvVars::UV_EXCLUDE_NEWER)
+        .env(EnvVars::UV_TEST_CURRENT_TIMESTAMP, "2025-11-21T12:00:00Z")
+        .arg("--exclude-newer")
+        .arg("7 days"), @r###"
+    success: true
+    exit_code: 0
+    ----- stdout -----
+
+    ----- stderr -----
+    Resolved 2 packages in [TIME]
+    "###);
+
+    let lock_positive = context.read("uv.lock");
+    let timestamp_positive = lock_positive
+        .lines()
+        .find(|line| line.starts_with("exclude-newer = "))
+        .expect("Should find exclude-newer line");
+
+    let _ = fs_err::remove_file(context.temp_dir.child("uv.lock"));
+
+    // Lock with negative ISO 8601 duration "-P7D" (should produce same timestamp)
+    // Note: We use --exclude-newer=-P7D to avoid the dash being interpreted as a flag
+    uv_snapshot!(context.filters(), context
+        .lock()
+        .env_remove(EnvVars::UV_EXCLUDE_NEWER)
+        .env(EnvVars::UV_TEST_CURRENT_TIMESTAMP, "2025-11-21T12:00:00Z")
+        .arg("--exclude-newer=-P7D"), @r###"
+    success: true
+    exit_code: 0
+    ----- stdout -----
+
+    ----- stderr -----
+    Resolved 2 packages in [TIME]
+    "###);
+
+    let lock_negative_iso = context.read("uv.lock");
+    let timestamp_negative_iso = lock_negative_iso
+        .lines()
+        .find(|line| line.starts_with("exclude-newer = "))
+        .expect("Should find exclude-newer line");
+
+    let _ = fs_err::remove_file(context.temp_dir.child("uv.lock"));
+
+    // Lock with "7 days ago" friendly format (should also produce same timestamp)
+    uv_snapshot!(context.filters(), context
+        .lock()
+        .env_remove(EnvVars::UV_EXCLUDE_NEWER)
+        .env(EnvVars::UV_TEST_CURRENT_TIMESTAMP, "2025-11-21T12:00:00Z")
+        .arg("--exclude-newer")
+        .arg("7 days ago"), @r###"
+    success: true
+    exit_code: 0
+    ----- stdout -----
+
+    ----- stderr -----
+    Resolved 2 packages in [TIME]
+    "###);
+
+    let lock_ago = context.read("uv.lock");
+    let timestamp_ago = lock_ago
+        .lines()
+        .find(|line| line.starts_with("exclude-newer = "))
+        .expect("Should find exclude-newer line");
+
+    // All three should produce the same cutoff timestamp (7 days before 2025-11-21T12:00:00Z)
+    assert_eq!(
+        timestamp_positive, timestamp_negative_iso,
+        "Negative ISO duration should produce the same timestamp as positive duration"
+    );
+    assert_eq!(
+        timestamp_positive, timestamp_ago,
+        "'7 days ago' should produce the same timestamp as '7 days'"
+    );
+
+    // Verify the actual timestamp is correct (2025-11-14T12:00:00Z = 7 days before 2025-11-21T12:00:00Z)
+    assert!(
+        timestamp_positive.contains("2025-11-14T12:00:00Z"),
+        "Expected timestamp to be 2025-11-14T12:00:00Z, got: {timestamp_positive}"
+    );
+
+    Ok(())
+}
+
 /// Changing the span in pyproject.toml invalidates the lockfile.
 #[test]
 fn lock_exclude_newer_span_change_invalidates() -> Result<()> {