Render layer labels and terminal styles from report roles
This commit is contained in:
parent
852660bcc6
commit
b5071444f5
1 changed files with 843 additions and 648 deletions
668
src/review.rs
668
src/review.rs
|
|
@ -17,11 +17,14 @@ pub mod names;
|
|||
mod pair;
|
||||
pub mod report;
|
||||
pub mod selection;
|
||||
mod text;
|
||||
|
||||
use changes::Replacement;
|
||||
use pair::CellReuse;
|
||||
pub use pair::RevisionPair;
|
||||
use selection::{DisplayFilter, Scope};
|
||||
use text::CellText;
|
||||
pub use text::{TextReport, TextStyle};
|
||||
|
||||
/// Input revision associated with a diagnostic.
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
||||
|
|
@ -166,12 +169,13 @@ impl Object<'_> {
|
|||
}
|
||||
}
|
||||
|
||||
fn format_object<'a>(
|
||||
out: &mut fmt::Formatter<'_>,
|
||||
fn format_object<'a, W: fmt::Write>(
|
||||
out: &mut W,
|
||||
kind: u16,
|
||||
layer: Option<Layer>,
|
||||
fields: impl Iterator<Item = (u16, &'a [u8])> + Clone,
|
||||
properties: impl IntoIterator<Item = (u16, &'a [u8])>,
|
||||
heading: impl FnOnce(&mut W, &'static str) -> fmt::Result,
|
||||
) -> fmt::Result {
|
||||
let field = |tag| {
|
||||
fields
|
||||
|
|
@ -193,10 +197,7 @@ fn format_object<'a>(
|
|||
} else {
|
||||
None
|
||||
};
|
||||
if let Some((layer, datatype)) = layer {
|
||||
write!(out, "{layer}/{datatype}: ")?;
|
||||
}
|
||||
out.write_str(object_name(kind, rectangle.is_some()))?;
|
||||
heading(out, object_name(kind, rectangle.is_some()))?;
|
||||
if let Some(target) = target {
|
||||
write!(out, " {}", quoted(target))?;
|
||||
}
|
||||
|
|
@ -236,7 +237,7 @@ fn array_dimensions(data: &[u8]) -> Option<[u16; 2]> {
|
|||
|
||||
const POINTS_PER_LINE: usize = 4;
|
||||
|
||||
fn write_points(out: &mut fmt::Formatter<'_>, data: &[u8]) -> fmt::Result {
|
||||
fn write_points(out: &mut impl fmt::Write, data: &[u8]) -> fmt::Result {
|
||||
let mut points = XY::points(data);
|
||||
if points.len() == 1 {
|
||||
let [x, y] = points.next().unwrap();
|
||||
|
|
@ -258,6 +259,27 @@ fn write_points(out: &mut fmt::Formatter<'_>, data: &[u8]) -> fmt::Result {
|
|||
|
||||
impl fmt::Display for Object<'_> {
|
||||
fn fmt(&self, out: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||
self.format_with_heading(out, |out, name| write_object_heading(out, self.layer, name))
|
||||
}
|
||||
}
|
||||
|
||||
fn write_object_heading(
|
||||
out: &mut impl fmt::Write,
|
||||
layer: Option<Layer>,
|
||||
name: &str,
|
||||
) -> fmt::Result {
|
||||
if let Some((layer, datatype)) = layer {
|
||||
write!(out, "{layer}/{datatype}: ")?;
|
||||
}
|
||||
out.write_str(name)
|
||||
}
|
||||
|
||||
impl Object<'_> {
|
||||
fn format_with_heading<W: fmt::Write>(
|
||||
&self,
|
||||
out: &mut W,
|
||||
heading: impl FnOnce(&mut W, &'static str) -> fmt::Result,
|
||||
) -> fmt::Result {
|
||||
format_object(
|
||||
out,
|
||||
self.kind,
|
||||
|
|
@ -267,6 +289,7 @@ impl fmt::Display for Object<'_> {
|
|||
.iter()
|
||||
.map(|(tag, data)| (*tag, data.as_ref())),
|
||||
self.key.properties.iter().copied(),
|
||||
heading,
|
||||
)
|
||||
}
|
||||
}
|
||||
|
|
@ -886,12 +909,21 @@ impl<'a> Document<'a> {
|
|||
|
||||
pub fn hierarchy(&self, mermaid: bool, max_depth: usize) -> String {
|
||||
let revision = Revision::from_document(self);
|
||||
render_hierarchy(&revision, &revision, None, mermaid, max_depth, None)
|
||||
render_hierarchy(&revision, &revision, None, mermaid, max_depth)
|
||||
}
|
||||
|
||||
pub fn canonical_dump(&self) -> String {
|
||||
let mut out = TextReport::default();
|
||||
self.write_canonical_dump(&mut out);
|
||||
out.into_string()
|
||||
}
|
||||
|
||||
/// Append the canonical object dump and its presentation roles.
|
||||
pub fn write_canonical_dump(&self, out: &mut TextReport) {
|
||||
if !self.present {
|
||||
return "library absent\n".to_string();
|
||||
out.write_styled(TextStyle::Heading, format_args!("library absent"));
|
||||
out.push('\n');
|
||||
return;
|
||||
}
|
||||
let version_index = self
|
||||
.header
|
||||
|
|
@ -901,23 +933,29 @@ impl<'a> Document<'a> {
|
|||
let header = |tag| self.header.iter().find(|(t, _)| *t == tag).unwrap().1;
|
||||
let (user, meters) = header(RTAG_UNITS).split_at(8);
|
||||
let version = i16::from_be_bytes(self.header[version_index].1.try_into().unwrap());
|
||||
let mut out = format!(
|
||||
"library {} (GDSII {version}, {} user units/dbu, {} m/dbu)\n",
|
||||
quoted(header(RTAG_LIBNAME)),
|
||||
format_exact_value(RTAG_UNITS, user),
|
||||
format_exact_value(RTAG_UNITS, meters)
|
||||
out.write_styled(
|
||||
TextStyle::Heading,
|
||||
format_args!(
|
||||
"library {} (GDSII {version}, {} user units/dbu, {} m/dbu)",
|
||||
quoted(header(RTAG_LIBNAME)),
|
||||
format_exact_value(RTAG_UNITS, user),
|
||||
format_exact_value(RTAG_UNITS, meters)
|
||||
),
|
||||
);
|
||||
self.scope.write_restrictions(&mut out);
|
||||
out.push('\n');
|
||||
self.scope.write_restrictions(out);
|
||||
for (index, (tag, data)) in self.header.iter().enumerate() {
|
||||
if index != version_index && !matches!(*tag, RTAG_LIBNAME | RTAG_UNITS) {
|
||||
writeln!(out, "{}={}", tag_name(*tag), format_exact_value(*tag, data)).unwrap();
|
||||
}
|
||||
}
|
||||
for ((layer, dtype), name) in &self.layer_names {
|
||||
writeln!(out, "{layer}/{dtype}: name {name:?}").unwrap();
|
||||
out.write_styled(TextStyle::Layer, format_args!("{layer}/{dtype}"));
|
||||
writeln!(out, ": name {name:?}").unwrap();
|
||||
}
|
||||
for (name, cell) in &self.cells {
|
||||
writeln!(out, "cell {name:?}").unwrap();
|
||||
out.write_styled(TextStyle::Heading, format_args!("cell {name:?}"));
|
||||
out.push('\n');
|
||||
for (tag, data) in &cell.attributes {
|
||||
writeln!(
|
||||
out,
|
||||
|
|
@ -937,17 +975,34 @@ impl<'a> Document<'a> {
|
|||
while objects.next_if(|next| next.key == object.key).is_some() {
|
||||
count += 1;
|
||||
}
|
||||
if count == 1 {
|
||||
writeln!(out, " {object}").unwrap();
|
||||
} else {
|
||||
writeln!(out, " {count}x {object}").unwrap();
|
||||
out.push_str(" ");
|
||||
if count != 1 {
|
||||
write!(out, "{count}x ").unwrap();
|
||||
}
|
||||
object
|
||||
.format_with_heading(out, |out, name| {
|
||||
if let Some((layer, datatype)) = object.layer {
|
||||
out.write_styled(TextStyle::Layer, format_args!("{layer}/{datatype}"));
|
||||
out.push_str(": ");
|
||||
}
|
||||
if matches!(object.kind, RTAG_SREF | RTAG_AREF) && object.layer.is_none() {
|
||||
out.write_styled(TextStyle::Layer, format_args!("{name}"));
|
||||
} else {
|
||||
out.push_str(name);
|
||||
}
|
||||
Ok(())
|
||||
})
|
||||
.unwrap();
|
||||
out.push('\n');
|
||||
}
|
||||
}
|
||||
for diagnostic in &self.diagnostics {
|
||||
writeln!(out, "INCOMPLETE: {}", diagnostic.message).unwrap();
|
||||
out.write_styled(
|
||||
TextStyle::Warning,
|
||||
format_args!("INCOMPLETE: {}", diagnostic.message),
|
||||
);
|
||||
out.push('\n');
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
pub fn record_dump(&self) -> String {
|
||||
|
|
@ -957,18 +1012,30 @@ impl<'a> Document<'a> {
|
|||
|
||||
/// Inspect record boundaries even when object grammar or metadata is invalid.
|
||||
pub fn dump_records(input: &[u8]) -> Result<String, String> {
|
||||
Ok(format_records(&read_records(input)?))
|
||||
let mut out = TextReport::default();
|
||||
write_record_dump(&mut out, input)?;
|
||||
Ok(out.into_string())
|
||||
}
|
||||
|
||||
/// Append the raw record dump and its presentation roles.
|
||||
pub fn write_record_dump(out: &mut TextReport, input: &[u8]) -> Result<(), String> {
|
||||
write_records(out, &read_records(input)?);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn format_records(records: &[Record<'_>]) -> String {
|
||||
let mut out = String::new();
|
||||
let mut out = TextReport::default();
|
||||
write_records(&mut out, records);
|
||||
out.into_string()
|
||||
}
|
||||
|
||||
fn write_records(out: &mut TextReport, records: &[Record<'_>]) {
|
||||
for record in records {
|
||||
write!(out, "{:010} {:04x} ", record.offset, record.tag).unwrap();
|
||||
out.write_styled(TextStyle::Layer, format_args!("{}", tag_name(record.tag)));
|
||||
writeln!(
|
||||
out,
|
||||
"{:010} {:04x} {} size={} {}",
|
||||
record.offset,
|
||||
record.tag,
|
||||
tag_name(record.tag),
|
||||
" size={} {}",
|
||||
record.data.len() + 4,
|
||||
format_data(
|
||||
record.tag,
|
||||
|
|
@ -981,7 +1048,6 @@ fn format_records(records: &[Record<'_>]) -> String {
|
|||
)
|
||||
.unwrap();
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
/// A retained comparison field. Polygon coordinates and string padding follow
|
||||
|
|
@ -1019,6 +1085,16 @@ pub struct ObjectChange {
|
|||
|
||||
impl fmt::Display for ObjectChange {
|
||||
fn fmt(&self, out: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||
self.format_with_heading(out, |out, name| write_object_heading(out, self.layer, name))
|
||||
}
|
||||
}
|
||||
|
||||
impl ObjectChange {
|
||||
fn format_with_heading<W: fmt::Write>(
|
||||
&self,
|
||||
out: &mut W,
|
||||
heading: impl FnOnce(&mut W, &'static str) -> fmt::Result,
|
||||
) -> fmt::Result {
|
||||
format_object(
|
||||
out,
|
||||
self.kind,
|
||||
|
|
@ -1029,6 +1105,7 @@ impl fmt::Display for ObjectChange {
|
|||
self.properties
|
||||
.iter()
|
||||
.map(|(attribute, data)| (*attribute, data.as_slice())),
|
||||
heading,
|
||||
)
|
||||
}
|
||||
}
|
||||
|
|
@ -1249,6 +1326,18 @@ impl TextComparison {
|
|||
.render_text_with_options(max_objects, show, show_library_presence, options)
|
||||
}
|
||||
|
||||
pub fn write_text_report(
|
||||
&self,
|
||||
out: &mut TextReport,
|
||||
max_objects: usize,
|
||||
show: &DisplayFilter,
|
||||
show_library_presence: bool,
|
||||
options: TextReportOptions,
|
||||
) {
|
||||
self.comparison
|
||||
.write_text_report(out, max_objects, show, show_library_presence, options);
|
||||
}
|
||||
|
||||
/// Render the cell changes and their ASCII hierarchy together.
|
||||
pub fn render_text_with_ascii_hierarchy(
|
||||
&self,
|
||||
|
|
@ -1450,14 +1539,7 @@ impl Comparison {
|
|||
|
||||
/// Render the affected hierarchy. ASCII output shows relationships between cells.
|
||||
pub fn hierarchy(&self, mermaid: bool, max_depth: usize) -> String {
|
||||
render_hierarchy(
|
||||
&self.old,
|
||||
&self.new,
|
||||
Some(&self.cells),
|
||||
mermaid,
|
||||
max_depth,
|
||||
None,
|
||||
)
|
||||
render_hierarchy(&self.old, &self.new, Some(&self.cells), mermaid, max_depth)
|
||||
}
|
||||
|
||||
/// Limit presentation only: the complete comparison has already been made.
|
||||
|
|
@ -1512,19 +1594,59 @@ impl Comparison {
|
|||
show_library_presence: bool,
|
||||
options: TextReportOptions,
|
||||
) -> String {
|
||||
let TextReportOptions {
|
||||
details,
|
||||
ascii_depth,
|
||||
} = options;
|
||||
let mut out = TextReport::default();
|
||||
self.write_text_report(&mut out, max_objects, show, show_library_presence, options);
|
||||
out.into_string()
|
||||
}
|
||||
|
||||
/// Append the selected changes and their presentation roles to a text report.
|
||||
pub fn write_text_report(
|
||||
&self,
|
||||
out: &mut TextReport,
|
||||
max_objects: usize,
|
||||
show: &DisplayFilter,
|
||||
show_library_presence: bool,
|
||||
options: TextReportOptions,
|
||||
) {
|
||||
let selection = selection::TextSelection::new(&self.cells, show, max_objects);
|
||||
let outcome = self.outcome();
|
||||
let mut out = match outcome {
|
||||
Outcome::Equal => "Equal",
|
||||
Outcome::Different => "Different",
|
||||
Outcome::Incomplete { .. } => "Incomplete",
|
||||
Outcome::Failed => "Failed",
|
||||
let headline = out.len();
|
||||
let (result, style) = match outcome {
|
||||
Outcome::Equal => ("Equal", TextStyle::Success),
|
||||
Outcome::Different => ("Different", TextStyle::Warning),
|
||||
Outcome::Incomplete { .. } => ("Incomplete", TextStyle::Warning),
|
||||
Outcome::Failed => ("Failed", TextStyle::Error),
|
||||
};
|
||||
out.push_str(result);
|
||||
let has_omissions = selection.filtered_objects != 0
|
||||
|| selection.limited_objects != 0
|
||||
|| selection.filtered_cells != 0;
|
||||
if !self.cells.is_empty()
|
||||
&& (self.cells.len() > 3 || !outcome.is_complete() || has_omissions)
|
||||
{
|
||||
let (mut modified, mut added, mut removed) = (0, 0, 0);
|
||||
for cell in &self.cells {
|
||||
match cell_marker(cell.old.is_some(), cell.new.is_some()) {
|
||||
'-' => removed += 1,
|
||||
'+' => added += 1,
|
||||
_ => modified += 1,
|
||||
}
|
||||
}
|
||||
let mut counts = [
|
||||
(modified, "modified"),
|
||||
(added, "added"),
|
||||
(removed, "removed"),
|
||||
]
|
||||
.into_iter()
|
||||
.filter(|(count, _)| *count != 0);
|
||||
if let Some((count, action)) = counts.next() {
|
||||
let noun = if count == 1 { "cell" } else { "cells" };
|
||||
write!(out, " · {count} {noun} {action}").unwrap();
|
||||
for (count, action) in counts {
|
||||
write!(out, ", {count} {action}").unwrap();
|
||||
}
|
||||
}
|
||||
}
|
||||
.to_string();
|
||||
let headline_end = out.len();
|
||||
let library_changes = self.library_changes.iter().filter(|change| {
|
||||
show_library_presence || !matches!(change, LibraryChange::Presence { .. })
|
||||
});
|
||||
|
|
@ -1537,9 +1659,11 @@ impl Comparison {
|
|||
write!(out, " · {count} {label}{plural}").unwrap();
|
||||
}
|
||||
}
|
||||
out.mark(headline, style);
|
||||
out.push('\n');
|
||||
self.old.scope.write_restrictions(&mut out);
|
||||
self.old.scope.write_restrictions(out);
|
||||
if show.cell.is_some() || show.layer.is_some() {
|
||||
let start = out.len();
|
||||
out.push_str("Display filter");
|
||||
if let Some(cell) = &show.cell {
|
||||
write!(out, " cell={cell:?}").unwrap();
|
||||
|
|
@ -1547,9 +1671,29 @@ impl Comparison {
|
|||
if let Some((layer, datatype)) = show.layer {
|
||||
write!(out, " layer={layer}/{datatype}").unwrap();
|
||||
}
|
||||
out.mark(start, TextStyle::Heading);
|
||||
out.push('\n');
|
||||
}
|
||||
if has_omissions {
|
||||
let start = out.len();
|
||||
out.push_str("Omitted");
|
||||
for (count, label, reason) in [
|
||||
(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" };
|
||||
write!(out, " · {count} {label}{plural} {reason}").unwrap();
|
||||
}
|
||||
}
|
||||
out.mark(start, TextStyle::Warning);
|
||||
out.push('\n');
|
||||
}
|
||||
let notice_start = out.len();
|
||||
for change in library_changes {
|
||||
writeln!(out, "library {change}").unwrap();
|
||||
}
|
||||
|
|
@ -1578,229 +1722,39 @@ impl Comparison {
|
|||
)
|
||||
.unwrap();
|
||||
}
|
||||
let body_start = out.len();
|
||||
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 body = CellText::new(&self.layer_legend, &self.layer_names, out.is_styled());
|
||||
let mut covered_edges = BTreeSet::new();
|
||||
for selected in &selection.modified_cells {
|
||||
let cell = selected.cell;
|
||||
let name = cell_label(&cell.name);
|
||||
let note = if selected.attributes_changed {
|
||||
" (attributes changed)"
|
||||
} else {
|
||||
""
|
||||
};
|
||||
writeln!(out, "* {name}{note}").unwrap();
|
||||
let mut polygons = changes::PolygonChanges::default();
|
||||
let mut shown_refs = BTreeMap::<&str, changes::ShownReferences>::new();
|
||||
for &(a, b) in &selected.replacements {
|
||||
if !details && a.layer == b.layer && is_polygon(a.kind) {
|
||||
polygons.replacement(a, b);
|
||||
} else {
|
||||
out.push_str(" ~ ");
|
||||
let row_start = out.len();
|
||||
if a.layer != b.layer {
|
||||
changes::write_layer_transition(&mut out, a, b, Some(&mut layers));
|
||||
} else {
|
||||
layers.record(a.layer, row_start);
|
||||
if details {
|
||||
out.push_str(&changes::replacement_heading(a, b));
|
||||
} else {
|
||||
out.push_str(&changes::replacement_summary(a, b));
|
||||
}
|
||||
}
|
||||
out.push('\n');
|
||||
if details {
|
||||
changes::write_replacement_objects(&mut out, a, b);
|
||||
}
|
||||
if let Some(target) = &a.target {
|
||||
shown_refs
|
||||
.entry(target)
|
||||
.or_default()
|
||||
.replacement(a, b, row_start);
|
||||
}
|
||||
}
|
||||
}
|
||||
let mut removed_refs = BTreeMap::new();
|
||||
let mut added_refs = BTreeMap::new();
|
||||
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 &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.
|
||||
for (object, count) in unmatched {
|
||||
write!(out, " {sign} ").unwrap();
|
||||
if count > 1 {
|
||||
write!(out, "{count}× ").unwrap();
|
||||
}
|
||||
let row_start = out.len();
|
||||
layers.record(object.layer, row_start);
|
||||
if details {
|
||||
writeln!(out, "{object}").unwrap();
|
||||
if let Some(target) = object.target.as_deref() {
|
||||
shown_refs
|
||||
.entry(target)
|
||||
.or_default()
|
||||
.individual(object, removed, count, row_start);
|
||||
}
|
||||
} else {
|
||||
changes::write_unmatched(&mut out, object);
|
||||
}
|
||||
}
|
||||
}
|
||||
let no_refs = changes::ReferenceCounts::default();
|
||||
for (target, (first, counts)) in removed_refs {
|
||||
let row_start = out.len();
|
||||
if let Some((_, added)) = added_refs.remove(target) {
|
||||
counts.write_change(&mut out, target, &added);
|
||||
shown_refs
|
||||
.entry(target)
|
||||
.or_default()
|
||||
.unmatched(&counts, &added, row_start);
|
||||
} else {
|
||||
counts.write(&mut out, "-", target, first);
|
||||
shown_refs
|
||||
.entry(target)
|
||||
.or_default()
|
||||
.unmatched(&counts, &no_refs, row_start);
|
||||
}
|
||||
}
|
||||
for (target, (first, counts)) in added_refs {
|
||||
let row_start = out.len();
|
||||
counts.write(&mut out, "+", target, first);
|
||||
shown_refs
|
||||
.entry(target)
|
||||
.or_default()
|
||||
.unmatched(&no_refs, &counts, row_start);
|
||||
}
|
||||
if !shown_refs.is_empty() {
|
||||
for target in cell
|
||||
.removed
|
||||
.iter()
|
||||
.chain(&cell.added)
|
||||
.filter_map(|o| o.target.as_deref())
|
||||
{
|
||||
if let Some(shown) = shown_refs.get_mut(target) {
|
||||
shown.count_change();
|
||||
}
|
||||
}
|
||||
for (target, shown) in shown_refs {
|
||||
if shown.complete() {
|
||||
let edge = (cell.name.clone(), target.to_owned());
|
||||
let old = self.old.edges.get(&edge).copied().unwrap_or(0);
|
||||
let new = self.new.edges.get(&edge).copied().unwrap_or(0);
|
||||
shown.annotate(&out, &mut annotations, old, new);
|
||||
if ascii_depth.is_some() && outcome.is_complete() {
|
||||
covered_edges.insert(edge);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
polygons.write(&mut out, &mut layers);
|
||||
}
|
||||
let mut before_cells = String::new();
|
||||
layers.finish(&out, &mut annotations, &mut before_cells);
|
||||
// Resolve row offsets before inserting the section headers.
|
||||
if !annotations.is_empty() {
|
||||
annotations.sort_unstable_by_key(|(at, _)| *at);
|
||||
let mut annotated = String::with_capacity(out.len());
|
||||
let mut start = 0;
|
||||
for (at, annotation) in annotations {
|
||||
annotated.push_str(&out[start..at]);
|
||||
annotated.push_str(&annotation);
|
||||
start = at;
|
||||
}
|
||||
annotated.push_str(&out[start..]);
|
||||
out = annotated;
|
||||
self.write_cell_details(
|
||||
&mut body,
|
||||
selected,
|
||||
options.details,
|
||||
(options.ascii_depth.is_some() && outcome.is_complete())
|
||||
.then_some(&mut covered_edges),
|
||||
);
|
||||
}
|
||||
body.write_legend(out);
|
||||
if !selection.modified_cells.is_empty()
|
||||
|| !selection.removed_cells.is_empty()
|
||||
|| !selection.added_cells.is_empty()
|
||||
{
|
||||
before_cells.push_str("Cells:\n");
|
||||
out.write_styled(TextStyle::Heading, format_args!("Cells:"));
|
||||
out.push('\n');
|
||||
for name in selection.removed_cells {
|
||||
writeln!(before_cells, "- {}", cell_label(name)).unwrap();
|
||||
out.write_styled(TextStyle::Removed, format_args!("- {}", cell_label(name)));
|
||||
out.push('\n');
|
||||
}
|
||||
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 [
|
||||
(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" };
|
||||
omissions.push(format!("{count} {label}{plural} {reason}"));
|
||||
}
|
||||
}
|
||||
if !omissions.is_empty() {
|
||||
out.insert_str(
|
||||
notice_start,
|
||||
&format!("Omitted · {}\n", omissions.join(" · ")),
|
||||
);
|
||||
}
|
||||
const COMPACT_HEADLINE_CELL_LIMIT: usize = 3;
|
||||
if !self.cells.is_empty()
|
||||
&& (self.cells.len() > COMPACT_HEADLINE_CELL_LIMIT
|
||||
|| !outcome.is_complete()
|
||||
|| !omissions.is_empty())
|
||||
{
|
||||
let (mut modified, mut added, mut removed) = (0_usize, 0_usize, 0_usize);
|
||||
for cell in &self.cells {
|
||||
match cell_marker(cell.old.is_some(), cell.new.is_some()) {
|
||||
'-' => removed += 1,
|
||||
'+' => added += 1,
|
||||
_ => modified += 1,
|
||||
}
|
||||
}
|
||||
let mut counts = [
|
||||
(modified, "modified"),
|
||||
(added, "added"),
|
||||
(removed, "removed"),
|
||||
]
|
||||
.into_iter()
|
||||
.filter(|(count, _)| *count != 0);
|
||||
if let Some((count, action)) = counts.next() {
|
||||
let noun = if count == 1 { "cell" } else { "cells" };
|
||||
let mut summary = format!(" · {count} {noun} {action}");
|
||||
for (count, action) in counts {
|
||||
write!(summary, ", {count} {action}").unwrap();
|
||||
}
|
||||
out.insert_str(headline_end, &summary);
|
||||
out.write_styled(TextStyle::Added, format_args!("+ {}", cell_label(name)));
|
||||
out.push('\n');
|
||||
}
|
||||
body.write_body(out);
|
||||
}
|
||||
// General comparison errors precede revision-specific errors in text.
|
||||
if !self.diagnostics.is_empty() {
|
||||
out.push_str("Diagnostics\n");
|
||||
out.write_styled(TextStyle::Heading, format_args!("Diagnostics"));
|
||||
out.push('\n');
|
||||
for diagnostic in self
|
||||
.diagnostics
|
||||
.iter()
|
||||
|
|
@ -1810,17 +1764,167 @@ impl Comparison {
|
|||
writeln!(out, " {diagnostic}").unwrap();
|
||||
}
|
||||
}
|
||||
if let Some(max_depth) = ascii_depth {
|
||||
out.push_str(&render_hierarchy(
|
||||
if let Some(max_depth) = options.ascii_depth {
|
||||
write_hierarchy(
|
||||
out,
|
||||
&self.old,
|
||||
&self.new,
|
||||
Some(&self.cells),
|
||||
false,
|
||||
max_depth,
|
||||
Some(&covered_edges),
|
||||
));
|
||||
);
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
fn write_cell_details(
|
||||
&self,
|
||||
out: &mut CellText<'_>,
|
||||
selected: &selection::TextCellSelection<'_>,
|
||||
details: bool,
|
||||
mut covered_edges: Option<&mut BTreeSet<(String, String)>>,
|
||||
) {
|
||||
let cell = selected.cell;
|
||||
let name = cell_label(&cell.name);
|
||||
let note = if selected.attributes_changed {
|
||||
" (attributes changed)"
|
||||
} else {
|
||||
""
|
||||
};
|
||||
out.style(Some(TextStyle::Changed));
|
||||
writeln!(out, "* {name}{note}").unwrap();
|
||||
let mut polygons = changes::PolygonChanges::default();
|
||||
let mut shown_refs = BTreeMap::<&str, changes::ShownReferences>::new();
|
||||
for &(a, b) in &selected.replacements {
|
||||
if !details && a.layer == b.layer && is_polygon(a.kind) {
|
||||
polygons.replacement(a, b);
|
||||
continue;
|
||||
}
|
||||
out.push_str(" ");
|
||||
out.style(Some(TextStyle::Changed));
|
||||
out.push_str("~ ");
|
||||
if a.layer != b.layer {
|
||||
changes::write_layer_transition(out, a, b);
|
||||
out.push('\n');
|
||||
} else {
|
||||
if let Some(layer) = a.layer {
|
||||
out.write_layer(layer, None);
|
||||
out.push_str(": ");
|
||||
}
|
||||
let description = changes::replacement_description(a, b, details);
|
||||
let (heading, rest) = match description.split_once('\n') {
|
||||
Some((heading, rest)) => (heading, Some(rest)),
|
||||
None => (description.as_str(), None),
|
||||
};
|
||||
out.push_str(heading);
|
||||
if let Some(target) = &a.target {
|
||||
let placements = out.reserve_placements();
|
||||
shown_refs
|
||||
.entry(target)
|
||||
.or_default()
|
||||
.replacement(a, b, placements);
|
||||
}
|
||||
out.push('\n');
|
||||
if let Some(rest) = rest {
|
||||
writeln!(out, "{rest}").unwrap();
|
||||
}
|
||||
}
|
||||
if details {
|
||||
changes::write_replacement_objects(out, a, b);
|
||||
}
|
||||
}
|
||||
let mut removed_refs = BTreeMap::new();
|
||||
let mut added_refs = BTreeMap::new();
|
||||
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 &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.
|
||||
for (object, count) in unmatched {
|
||||
out.push_str(" ");
|
||||
out.style(Some(TextStyle::change(sign)));
|
||||
write!(out, "{sign} ").unwrap();
|
||||
if count > 1 {
|
||||
write!(out, "{count}× ").unwrap();
|
||||
}
|
||||
changes::write_unmatched(out, object, details);
|
||||
if let Some(target) = object.target.as_deref() {
|
||||
let placements = out.reserve_placements();
|
||||
shown_refs
|
||||
.entry(target)
|
||||
.or_default()
|
||||
.individual(object, removed, count, placements);
|
||||
}
|
||||
out.push('\n');
|
||||
}
|
||||
}
|
||||
let no_refs = changes::ReferenceCounts::default();
|
||||
for (target, (first, counts)) in removed_refs {
|
||||
if let Some((_, added)) = added_refs.remove(target) {
|
||||
let placements = counts.write_change(out, target, &added);
|
||||
shown_refs
|
||||
.entry(target)
|
||||
.or_default()
|
||||
.unmatched(&counts, &added, placements);
|
||||
} else {
|
||||
let placements = counts.write(out, '-', target, first);
|
||||
shown_refs
|
||||
.entry(target)
|
||||
.or_default()
|
||||
.unmatched(&counts, &no_refs, placements);
|
||||
}
|
||||
}
|
||||
for (target, (first, counts)) in added_refs {
|
||||
let placements = counts.write(out, '+', target, first);
|
||||
shown_refs
|
||||
.entry(target)
|
||||
.or_default()
|
||||
.unmatched(&no_refs, &counts, placements);
|
||||
}
|
||||
if !shown_refs.is_empty() {
|
||||
for target in cell
|
||||
.removed
|
||||
.iter()
|
||||
.chain(&cell.added)
|
||||
.filter_map(|o| o.target.as_deref())
|
||||
{
|
||||
if let Some(shown) = shown_refs.get_mut(target) {
|
||||
shown.count_change();
|
||||
}
|
||||
}
|
||||
for (target, shown) in shown_refs {
|
||||
if shown.complete() {
|
||||
let edge = (cell.name.clone(), target.to_owned());
|
||||
let old = self.old.edges.get(&edge).copied().unwrap_or(0);
|
||||
let new = self.new.edges.get(&edge).copied().unwrap_or(0);
|
||||
shown.write_placements(out, old, new);
|
||||
if let Some(covered) = covered_edges.as_deref_mut() {
|
||||
covered.insert(edge);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
polygons.write(out);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -1885,10 +1989,23 @@ fn render_hierarchy(
|
|||
changes: Option<&[CellChange]>,
|
||||
mermaid: bool,
|
||||
max_depth: usize,
|
||||
covered_edges: Option<&BTreeSet<(String, String)>>,
|
||||
) -> String {
|
||||
let mut out = TextReport::default();
|
||||
write_hierarchy(&mut out, old, new, changes, mermaid, max_depth, None);
|
||||
out.into_string()
|
||||
}
|
||||
|
||||
fn write_hierarchy(
|
||||
out: &mut TextReport,
|
||||
old: &Revision,
|
||||
new: &Revision,
|
||||
changes: Option<&[CellChange]>,
|
||||
mermaid: bool,
|
||||
max_depth: usize,
|
||||
covered_edges: Option<&BTreeSet<(String, String)>>,
|
||||
) {
|
||||
if !mermaid && changes.is_some_and(<[CellChange]>::is_empty) {
|
||||
return String::new();
|
||||
return;
|
||||
}
|
||||
|
||||
let HierarchyAnalysis {
|
||||
|
|
@ -1952,7 +2069,7 @@ fn render_hierarchy(
|
|||
visible.retain(|name| children.contains_key(name) || targets.contains(name));
|
||||
}
|
||||
if changes.is_some() && !mermaid && children.is_empty() {
|
||||
return String::new();
|
||||
return;
|
||||
}
|
||||
let roots: Vec<_> = visible.difference(&targets).cloned().collect();
|
||||
// Distinguish rootless cycles from descendants hidden by the depth limit.
|
||||
|
|
@ -2052,7 +2169,7 @@ fn render_hierarchy(
|
|||
.enumerate()
|
||||
.map(|(i, n)| (n, i))
|
||||
.collect();
|
||||
let mut out = "flowchart TD\n".to_string();
|
||||
out.push_str("flowchart TD\n");
|
||||
if changes.is_none() && new.scope != Scope::default() {
|
||||
writeln!(out, " %% {}", new.scope.description()).unwrap();
|
||||
}
|
||||
|
|
@ -2074,7 +2191,6 @@ fn render_hierarchy(
|
|||
if rows.is_empty() {
|
||||
out.push_str(" empty[\"No changed hierarchy\"]\n");
|
||||
}
|
||||
out
|
||||
} else {
|
||||
let single_placement = |parent: &String, target: &String| {
|
||||
let key = (parent.clone(), target.clone());
|
||||
|
|
@ -2097,9 +2213,10 @@ fn render_hierarchy(
|
|||
&& (old.cells.contains(&child.name) || new.cells.contains(&child.name))
|
||||
&& single_placement(&parent.name, &child.name)
|
||||
};
|
||||
let mut out = "Hierarchy\n".to_string();
|
||||
out.write_styled(TextStyle::Heading, format_args!("Hierarchy"));
|
||||
out.push('\n');
|
||||
if changes.is_none() {
|
||||
new.scope.write_restrictions(&mut out);
|
||||
new.scope.write_restrictions(out);
|
||||
}
|
||||
let mut index = 0;
|
||||
let mut ancestor_depths = Vec::new();
|
||||
|
|
@ -2130,6 +2247,7 @@ fn render_hierarchy(
|
|||
ancestor_depths.pop();
|
||||
}
|
||||
out.push_str(&" ".repeat(ancestor_depths.len()));
|
||||
let mut change = None;
|
||||
for (i, row) in rows[index..=end].iter().enumerate() {
|
||||
let name = &row.name;
|
||||
if i != 0 {
|
||||
|
|
@ -2137,6 +2255,7 @@ fn render_hierarchy(
|
|||
}
|
||||
if direct.contains(name) {
|
||||
let marker = cell_marker(old.cells.contains(name), new.cells.contains(name));
|
||||
change = Some((out.len(), TextStyle::change(marker)));
|
||||
write!(out, "{marker} ").unwrap();
|
||||
}
|
||||
if changes.is_some() {
|
||||
|
|
@ -2151,14 +2270,17 @@ fn render_hierarchy(
|
|||
}
|
||||
}
|
||||
let last = &rows[end];
|
||||
writeln!(out, "{}{}", status(&last.name), last.note).unwrap();
|
||||
write!(out, "{}{}", status(&last.name), last.note).unwrap();
|
||||
if let Some((start, style)) = change {
|
||||
out.mark(start, style);
|
||||
}
|
||||
out.push('\n');
|
||||
ancestor_depths.push(last.depth);
|
||||
index = end + 1;
|
||||
}
|
||||
if visible.is_empty() {
|
||||
out.push_str("No changed hierarchy\n");
|
||||
}
|
||||
out
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
Loading…
Reference in a new issue