Fold unbranched paths in ASCII diffs

This commit is contained in:
Jan Petykiewicz 2026-11-18 23:04:24 -08:00
commit 4ae689cd1c
4 changed files with 208 additions and 33 deletions

View file

@ -137,7 +137,10 @@ reference changes whose placement count stays the same. When the cell list
shows all edits to an unchanged target on a single branch, ASCII can omit shows all edits to an unchanged target on a single branch, ASCII can omit
that terminal edge. The hierarchy retains ancestor paths, shared branches, that terminal edge. The hierarchy retains ancestor paths, shared branches,
and edges with edits hidden by display filters or limits. ASCII appears when and edges with edits hidden by display filters or limits. ASCII appears when
there are relationships to show. Use `--depth` with text output. there are relationships to show. ASCII diffs fold chains of three or more cells
along unchanged single-placement edges, for example `CHIP → block → * leaf`.
Branch points and changed edges keep their own rows. `--depth` counts the
original edges.
For the complete graph within the comparison scope, use For the complete graph within the comparison scope, use
`--format json --hierarchy graph` without `--depth`. Display filters leave the `--format json --hierarchy graph` without `--depth`. Display filters leave the
graph intact. graph intact.

View file

@ -31,6 +31,7 @@ pub(super) fn print(text: &str, report: Report, choice: ColorChoice) -> io::Resu
} }
let mut in_cells = false; let mut in_cells = false;
let mut in_hierarchy = false;
let mut in_mermaid = false; let mut in_mermaid = false;
for line in text.split_inclusive('\n') { for line in text.split_inclusive('\n') {
let body = line.strip_suffix('\n').unwrap_or(line); let body = line.strip_suffix('\n').unwrap_or(line);
@ -48,10 +49,14 @@ pub(super) fn print(text: &str, report: Report, choice: ColorChoice) -> io::Resu
_ => { _ => {
match body { match body {
"Cells:" => in_cells = true, "Cells:" => in_cells = true,
"Hierarchy" | "Diagnostics" => in_cells = false, "Hierarchy" => {
in_cells = false;
in_hierarchy = true;
}
"Diagnostics" => in_cells = false,
_ => (), _ => (),
} }
diff_line(&mut out, body, in_cells)?; diff_line(&mut out, body, in_cells, in_hierarchy)?;
} }
}, },
Report::Dump => dump_line(&mut out, body)?, Report::Dump => dump_line(&mut out, body)?,
@ -75,7 +80,40 @@ fn paint(
result.and(out.reset()) result.and(out.reset())
} }
fn diff_line(out: &mut impl WriteColor, line: &str, in_cells: bool) -> io::Result<()> { fn change_color(marker: &str) -> Option<Color> {
match marker {
"+" => Some(Color::Green),
"-" => Some(Color::Red),
"*" | "~" => Some(Color::Yellow),
_ => None,
}
}
fn folded_endpoint(line: &str) -> Option<(&str, &str)> {
let mut chars = line.char_indices();
let mut quoted = false;
let mut endpoint = None;
while let Some((index, ch)) = chars.next() {
match ch {
'"' => quoted = !quoted,
'\\' if quoted => {
chars.next();
}
'→' if !quoted && line[index..].starts_with("→ ") => {
endpoint = Some(line.split_at(index + "→ ".len()));
}
_ => (),
}
}
endpoint
}
fn diff_line(
out: &mut impl WriteColor,
line: &str,
in_cells: bool,
in_hierarchy: bool,
) -> io::Result<()> {
let content = line.trim_start_matches(' '); let content = line.trim_start_matches(' ');
let indent = &line[..line.len() - content.len()]; let indent = &line[..line.len() - content.len()];
let first = content.split_once(' ').map_or(content, |(word, _)| word); let first = content.split_once(' ').map_or(content, |(word, _)| word);
@ -93,16 +131,19 @@ fn diff_line(out: &mut impl WriteColor, line: &str, in_cells: bool) -> io::Resul
return paint(out, line, color, true); return paint(out, line, color, true);
} }
} }
let color = match first { if let Some(color) = change_color(first) {
"+" => Some(Color::Green),
"-" => Some(Color::Red),
"*" | "~" => Some(Color::Yellow),
_ => None,
};
if let Some(color) = color {
out.write_all(indent.as_bytes())?; out.write_all(indent.as_bytes())?;
return paint(out, content, color, false); return paint(out, content, color, false);
} }
if in_hierarchy
&& line.contains('→')
&& let Some((path, cell)) = folded_endpoint(line)
&& let Some((marker, _)) = cell.split_once(' ')
&& let Some(color) = change_color(marker)
{
out.write_all(path.as_bytes())?;
return paint(out, cell, color, false);
}
if in_cells && indent == " " { if in_cells && indent == " " {
if (layer_token(content).is_some() || content.starts_with("unknown layer: ")) if (layer_token(content).is_some() || content.starts_with("unknown layer: "))
&& let Some((layer, counts)) = content.rsplit_once(": ") && let Some((layer, counts)) = content.rsplit_once(": ")

View file

@ -1890,27 +1890,28 @@ fn render_hierarchy(
}; };
let mut children = BTreeMap::<String, Vec<String>>::new(); let mut children = BTreeMap::<String, Vec<String>>::new();
let mut targets = BTreeSet::new(); let mut targets = BTreeSet::new();
let fold_paths = !mermaid && changes.is_some();
let mut shared = BTreeSet::new();
for (parent, target) in &edges { for (parent, target) in &edges {
if visible.contains(parent) && visible.contains(target) { if visible.contains(parent) && visible.contains(target) {
children children
.entry(parent.clone()) .entry(parent.clone())
.or_default() .or_default()
.push(target.clone()); .push(target.clone());
targets.insert(target.clone()); if !targets.insert(target.clone()) && fold_paths {
shared.insert(target.clone());
}
} }
} }
if let Some(covered) = covered_edges { if let Some(covered) = covered_edges {
if !covered.is_empty() { if !covered.is_empty() {
let mut incoming = BTreeMap::new();
for target in children.values().flatten() {
*incoming.entry(target).or_insert(0_usize) += 1;
}
// Keep changed or shared descendants, branches, and target status notes. // Keep changed or shared descendants, branches, and target status notes.
let redundant: BTreeSet<_> = covered let redundant: BTreeSet<_> = covered
.iter() .iter()
.map(|(_, target)| target) .map(|(_, target)| target)
.filter(|&target| { .filter(|&target| {
incoming.get(target) == Some(&1) targets.contains(target)
&& !shared.contains(target)
&& !children.contains_key(target) && !children.contains_key(target)
&& !affected.contains(target) && !affected.contains(target)
&& old.cells.contains(target) && old.cells.contains(target)
@ -1938,6 +1939,12 @@ fn render_hierarchy(
} }
} }
let mut included = BTreeSet::new(); let mut included = BTreeSet::new();
struct Row {
name: String,
depth: usize,
parent: Option<String>,
note: &'static str,
}
let mut rows = Vec::new(); let mut rows = Vec::new();
let mut stack: Vec<_> = roots let mut stack: Vec<_> = roots
.iter() .iter()
@ -1956,7 +1963,12 @@ fn render_hierarchy(
} else { } else {
"" ""
}; };
rows.push((name.clone(), depth, parent, note)); rows.push(Row {
name: name.clone(),
depth,
parent,
note,
});
if !seen && depth < max_depth { if !seen && depth < max_depth {
for child in descendants.iter().rev() { for child in descendants.iter().rev() {
stack.push((child.clone(), depth + 1, Some(name.clone()))); stack.push((child.clone(), depth + 1, Some(name.clone())));
@ -1964,7 +1976,12 @@ fn render_hierarchy(
} }
} }
for name in visible.difference(&reachable) { for name in visible.difference(&reachable) {
rows.push((name.clone(), 0, None, " [children omitted]")); rows.push(Row {
name: name.clone(),
depth: 0,
parent: None,
note: " [children omitted]",
});
} }
let status = |name: &String| { let status = |name: &String| {
if !old.cells.contains(name) && !new.cells.contains(name) { if !old.cells.contains(name) && !new.cells.contains(name) {
@ -2004,7 +2021,7 @@ fn render_hierarchy(
if mermaid { if mermaid {
let ids: BTreeMap<_, _> = rows let ids: BTreeMap<_, _> = rows
.iter() .iter()
.map(|r| &r.0) .map(|row| &row.name)
.collect::<BTreeSet<_>>() .collect::<BTreeSet<_>>()
.into_iter() .into_iter()
.enumerate() .enumerate()
@ -2034,25 +2051,84 @@ fn render_hierarchy(
} }
out out
} else { } else {
let single_placement = |parent: &String, target: &String| {
let key = (parent.clone(), target.clone());
old_edges.get(&key) == Some(&1)
&& new_edges.get(&key) == Some(&1)
&& !changed_refs.contains(&key)
};
let unbranched = |name: &String| {
!shared.contains(name)
&& children
.get(name)
.is_none_or(|descendants| descendants.len() == 1)
};
let can_join = |parent: &Row, child: &Row| {
child.parent.as_ref() == Some(&parent.name)
&& parent.note.is_empty()
&& !direct.contains(&parent.name)
&& affected.contains(&parent.name)
&& unbranched(&child.name)
&& (old.cells.contains(&child.name) || new.cells.contains(&child.name))
&& single_placement(&parent.name, &child.name)
};
let mut out = "Hierarchy\n".to_string(); let mut out = "Hierarchy\n".to_string();
if changes.is_none() { if changes.is_none() {
new.scope.write_restrictions(&mut out); new.scope.write_restrictions(&mut out);
} }
for (name, depth, parent, note) in rows { let mut index = 0;
out.push_str(&" ".repeat(depth)); let mut ancestor_depths = Vec::new();
if direct.contains(&name) { while let Some(first) = rows.get(index) {
let marker = cell_marker(old.cells.contains(&name), new.cells.contains(&name)); let mut end = index;
if fold_paths
&& unbranched(&first.name)
&& first
.parent
.as_ref()
.is_none_or(|parent| single_placement(parent, &first.name))
{
while rows
.get(end + 1)
.is_some_and(|next| can_join(&rows[end], next))
{
end += 1;
}
// Two rows are already easy to scan.
if end - index < 2 {
end = index;
}
}
while ancestor_depths
.last()
.is_some_and(|&depth| depth >= first.depth)
{
ancestor_depths.pop();
}
out.push_str(&" ".repeat(ancestor_depths.len()));
for (i, row) in rows[index..=end].iter().enumerate() {
let name = &row.name;
if i != 0 {
out.push_str(" → ");
}
if direct.contains(name) {
let marker = cell_marker(old.cells.contains(name), new.cells.contains(name));
write!(out, "{marker} ").unwrap(); write!(out, "{marker} ").unwrap();
} }
if changes.is_some() { if changes.is_some() {
out.push_str(&cell_label(&name)); out.push_str(&cell_label(name));
} else { } else {
write!(out, "{name:?}").unwrap(); write!(out, "{name:?}").unwrap();
} }
if let Some(parent) = parent { if i == 0
write!(out, " {}", edge_label(&parent, &name)).unwrap(); && let Some(parent) = &row.parent
{
write!(out, " {}", edge_label(parent, name)).unwrap();
} }
writeln!(out, "{}{note}", status(&name)).unwrap(); }
let last = &rows[end];
writeln!(out, "{}{}", status(&last.name), last.note).unwrap();
ancestor_depths.push(last.depth);
index = end + 1;
} }
if visible.is_empty() { if visible.is_empty() {
out.push_str("No changed hierarchy\n"); out.push_str("No changed hierarchy\n");

View file

@ -533,6 +533,48 @@ fn shared_hierarchy_reports_ancestors_and_each_leaf_placement_count() {
); );
} }
#[test]
fn ascii_diff_folds_single_placement_paths_up_to_branches_and_changed_edges() {
let with_branch = |count, shape| {
layout(&[
("CHIP", vec![reference("block", 0, 1)]),
("block", vec![reference("routing", 0, 1)]),
("routing", vec![reference("fanout", 0, 1)]),
(
"fanout",
vec![reference("left", 0, 1), reference("right", 0, 1)],
),
("left", vec![reference("target", 0, count)]),
("target", vec![]),
("right", vec![reference("unit", 0, 1)]),
("unit", vec![reference("leaf", 0, 1)]),
("leaf", vec![shape]),
])
};
let old = with_branch(2, square());
let new = with_branch(3, triangle());
let diff = Comparison::between(
&Document::parse(&old).unwrap(),
&Document::parse(&new).unwrap(),
);
assert_eq!(
diff.hierarchy(false, 8),
concat!(
"Hierarchy\n",
"CHIP → block → routing [affected]\n",
" fanout x1 [affected]\n",
" * left x1\n",
" target x2 -> x3\n",
" right x1 → unit → * leaf\n",
)
);
assert_eq!(
diff.hierarchy(false, 2),
"Hierarchy\nCHIP → block → routing [affected] [children omitted]\n"
);
assert!(!diff.hierarchy(true, 8).contains('→'));
}
#[test] #[test]
fn ascii_hierarchy_marks_repeated_subtrees_and_depth_limits() { fn ascii_hierarchy_marks_repeated_subtrees_and_depth_limits() {
let bytes = layout(&[ let bytes = layout(&[
@ -880,7 +922,13 @@ fn cli_color_preserves_plain_output_and_machine_formats() {
.map(|x| reference("leaf", x, 1)) .map(|x| reference("leaf", x, 1))
.chain([shape]) .chain([shape])
.collect(); .collect();
layout(&[("CHIP", objects), ("leaf", vec![]), (name, vec![])]) layout(&[
("top", vec![reference("route", 0, 1)]),
("route", vec![reference("CHIP", 0, 1)]),
("CHIP", objects),
("leaf", vec![]),
(name, vec![]),
])
}; };
fs::write(&old, with_changes("obsolete", square(), 0..2)).unwrap(); fs::write(&old, with_changes("obsolete", square(), 0..2)).unwrap();
fs::write(&new, with_changes("new", triangle(), 10..13)).unwrap(); fs::write(&new, with_changes("new", triangle(), 10..13)).unwrap();
@ -928,6 +976,13 @@ fn cli_color_preserves_plain_output_and_machine_formats() {
diff(&["--color", "always", "--format", "json"]), diff(&["--color", "always", "--format", "json"]),
diff(&["--format", "json"]) diff(&["--format", "json"])
); );
let ascii = diff(&["--hierarchy", "ascii", "--color=always"]);
let folded = ascii
.lines()
.find(|line| line.starts_with("top → route → "))
.unwrap();
assert!(folded.contains("\x1b[33m* CHIP"));
assert_eq!(strip_ansi(&ascii), diff(&["--hierarchy", "ascii"]));
for (options, token) in [ for (options, token) in [
(&[][..], "\x1b[36mcell \"CHIP\""), (&[][..], "\x1b[36mcell \"CHIP\""),