From 852660bcc608e109e56b5ed60cb2b8d01b4c22c9 Mon Sep 17 00:00:00 2001 From: Jan Petykiewicz Date: Thu, 19 Nov 2026 08:35:08 -0800 Subject: [PATCH] Separate text evidence selection from report formatting --- src/review.rs | 122 ++++++++++++++-------------------------- src/review/selection.rs | 98 ++++++++++++++++++++++++++++++++ 2 files changed, 139 insertions(+), 81 deletions(-) diff --git a/src/review.rs b/src/review.rs index 70b2b4b..fc9e16e 100644 --- a/src/review.rs +++ b/src/review.rs @@ -1579,62 +1579,22 @@ impl Comparison { .unwrap(); } let body_start = out.len(); - let mut removed_cells = String::new(); - let mut added_cells = String::new(); + let selection = selection::TextSelection::new(&self.cells, show, max_objects); 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; - let mut selected = 0; - let mut shown: usize = 0; - let mut hidden_cell_changes = 0; - let visible = - |object: &ObjectChange| show.layer.is_none_or(|layer| object.layer == Some(layer)); - for cell in &self.cells { - let marker = cell_marker(cell.old.is_some(), cell.new.is_some()); - let attributes_changed = marker == '*' && cell.attributes_changed(); - if marker == '*' { - detail_total += cell.removed.len() + cell.added.len(); - } - if show.cell.as_ref().is_some_and(|name| name != &cell.name) { - hidden_cell_changes += usize::from(marker != '*' || attributes_changed); - continue; - } + for selected in &selection.modified_cells { + let cell = selected.cell; let name = cell_label(&cell.name); - match marker { - '-' => { - writeln!(removed_cells, "- {name}").unwrap(); - continue; - } - '+' => { - writeln!(added_cells, "+ {name}").unwrap(); - continue; - } - _ => (), - }; - let note = if attributes_changed { + let note = if selected.attributes_changed { " (attributes changed)" } else { "" }; - let cell_start = out.len(); - let previously_shown = shown; writeln!(out, "* {name}{note}").unwrap(); let mut polygons = changes::PolygonChanges::default(); let mut shown_refs = BTreeMap::<&str, changes::ShownReferences>::new(); - let mut paired_old = BTreeSet::new(); - let mut paired_new = BTreeSet::new(); - for replacement in &cell.replacements { - let a = &cell.removed[replacement.removed]; - let b = &cell.added[replacement.added]; - if !visible(a) || !visible(b) { - continue; - } - paired_old.insert(replacement.removed); - paired_new.insert(replacement.added); - if max_objects - shown < 2 { - continue; - } + for &(a, b) in &selected.replacements { if !details && a.layer == b.layer && is_polygon(a.kind) { polygons.replacement(a, b); } else { @@ -1661,39 +1621,31 @@ impl Comparison { .replacement(a, b, row_start); } } - shown += 2; } let mut removed_refs = BTreeMap::new(); let mut added_refs = BTreeMap::new(); - for (removed, objects, paired, references) in [ - (true, &cell.removed, &paired_old, &mut removed_refs), - (false, &cell.added, &paired_new, &mut added_refs), + for (removed, objects, references) in [ + (true, &selected.removed, &mut removed_refs), + (false, &selected.added, &mut added_refs), ] { let sign = if removed { "-" } else { "+" }; let mut unmatched: Vec<(&ObjectChange, usize)> = Vec::new(); - for (index, object) in objects.iter().enumerate() { - if !visible(object) { - continue; - } - selected += 1; - if !paired.contains(&index) && shown < max_objects { - if !details && is_polygon(object.kind) { - polygons.unmatched(object, removed); - } else if !details && let Some(target) = object.target.as_deref() { - let (_, counts) = references - .entry(target) - .or_insert_with(|| (object, changes::ReferenceCounts::default())); - counts.add(object); - } else if let Some((last, count)) = unmatched.last_mut() - && last.kind == object.kind - && last.fields == object.fields - && last.properties == object.properties - { - *count += 1; - } else { - unmatched.push((object, 1)); - } - shown += 1; + for &object in objects { + if !details && is_polygon(object.kind) { + polygons.unmatched(object, removed); + } else if !details && let Some(target) = object.target.as_deref() { + let (_, counts) = references + .entry(target) + .or_insert_with(|| (object, changes::ReferenceCounts::default())); + counts.add(object); + } else if let Some((last, count)) = unmatched.last_mut() + && last.kind == object.kind + && last.fields == object.fields + && last.properties == object.properties + { + *count += 1; + } else { + unmatched.push((object, 1)); } } // The comparison orders these objects by kind, fields, and properties. @@ -1766,9 +1718,6 @@ impl Comparison { } } polygons.write(&mut out, &mut layers); - if shown == previously_shown && !attributes_changed { - out.truncate(cell_start); - } } let mut before_cells = String::new(); layers.finish(&out, &mut annotations, &mut before_cells); @@ -1785,17 +1734,28 @@ impl Comparison { annotated.push_str(&out[start..]); out = annotated; } - if out.len() > body_start || !removed_cells.is_empty() || !added_cells.is_empty() { + if !selection.modified_cells.is_empty() + || !selection.removed_cells.is_empty() + || !selection.added_cells.is_empty() + { before_cells.push_str("Cells:\n"); - before_cells.push_str(&removed_cells); - before_cells.push_str(&added_cells); + for name in selection.removed_cells { + writeln!(before_cells, "- {}", cell_label(name)).unwrap(); + } + for name in selection.added_cells { + writeln!(before_cells, "+ {}", cell_label(name)).unwrap(); + } } out.insert_str(body_start, &before_cells); let mut omissions = Vec::new(); for (count, label, reason) in [ - (detail_total - selected, "object change", "filtered out"), - (selected - shown, "object change", "over the limit"), - (hidden_cell_changes, "cell-level change", "filtered out"), + (selection.filtered_objects, "object change", "filtered out"), + (selection.limited_objects, "object change", "over the limit"), + ( + selection.filtered_cells, + "cell-level change", + "filtered out", + ), ] { if count != 0 { let plural = if count == 1 { "" } else { "s" }; diff --git a/src/review/selection.rs b/src/review/selection.rs index db52a59..71b2594 100644 --- a/src/review/selection.rs +++ b/src/review/selection.rs @@ -16,6 +16,104 @@ pub struct DisplayFilter { pub layer: Option, } +#[derive(Default)] +pub(super) struct TextSelection<'a> { + pub removed_cells: Vec<&'a str>, + pub added_cells: Vec<&'a str>, + pub modified_cells: Vec>, + pub filtered_objects: usize, + pub limited_objects: usize, + pub filtered_cells: usize, +} + +pub(super) struct TextCellSelection<'a> { + pub cell: &'a CellChange, + pub attributes_changed: bool, + pub replacements: Vec<(&'a ObjectChange, &'a ObjectChange)>, + pub removed: Vec<&'a ObjectChange>, + pub added: Vec<&'a ObjectChange>, +} + +impl<'a> TextSelection<'a> { + pub fn new(cells: &'a [CellChange], show: &DisplayFilter, mut remaining: usize) -> Self { + let mut selection = Self::default(); + let visible = + |object: &ObjectChange| show.layer.is_none_or(|layer| object.layer == Some(layer)); + for cell in cells { + let marker = cell_marker(cell.old.is_some(), cell.new.is_some()); + let attributes_changed = marker == '*' && cell.attributes_changed(); + if show.cell.as_ref().is_some_and(|name| name != &cell.name) { + selection.filtered_cells += usize::from(marker != '*' || attributes_changed); + if marker == '*' { + selection.filtered_objects += cell.removed.len() + cell.added.len(); + } + continue; + } + match marker { + '-' => { + selection.removed_cells.push(&cell.name); + continue; + } + '+' => { + selection.added_cells.push(&cell.name); + continue; + } + _ => (), + } + + let mut selected = TextCellSelection { + cell, + attributes_changed, + replacements: Vec::new(), + removed: Vec::new(), + added: Vec::new(), + }; + let mut paired_old = BTreeSet::new(); + let mut paired_new = BTreeSet::new(); + for pair in &cell.replacements { + let old = &cell.removed[pair.removed]; + let new = &cell.added[pair.added]; + if visible(old) && visible(new) { + paired_old.insert(pair.removed); + paired_new.insert(pair.added); + if remaining >= 2 { + selected.replacements.push((old, new)); + remaining -= 2; + } else { + selection.limited_objects += 2; + } + } + } + // A layer filter may leave one side of a pair eligible on its own. + for (objects, paired, selected) in [ + (&cell.removed, &paired_old, &mut selected.removed), + (&cell.added, &paired_new, &mut selected.added), + ] { + for (index, object) in objects.iter().enumerate() { + if !visible(object) { + selection.filtered_objects += 1; + } else if !paired.contains(&index) { + if remaining == 0 { + selection.limited_objects += 1; + } else { + selected.push(object); + remaining -= 1; + } + } + } + } + if attributes_changed + || !selected.replacements.is_empty() + || !selected.removed.is_empty() + || !selected.added.is_empty() + { + selection.modified_cells.push(selected); + } + } + selection + } +} + impl Scope { pub(super) fn write_restrictions(&self, out: &mut String) { if self == &Self::default() {