From a7cc7871f1f716798d240c220f9ed365f640dd30 Mon Sep 17 00:00:00 2001 From: Nicolas Le Cam Date: Tue, 8 Sep 2026 03:19:54 +0200 Subject: [PATCH] test(diff): pin the shape detectors, the structural index lines and the GNU roots Every fixture in the diff corpus is a real capture, so the shape detectors only ever see well-formed lines and nothing asserted what they reject. Loosening `&&` to `||` in `is_mbox_from` makes any `From `-prefixed line over 40 characters open an mbox message region, which ordinary commit prose reaches; the same loosening accepts a non-hex revision in `is_hg_echo` and a short or non-hex side of a `Submodule` range. None of those failed a test. git's `index` and `similarity index` lines are structure, not prose. Counting one as a dropped line costs nothing on a git-only stream, because nothing consults the drop until a GNU echo has been seen -- but a stream carrying both producers then bails to raw on a section that parses. Collapsing that prefix chain to a single term left every test green. The roots GNU diff was given were collected by the same eight lines inlined in two arms, and mutating either copy changed no output because no unit reached them directly. Extracted as `record_gnu_roots`, which makes the dedup and the non-empty guard assertable; both are now pinned. No behaviour change: byte-identical to develop across the 81 diff fixtures, 400 `git show` streams and GNU directory diffs over names holding `: ` and `'`. Also rewrites `condense_stdin`'s doc comment, which named a rejected alternative, described `guard::never_worse`'s signature from a file that does not call it, and repeated the ANSI-view clause carried by `condense_unified_diff_strict`'s own doc. Co-Authored-By: Claude Opus 5 --- src/cmds/git/diff_cmd.rs | 127 +++++++++++++++++++++++++++++++-------- 1 file changed, 101 insertions(+), 26 deletions(-) diff --git a/src/cmds/git/diff_cmd.rs b/src/cmds/git/diff_cmd.rs index 2f63669150..f29b9cd224 100644 --- a/src/cmds/git/diff_cmd.rs +++ b/src/cmds/git/diff_cmd.rs @@ -487,15 +487,9 @@ pub fn run_stdin(_verbose: u8) -> Result<()> { Ok(()) } -/// Filter a piped stream: parse strictly (the parser reads structure through -/// an ANSI-stripped view, so a `git diff --color` stream parses instead of -/// condensing to silence, while content lines keep their bytes) and apply -/// the never-worse check — inlined rather than via `guard::never_worse`, -/// which hands back the winning `&str`, where this path needs `None` to -/// mean byte-exact fallback. `None` means the caller must emit its exact -/// input bytes — including for non-UTF-8 input, where filtering would -/// rewrite the user's content bytes to U+FFFD (byte fidelity outranks -/// savings here). +/// Filter a piped stream. `None` means the caller emits its input bytes +/// exactly: non-UTF-8 input takes that path, so content that is not valid +/// UTF-8 survives byte for byte. fn condense_stdin(bytes: &[u8]) -> Option { let input = std::str::from_utf8(bytes).ok()?; // PowerShell 5.1's `>` writes a BOM; without this the first `diff @@ -1839,6 +1833,24 @@ fn shared_tail(x: &str, y: &str) -> Option { tail.find('/').map(|p| n - p).filter(|&m| m > 1) } +/// Record the roots GNU diff was given, taken from a pair of paths it printed +/// for the same file. What precedes the shared tail is that side's root; an +/// `Only in : ` line later splits on whichever of these it starts +/// with, which is how a directory holding `: ` keeps its name. A root already +/// held is not recorded twice, and a pair with no root above the shared tail +/// records nothing. +fn record_gnu_roots(set: &mut Vec, x: &str, y: &str) { + let Some(n) = shared_tail(x, y) else { + return; + }; + for side in [x, y] { + let root = side[..side.len() - n].trim_end_matches('/'); + if !root.is_empty() && !set.iter().any(|r| r == root) { + set.push(root.to_string()); + } + } +} + /// Parse `@@ -a[,b] +c[,d] @@ ...` (and `@@@ -a,b -c,d +e,f @@@ ...` with one /// `-` range per parent) into per-parent old-line budgets and the new-line /// budget. Omitted counts default to 1 per the unified-diff spec. @@ -2480,14 +2492,7 @@ fn condense_unified_diff_strict(diff: &str) -> Option { if gnu_roots && !hg_stream { // The roots GNU diff was given, for `Only in` (rule 6). let (x, y) = (dequote(minus), dequote(plus)); - if let Some(n) = shared_tail(&x, &y) { - for side in [&x, &y] { - let root = side[..side.len() - n].trim_end_matches('/'); - if !root.is_empty() && !gnu_root_set.iter().any(|r| r == root) { - gnu_root_set.push(root.to_string()); - } - } - } + record_gnu_roots(&mut gnu_root_set, &x, &y); } match current.as_mut().filter(|e| e.header_only()) { // `rename to`/`copy to` is git's exact path; the pair @@ -2639,14 +2644,7 @@ fn condense_unified_diff_strict(diff: &str) -> Option { std::borrow::Cow::Borrowed(pair), std::borrow::Cow::Borrowed(pair), )); - if let Some(n) = shared_tail(&x, &y) { - for side in [&x, &y] { - let root = side[..side.len() - n].trim_end_matches('/'); - if !root.is_empty() && !gnu_root_set.iter().any(|r| r == root) { - gnu_root_set.push(root.to_string()); - } - } - } + record_gnu_roots(&mut gnu_root_set, &x, &y); let name = header_name(&x, &y, Some(("", ""))); flush(&mut entries, &mut current)?; entries.push(FileEntry { @@ -4674,6 +4672,84 @@ mod tests { assert_eq!(code, 1); } + /// git's `index` and `similarity index` lines are structure, not prose. + /// Counting one as a dropped line costs nothing on a git-only stream — + /// nothing consults the drop until a GNU echo has been seen — but a stream + /// carrying both producers then bails to raw on a section that parses. + #[test] + fn git_index_lines_are_structural_in_a_gnu_stream() { + let mixed = "diff -ru a/z.txt b/z.txt\n\ + --- a/z.txt\t2026-09-08 00:00:00.000000000 +0000\n\ + +++ b/z.txt\t2026-09-08 00:00:00.000000000 +0000\n\ + @@ -1 +1 @@\n\ + -one\n\ + +two\n\ + diff --git a/g.txt b/g.txt\n\ + index 1234567..89abcde 100644\n\ + --- a/g.txt\n\ + +++ b/g.txt\n\ + @@ -1 +1 @@\n\ + -old\n\ + +new\n"; + let out = condense_unified_diff_strict(mixed).expect("both sections parse"); + assert!(out.contains("[file] b/z.txt"), "GNU section: {out}"); + assert!(out.contains("[file] g.txt"), "git section: {out}"); + } + + /// The roots GNU diff was given are what an `Only in : ` line + /// splits on, so a directory holding `: ` keeps its name. Recorded once + /// each, and only when the pair has a root above its shared tail. + #[test] + fn gnu_roots_are_recorded_once_and_never_empty() { + let mut set = Vec::new(); + record_gnu_roots(&mut set, "cd1/d: x/f.txt", "cd2/e: y/f.txt"); + assert_eq!(set, ["cd1/d: x", "cd2/e: y"]); + + // Same roots again from a sibling file: still one entry each. + record_gnu_roots(&mut set, "cd1/d: x/g.txt", "cd2/e: y/g.txt"); + assert_eq!(set, ["cd1/d: x", "cd2/e: y"]); + + // A bare pair has no root above the shared tail, and a trailing slash + // is not a root of its own. + let mut bare = Vec::new(); + record_gnu_roots(&mut bare, "f.txt", "f.txt"); + record_gnu_roots(&mut bare, "/f.txt", "/f.txt"); + assert!(bare.is_empty(), "{bare:?}"); + } + + /// Every fixture is a real capture, so the detectors only ever see + /// well-formed lines there. These are the near misses they must reject: + /// a line one edit away from the shape, which prose can reach. + #[test] + fn detectors_reject_near_misses() { + assert!(is_hg_echo("diff -r 0123456789ab -r 0123456789cd f.txt")); + assert!(is_hg_echo("diff -r 0123456789ab f.txt")); + assert!(!is_hg_echo("diff -r zzzzzzzzzzzz -r 0123456789cd f.txt")); + assert!(!is_hg_echo("diff -r 0123456789ab -r zzzzzzzzzzzz f.txt")); + assert!(!is_hg_echo("diff -r 0123456789abcd -r 0123456789cd f.txt")); + + let sha1 = "a".repeat(40); + assert!(is_mbox_from(&format!("From {sha1} Mon Sep 17 00:00:00 2001"))); + assert!(is_mbox_from(&format!( + "From {} Mon Sep 17 00:00:00 2001", + "b".repeat(64) + ))); + assert!(!is_mbox_from(&format!( + "From {} Mon Sep 17 00:00:00 2001", + "z".repeat(40) + ))); + assert!(!is_mbox_from(&format!("From {sha1}"))); + assert!(!is_mbox_from( + "From the reporter's description this looked like a parser bug, but" + )); + + assert!(is_submodule_range("Submodule sub 0123456..89abcde:")); + assert!(is_submodule_range("Submodule sub 0123456..89abcde (rewind):")); + assert!(!is_submodule_range("Submodule sub zzzzzzz..89abcde:")); + assert!(!is_submodule_range("Submodule sub 0123456..zzzzzzz:")); + assert!(!is_submodule_range("Submodule sub 01234..89abcde:")); + assert!(!is_submodule_range("Submodule sub contains modified content")); + } // --- condense_unified_diff --- #[test] @@ -7187,4 +7263,3 @@ diff --git a/b.rs b/b.rs ); } } -