From ab308f7b7fb7ed98741a0aef3496c886cabc84e2 Mon Sep 17 00:00:00 2001 From: Jan Petykiewicz Date: Wed, 18 Nov 2026 23:16:09 -0800 Subject: [PATCH] Pair unique layer-only shape changes --- docs/cli.md | 7 +- docs/diff-reports.md | 9 ++- src/review.rs | 17 +++-- src/review/changes.rs | 146 ++++++++++++++++++++++++++++++++++-------- tests/review.rs | 112 ++++++++++++++++++++++++++++++++ 5 files changed, 253 insertions(+), 38 deletions(-) diff --git a/docs/cli.md b/docs/cli.md index 2c0d51f..fbaadba 100644 --- a/docs/cli.md +++ b/docs/cli.md @@ -68,6 +68,8 @@ displayed rows gets one legend entry. Object details use `-` for removals, `+` f and `~` for likely replacements. Identical unmatched objects share a row with a count such as `+ 12× 1/0: path …`. Unmatched paths with five or more vertices show their width, vertex count, and vertex bounds in one line. +A unique polygon, box, or path replacement that differs only in layer or +datatype appears on one row, for example `~ 1/0 (WG) → 2/0 (CORE) · rectangle`. Use `--format json` for details of individual objects and `--hierarchy` to see which parent cells are affected. @@ -128,8 +130,9 @@ comparison, totals, or exit status. A layer display filter hides references without a numeric layer. `--max-changes N` limits displayed object occurrences after filtering. Text defaults to 100 occurrences and shows a replacement only when both objects fit within the limit. Grouped rows count each object toward -the limit. A single omission line lists changes hidden by filters or the -limit. JSON has no default object limit and reports +the limit. When a layer filter selects one side of a layer-only replacement, +that side appears as an addition or removal. A single omission line lists +changes hidden by filters or the limit. JSON has no default object limit and reports omissions from both display filters and any explicit limit in `report_selection`. See the [JSON reference](diff-reports.md) for the selection counters. diff --git a/docs/diff-reports.md b/docs/diff-reports.md index ef870a5..c88cdfd 100644 --- a/docs/diff-reports.md +++ b/docs/diff-reports.md @@ -90,9 +90,12 @@ explicit defaults remain significant. For gzip inputs, source offsets locate records in the decompressed layout. Replacements link report-local removed/added IDs with `match_rule`, -`field_changes`, and `properties_changed`. Rules are `unique_kind_layer_bounds`, -`unique_kind_layer`, or `unique_kind_target`. IDs are not persistent identities; -ambiguous candidates stay separate. Explanation text is for display only. +`field_changes`, and `properties_changed`. The `unique_layer_change` rule +matches a unique polygon, box, or path on each side with identical retained +fields and properties outside the layer and datatype fields. The other rules +are `unique_kind_layer_bounds`, `unique_kind_layer`, and `unique_kind_target`. +Ambiguous candidates stay separate. Replacement IDs refer only to objects in +the current report. Explanation text is for display only. ## Diagnostics and hierarchy diff --git a/src/review.rs b/src/review.rs index f1a2820..dcdb302 100644 --- a/src/review.rs +++ b/src/review.rs @@ -1543,7 +1543,7 @@ impl Comparison { let body_start = out.len(); let mut removed_cells = String::new(); let mut added_cells = String::new(); - let mut layers = changes::LayerRows::new(&self.layer_legend); + let mut layers = changes::LayerRows::new(&self.layer_legend, &self.layer_names); let mut annotations = Vec::new(); let mut covered_edges = BTreeSet::new(); let mut detail_total = 0; @@ -1587,12 +1587,19 @@ impl Comparison { let mut paired_old = BTreeSet::new(); let mut paired_new = BTreeSet::new(); for replacement in &cell.replacements { - paired_old.insert(replacement.removed); - paired_new.insert(replacement.added); let a = &cell.removed[replacement.removed]; let b = &cell.added[replacement.added]; - if max_objects - shown >= 2 && visible(a) && visible(b) { - if is_polygon(a.kind) { + if !visible(a) || !visible(b) { + continue; + } + paired_old.insert(replacement.removed); + paired_new.insert(replacement.added); + if max_objects - shown >= 2 { + if a.layer != b.layer { + out.push_str(" ~ "); + changes::write_layer_transition(&mut out, a, b, Some(&mut layers)); + out.push('\n'); + } else if is_polygon(a.kind) { polygons.replacement(a, b); } else { out.push_str(" ~ "); diff --git a/src/review/changes.rs b/src/review/changes.rs index 2f0a6cd..9b4e88b 100644 --- a/src/review/changes.rs +++ b/src/review/changes.rs @@ -25,38 +25,82 @@ fn group(object: &ObjectChange, bounds: bool) -> Group { ) } +fn unique_groups<'a, K: Ord>( + objects: &'a [ObjectChange], + key: impl Fn(usize, &'a ObjectChange) -> Option, +) -> BTreeMap> { + let mut groups = BTreeMap::new(); + for (index, object) in objects.iter().enumerate() { + if let Some(key) = key(index, object) { + groups + .entry(key) + .and_modify(|value| *value = None) + .or_insert(Some(index)); + } + } + groups +} + +type ShapeKey<'a> = (u16, Vec<(u16, &'a [u8])>, &'a [(u16, Vec)]); + +fn shape_without_layer(object: &ObjectChange) -> Option> { + if object.layer.is_none() || !(is_polygon(object.kind) || object.kind == RTAG_PATH) { + return None; + } + let fields = object + .fields + .iter() + .filter(|field| !matches_layer_field(object.kind, field.tag)) + .map(|field| (field.tag, field.data.as_slice())) + .collect(); + Some((object.kind, fields, &object.properties)) +} + +fn layer_replacements(old: &[ObjectChange], new: &[ObjectChange]) -> Vec { + // Most small edits touch a single numeric pair. + let Some(layer) = old.iter().chain(new).find_map(|object| object.layer) else { + return Vec::new(); + }; + if !old + .iter() + .chain(new) + .any(|object| object.layer.is_some_and(|pair| pair != layer)) + { + return Vec::new(); + } + let a = unique_groups(old, |_, object| shape_without_layer(object)); + let b = unique_groups(new, |_, object| shape_without_layer(object)); + a.into_iter() + .filter_map(|(key, removed)| { + let removed = removed?; + let added = b.get(&key).copied().flatten()?; + (old[removed].layer != new[added].layer).then_some(Replacement { + removed, + added, + match_rule: "unique_layer_change", + }) + }) + .collect() +} + /// Pair only unique candidates in the remaining multisets. Ambiguous groups /// remain additions/removals; no identity or geometric equivalence is inferred. pub(super) fn replacements(old: &[ObjectChange], new: &[ObjectChange]) -> Vec { if old.is_empty() || new.is_empty() { return Vec::new(); } - let (mut used_old, mut used_new) = (BTreeSet::new(), BTreeSet::new()); - let mut result = Vec::new(); + let mut result = layer_replacements(old, new); + let (mut used_old, mut used_new): (BTreeSet<_>, BTreeSet<_>) = + result.iter().map(|pair| (pair.removed, pair.added)).unzip(); for bounds in [true, false] { - let (mut a, mut b) = ( - BTreeMap::>::new(), - BTreeMap::>::new(), - ); - for (i, object) in old - .iter() - .enumerate() - .filter(|(i, _)| !used_old.contains(i)) - { - a.entry(group(object, bounds)).or_default().push(i); - } - for (i, object) in new - .iter() - .enumerate() - .filter(|(i, _)| !used_new.contains(i)) - { - b.entry(group(object, bounds)).or_default().push(i); - } - for (key, indices) in a { - if let (1, Some(others)) = (indices.len(), b.get(&key)) - && others.len() == 1 - { - let (i, j) = (indices[0], others[0]); + let a = unique_groups(old, |i, object| { + (!used_old.contains(&i)).then(|| group(object, bounds)) + }); + let b = unique_groups(new, |i, object| { + (!used_new.contains(&i)).then(|| group(object, bounds)) + }); + for (key, index) in a { + if let (Some(i), Some(&Some(j))) = (index, b.get(&key)) { result.push(Replacement { removed: i, added: j, @@ -407,17 +451,37 @@ impl ShownReferences { pub(super) struct LayerRows<'a> { names: &'a BTreeMap, + name_changes: &'a [LayerNameChange], rows: BTreeMap>, } impl<'a> LayerRows<'a> { - pub fn new(names: &'a BTreeMap) -> Self { + pub fn new(names: &'a BTreeMap, name_changes: &'a [LayerNameChange]) -> Self { Self { names, + name_changes, rows: BTreeMap::new(), } } + fn write_transition_layer(&mut self, out: &mut String, layer: Layer, side: Side) { + self.record(Some(layer), out.len()); + write!(out, "{}/{}", layer.0, layer.1).unwrap(); + if let Ok(index) = self + .name_changes + .binary_search_by_key(&layer, |change| change.layer) + { + let change = &self.name_changes[index]; + let name = match side { + Side::Old => &change.old, + Side::New => &change.new, + }; + if let Some(name) = name { + write!(out, " ({})", cell_label(name)).unwrap(); + } + } + } + pub fn record(&mut self, layer: Option, row_start: usize) { if let Some(layer) = layer && self.names.contains_key(&layer) @@ -433,8 +497,11 @@ impl<'a> LayerRows<'a> { for (layer, first) in self.rows { let name = &self.names[&layer]; if let Some(at) = first { - // Each recorded heading starts with the numeric layer/type and a colon. - let at = at + text[at..].find(':').unwrap(); + let at = at + + text[at..] + .bytes() + .take_while(|b| b.is_ascii_digit() || *b == b'/') + .count(); annotations.push((at, format!(" ({})", cell_label(name)))); } else { writeln!(legend, "{}/{}: name {name:?}", layer.0, layer.1).unwrap(); @@ -443,6 +510,24 @@ impl<'a> LayerRows<'a> { } } +pub(super) fn write_layer_transition( + out: &mut String, + old: &ObjectChange, + new: &ObjectChange, + layers: Option<&mut LayerRows<'_>>, +) { + let (from, to) = (old.layer.unwrap(), new.layer.unwrap()); + if let Some(layers) = layers { + layers.write_transition_layer(out, from, Side::Old); + out.push_str(" → "); + layers.write_transition_layer(out, to, Side::New); + } else { + write!(out, "{}/{} → {}/{}", from.0, from.1, to.0, to.1).unwrap(); + } + let rectangular = is_polygon(old.kind) && rectangle_size(object_xy(old)).is_some(); + write!(out, " · {}", object_name(old.kind, rectangular)).unwrap(); +} + fn polygon_replacement(old: &ObjectChange, new: &ObjectChange) -> String { let before = object_xy(old); let after = object_xy(new); @@ -471,6 +556,11 @@ fn polygon_replacement(old: &ObjectChange, new: &ObjectChange) -> String { } pub(super) fn replacement_summary(old: &ObjectChange, new: &ObjectChange) -> String { + if old.layer != new.layer && old.layer.is_some() && new.layer.is_some() { + let mut out = String::new(); + write_layer_transition(&mut out, old, new, None); + return out; + } let polygon = is_polygon(old.kind); let mut out = if polygon { polygon_replacement(old, new) diff --git a/tests/review.rs b/tests/review.rs index cf31509..72b8a05 100644 --- a/tests/review.rs +++ b/tests/review.rs @@ -1813,6 +1813,118 @@ fn replacement_explanations_are_unique_and_keep_full_evidence() { assert!(!text.contains("xy=")); } +#[test] +fn layer_only_shape_replacements_keep_evidence_and_respect_selection() { + let rect = [[10, 0], [0, 0], [0, 10], [10, 10], [10, 0]]; + let on_core = ring(RTAG_BOUNDARY, RTAG_DATATYPE, 2, &rect); + let named = |mut objects: Vec>, names: &[&str]| { + objects.push(label((900, 7), LAYER_SENTINEL)); + objects.extend(names.iter().map(|name| label((900, 7), name))); + layout(&[("CHIP", objects)]) + }; + let old = named(vec![square()], &["1:0:WG", "2:0:CORE"]); + let new = named(vec![on_core.clone()], &["1:0:WG", "2:0:CORE"]); + let old = Document::parse(&old).unwrap(); + let diff = Comparison::between(&old, &Document::parse(&new).unwrap()); + assert_eq!( + diff.text(2), + "Different\nCells:\n* CHIP\n ~ 1/0 (WG) → 2/0 (CORE) · rectangle\n" + ); + let limited = diff.text(1); + assert!(limited.contains("2 object changes over the limit")); + assert!(!limited.contains("Cells:")); + for (pair, suffix) in [ + ((1, 0), " 1/0 (WG): 1 rectangle removed\n"), + ((2, 0), " 2/0 (CORE): 1 rectangle added\n"), + ] { + let filtered = diff.text_filtered( + 1, + &DisplayFilter { + cell: None, + layer: Some(pair), + }, + ); + assert!(filtered.contains("1 object change filtered out")); + assert!(filtered.ends_with(suffix), "{filtered}"); + } + let json = diff.json_report(&Default::default(), &Default::default()); + let replacement = &json["cell_changes"][0]["replacements"][0]; + assert_eq!(replacement["match_rule"], "unique_layer_change"); + assert_eq!(replacement["field_changes"].as_array().unwrap().len(), 1); + assert_eq!(replacement["field_changes"][0]["tag"], RTAG_LAYER); + assert_eq!(json["summary"]["removed_objects"], "1"); + assert_eq!(json["summary"]["added_objects"], "1"); + + let old = named(vec![square()], &["1:0:WG"]); + let new = named(vec![on_core], &["2:0:CORE"]); + let diff = Comparison::between( + &Document::parse(&old).unwrap(), + &Document::parse(&new).unwrap(), + ); + assert!( + diff.text(2) + .ends_with(" ~ 1/0 (WG) → 2/0 (CORE) · rectangle\n") + ); +} + +#[test] +fn layer_only_matching_requires_unique_shapes_and_identical_payloads() { + let core_square = ring( + RTAG_BOUNDARY, + RTAG_DATATYPE, + 2, + &[[0, 0], [10, 0], [10, 10], [0, 10], [0, 0]], + ); + for (old, new) in [ + (vec![square(), square()], vec![core_square.clone()]), + ( + vec![square()], + vec![core_square.clone(), core_square.clone()], + ), + (vec![square()], vec![with_property(core_square, "new")]), + ( + vec![square()], + vec![ring( + RTAG_BOUNDARY, + RTAG_DATATYPE, + 2, + &[[0, 0], [10, 0], [0, 10], [0, 0]], + )], + ), + ] { + let old = layout(&[("CHIP", old)]); + let new = layout(&[("CHIP", new)]); + let diff = Comparison::between( + &Document::parse(&old).unwrap(), + &Document::parse(&new).unwrap(), + ); + assert!(diff.cells[0].replacements.is_empty()); + assert!(diff.text(100).contains(" removed\n")); + assert!(diff.text(100).contains(" added\n")); + } +} + +#[test] +fn datatype_only_path_changes_pair_on_the_same_layer() { + let old = layout(&[("CHIP", vec![path(Some(8), &[[0, 0], [10, 10]])])]); + let old_doc = Document::parse(&old).unwrap(); + let at = old_doc + .records + .iter() + .find(|record| record.tag == RTAG_DATATYPE) + .unwrap() + .offset + + 4; + let mut new = old.clone(); + new[at..at + 2].copy_from_slice(&3_u16.to_be_bytes()); + let diff = Comparison::between(&old_doc, &Document::parse(&new).unwrap()); + assert!(diff.text(2).ends_with(" ~ 1/0 → 1/3 · path\n")); + assert_eq!( + diff.cells[0].replacements[0].match_rule, + "unique_layer_change" + ); +} + #[test] fn polygon_diff_reports_single_displacements_and_groups_bulk_moves() { let before = layout(&[("CHIP", vec![with_property(square(), "old")])]);