Pair unique layer-only shape changes
This commit is contained in:
parent
87683db7e8
commit
ab308f7b7f
5 changed files with 253 additions and 38 deletions
|
|
@ -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.
|
||||
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
||||
|
|
|
|||
|
|
@ -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(" ~ ");
|
||||
|
|
|
|||
|
|
@ -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<K>,
|
||||
) -> BTreeMap<K, Option<usize>> {
|
||||
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<u8>)]);
|
||||
|
||||
fn shape_without_layer(object: &ObjectChange) -> Option<ShapeKey<'_>> {
|
||||
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<Replacement> {
|
||||
// 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<Replacement> {
|
||||
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::<Group, Vec<usize>>::new(),
|
||||
BTreeMap::<Group, Vec<usize>>::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<Layer, String>,
|
||||
name_changes: &'a [LayerNameChange],
|
||||
rows: BTreeMap<Layer, Option<usize>>,
|
||||
}
|
||||
|
||||
impl<'a> LayerRows<'a> {
|
||||
pub fn new(names: &'a BTreeMap<Layer, String>) -> Self {
|
||||
pub fn new(names: &'a BTreeMap<Layer, String>, 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<Layer>, 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)
|
||||
|
|
|
|||
112
tests/review.rs
112
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<Vec<u8>>, 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")])]);
|
||||
|
|
|
|||
Loading…
Reference in a new issue