Diffs and overwrite mode should not replace wildcards with full output

[joshtriplett]

Observed in Cargo: when a test fails due to a mismatch in the output, then in addition to providing the new output, snapbox will also show a diff from any wildcards to the full output, and SNAPSHOTS=overwrite will replace the wildcards with the full output. snapbox should not produce or overwrite diffs where the - of the diff is a wildcard and the + of the diff is output matching that wildcard.

[epage]

Snapbox tries to maintain wildcard redactions as much as possible. The way that it works is it tries to normalize the actual output as much as possible to the expected output and then compares that to fail the assertion, render the diff, or overwrite the expected result.

That doesn't mean there can't be improvements to the algorithm; its just a matter of trade offs in which cases are handled, when it might redact the wrong thing, and performance (since it handles redactions on the assertion and not just when overwriting).

If you are curious, the logic is at

snapbox/crates/snapbox/src/filter/pattern.rs

Lines 529 to 577 in 15be600

	fn normalize_str_to_redactions(actual: &str, expected: &str, redactions: &Redactions) -> String {
	if actual == expected {
	return actual.to_owned();
	}
	let mut normalized: Vec<&str> = Vec::new();
	let mut actual_index = 0;
	let actual_lines: Vec<_> = crate::utils::LinesWithTerminator::new(actual).collect();
	let mut expected_lines = crate::utils::LinesWithTerminator::new(expected).peekable();
	while let Some(expected_line) = expected_lines.next() {
	if is_line_elide(expected_line) {
	let Some(next_expected_line) = expected_lines.peek() else {
	// Stop as elide consumes to end
	normalized.push(expected_line);
	actual_index = actual_lines.len();
	break;
	};
	let Some(index_offset) =
	actual_lines[actual_index..]
	.iter()
	.position(|next_actual_line| {
	line_matches(next_actual_line, next_expected_line, redactions)
	})
	else {
	// Give up as we can't find where the elide ends
	break;
	};
	normalized.push(expected_line);
	actual_index += index_offset;
	} else {
	let Some(actual_line) = actual_lines.get(actual_index) else {
	// Give up as we have no more content to check
	break;
	};
	if line_matches(actual_line, expected_line, redactions) {
	actual_index += 1;
	normalized.push(expected_line);
	} else {
	// Skip this line and keep processing
	actual_index += 1;
	normalized.push(actual_line);
	}
	}
	}
	normalized.extend(actual_lines[actual_index..].iter().copied());
	normalized.join("")
	}

Further up is similar logic for matching arrays or objects in json. We also have slightly different cases for unordered vs ordered matches.