Accept embedded layer names in CLI selectors
Resolve scope and display selectors against both revisions before projection. Keep display-only selection on the large-file comparison path and list numeric choices for ambiguous names.
This commit is contained in:
parent
4ae689cd1c
commit
87683db7e8
5 changed files with 209 additions and 35 deletions
|
|
@ -103,7 +103,7 @@ pheon diff before.gds after.gds --cell RESONATOR
|
|||
| --- | --- |
|
||||
| `--top NAME` | The named cell and its reachable descendants in each revision. |
|
||||
| `--cell NAME` | One cell, including its references, without its descendants. |
|
||||
| `--layer L/T` | Objects on a numeric layer/type pair, plus references leading to that layer. |
|
||||
| `--layer L/T\|NAME` | Objects on the selected layer/type pair, plus references leading to that layer. |
|
||||
|
||||
Selectors combine: `--top CHIP --cell RESONATOR` selects that cell within CHIP's
|
||||
subtree. A name absent from both revisions is an error; presence on only one
|
||||
|
|
@ -112,10 +112,14 @@ layer, but library fields and metadata-version diagnostics remain relevant.
|
|||
The complete input is parsed before scope selection, so malformed records
|
||||
outside the scope still fail the command.
|
||||
|
||||
Both `--layer` and `--show-layer` accept exact, case-sensitive names from the
|
||||
embedded metadata in either revision. If a name refers to several numeric pairs,
|
||||
Pheon lists the choices. A valid numeric pair always selects that pair directly.
|
||||
|
||||
## Control report detail
|
||||
|
||||
```sh
|
||||
pheon diff before.gds after.gds --show-cell RESONATOR --show-layer 1/0
|
||||
pheon diff before.gds after.gds --show-cell RESONATOR --show-layer WG
|
||||
pheon diff before.gds after.gds --hierarchy mermaid --depth 4
|
||||
```
|
||||
|
||||
|
|
|
|||
128
src/bin/pheon.rs
128
src/bin/pheon.rs
|
|
@ -4,8 +4,9 @@ mod color;
|
|||
use flate2::read::MultiGzDecoder;
|
||||
use pheon::review::report::{ReportInputs, ReportOptions, failure_report};
|
||||
use pheon::review::{
|
||||
Comparison, Diagnostic, Document, Outcome, RevisionPair, Side, TextComparison, dump_records,
|
||||
names::{parse_layer, parse_layer_name, write_layer_names},
|
||||
Comparison, Diagnostic, Document, Layer, Outcome, RevisionPair, Side, TextComparison,
|
||||
dump_records,
|
||||
names::{parse_layer, parse_layer_name, resolve_layer_name, write_layer_names},
|
||||
selection::{DisplayFilter, Scope},
|
||||
};
|
||||
use std::{
|
||||
|
|
@ -21,7 +22,7 @@ use termcolor::ColorChoice;
|
|||
|
||||
const HELP: &str = "Usage:
|
||||
pheon dump FILE [--records] [--color auto|always|never]
|
||||
pheon diff OLD NEW [--top NAME] [--cell NAME] [--layer L/T]\n [--show-cell NAME] [--show-layer L/T] [--hierarchy ascii|mermaid|none|graph]\n [--max-changes N] [--depth N] [--format text|json]
|
||||
pheon diff OLD NEW [--top NAME] [--cell NAME] [--layer L/T|NAME]\n [--show-cell NAME] [--show-layer L/T|NAME] [--hierarchy ascii|mermaid|none|graph]\n [--max-changes N] [--depth N] [--format text|json]
|
||||
[--color auto|always|never]
|
||||
pheon hierarchy FILE [--format ascii|mermaid] [--depth N] [--top NAME]\n pheon git-diff [OPTIONS] -- PATH OLD OLD_OID OLD_MODE NEW NEW_OID NEW_MODE
|
||||
pheon name-layers INPUT OUTPUT --cell NAME --carrier L/T --name L:T:NAME ...
|
||||
|
|
@ -145,10 +146,55 @@ fn parse_revision(bytes: Option<&[u8]>, side: Side) -> Result<Option<Document<'_
|
|||
.transpose()
|
||||
}
|
||||
|
||||
#[derive(Default)]
|
||||
struct Selectors {
|
||||
scope: Scope,
|
||||
filter: DisplayFilter,
|
||||
layer_name: Option<String>,
|
||||
show_layer_name: Option<String>,
|
||||
}
|
||||
|
||||
fn layer_argument(value: String) -> (Option<Layer>, Option<String>) {
|
||||
match parse_layer(&value) {
|
||||
Ok(pair) => (Some(pair), None),
|
||||
Err(_) => (None, Some(value)),
|
||||
}
|
||||
}
|
||||
|
||||
impl Selectors {
|
||||
fn resolve_layers(
|
||||
&mut self,
|
||||
resolve: impl Fn(&str) -> Result<Layer, String>,
|
||||
) -> Result<(), Diagnostic> {
|
||||
for (flag, code, name, pair) in [
|
||||
(
|
||||
"--layer",
|
||||
"invalid_scope",
|
||||
&self.layer_name,
|
||||
&mut self.scope.layer,
|
||||
),
|
||||
(
|
||||
"--show-layer",
|
||||
"command_error",
|
||||
&self.show_layer_name,
|
||||
&mut self.filter.layer,
|
||||
),
|
||||
] {
|
||||
if let Some(name) = name {
|
||||
*pair = Some(
|
||||
resolve(name)
|
||||
.map_err(|error| Diagnostic::new(code, format!("{flag} {error}"), None))?,
|
||||
);
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
fn prepare_comparison<T>(
|
||||
old_path: Option<&OsStr>,
|
||||
new_path: Option<&OsStr>,
|
||||
scope: &Scope,
|
||||
selectors: &mut Selectors,
|
||||
compare: impl FnOnce(&Document<'_>, &Document<'_>) -> T,
|
||||
compare_pair: impl FnOnce(RevisionPair<'_>) -> T,
|
||||
) -> Result<T, Diagnostic> {
|
||||
|
|
@ -168,10 +214,13 @@ fn prepare_comparison<T>(
|
|||
.as_deref()
|
||||
.zip(new_bytes.as_deref())
|
||||
.filter(|(old, new)| old.len().min(new.len()) >= PARALLEL_PARSE_MIN_BYTES);
|
||||
if scope == &Scope::default()
|
||||
if selectors.scope == Scope::default()
|
||||
&& selectors.layer_name.is_none()
|
||||
&& let Some((old, new)) = large_pair
|
||||
{
|
||||
return RevisionPair::parse(old, new).map(compare_pair);
|
||||
let pair = RevisionPair::parse(old, new)?;
|
||||
selectors.resolve_layers(|name| pair.resolve_layer_name(name))?;
|
||||
return Ok(compare_pair(pair));
|
||||
}
|
||||
let parse_old = || parse_revision(old_bytes.as_deref(), Side::Old);
|
||||
let parse_new = || parse_revision(new_bytes.as_deref(), Side::New);
|
||||
|
|
@ -206,6 +255,9 @@ fn prepare_comparison<T>(
|
|||
));
|
||||
}
|
||||
};
|
||||
selectors
|
||||
.resolve_layers(|name| resolve_layer_name(name, [&old.layer_names, &new.layer_names]))?;
|
||||
let scope = &selectors.scope;
|
||||
if scope == &Scope::default() {
|
||||
return Ok(compare(&old, &new));
|
||||
}
|
||||
|
|
@ -221,24 +273,35 @@ fn prepare_comparison<T>(
|
|||
Ok(compare(&old, &new))
|
||||
}
|
||||
|
||||
fn json_diff(paths: &[OsString], scope: &Scope, options: &ReportOptions) -> Result<u8, String> {
|
||||
fn json_diff(
|
||||
paths: &[OsString],
|
||||
selectors: &mut Selectors,
|
||||
max_objects: Option<usize>,
|
||||
hierarchy: bool,
|
||||
) -> Result<u8, String> {
|
||||
let inputs = ReportInputs {
|
||||
old: Some(PathBuf::from(&paths[0])),
|
||||
new: Some(PathBuf::from(&paths[1])),
|
||||
};
|
||||
let (result, outcome) = match prepare_comparison(
|
||||
let comparison = prepare_comparison(
|
||||
Some(&paths[0]),
|
||||
Some(&paths[1]),
|
||||
scope,
|
||||
selectors,
|
||||
Comparison::between,
|
||||
|pair| pair.compare(),
|
||||
) {
|
||||
);
|
||||
let options = ReportOptions {
|
||||
filter: selectors.filter.clone(),
|
||||
max_objects,
|
||||
hierarchy,
|
||||
};
|
||||
let (result, outcome) = match comparison {
|
||||
Ok(diff) => (
|
||||
json_stdout(|output| diff.write_json_report(output, &inputs, options)),
|
||||
json_stdout(|output| diff.write_json_report(output, &inputs, &options)),
|
||||
diff.outcome(),
|
||||
),
|
||||
Err(error) => {
|
||||
let report = failure_report(&inputs, scope, options, &error);
|
||||
let report = failure_report(&inputs, &selectors.scope, &options, &error);
|
||||
(
|
||||
json_stdout(|output| serde_json::to_writer_pretty(output, &report)),
|
||||
Outcome::Failed,
|
||||
|
|
@ -275,8 +338,7 @@ fn run(args: &[OsString]) -> Result<u8, String> {
|
|||
let compare = command == "diff" || command == "git-diff";
|
||||
let color_supported = compare || command == "dump";
|
||||
let mut color_choice = ColorChoice::Auto;
|
||||
let mut scope = Scope::default();
|
||||
let mut show = DisplayFilter::default();
|
||||
let mut selectors = Selectors::default();
|
||||
let mut raw = false;
|
||||
let mut format = if compare {
|
||||
"none".to_string()
|
||||
|
|
@ -310,12 +372,16 @@ fn run(args: &[OsString]) -> Result<u8, String> {
|
|||
Some(s) if color_supported && s.starts_with("--color=") => {
|
||||
color_choice = color::parse_choice(&s["--color=".len()..])?;
|
||||
}
|
||||
Some("--top") => scope.top = Some(value(args, &mut i)?),
|
||||
Some("--cell") => scope.cell = Some(value(args, &mut i)?),
|
||||
Some("--layer") => scope.layer = Some(parse_layer(&value(args, &mut i)?)?),
|
||||
Some("--show-cell") if compare => show.cell = Some(value(args, &mut i)?),
|
||||
Some("--top") => selectors.scope.top = Some(value(args, &mut i)?),
|
||||
Some("--cell") => selectors.scope.cell = Some(value(args, &mut i)?),
|
||||
Some("--layer") => {
|
||||
(selectors.scope.layer, selectors.layer_name) =
|
||||
layer_argument(value(args, &mut i)?);
|
||||
}
|
||||
Some("--show-cell") if compare => selectors.filter.cell = Some(value(args, &mut i)?),
|
||||
Some("--show-layer") if compare => {
|
||||
show.layer = Some(parse_layer(&value(args, &mut i)?)?)
|
||||
(selectors.filter.layer, selectors.show_layer_name) =
|
||||
layer_argument(value(args, &mut i)?);
|
||||
}
|
||||
Some("--hierarchy") if compare => format = value(args, &mut i)?,
|
||||
Some("--format") if command == "hierarchy" => format = value(args, &mut i)?,
|
||||
|
|
@ -347,15 +413,7 @@ fn run(args: &[OsString]) -> Result<u8, String> {
|
|||
"JSON accepts --hierarchy graph|none; --depth applies to text output".to_string(),
|
||||
);
|
||||
}
|
||||
return json_diff(
|
||||
&paths,
|
||||
&scope,
|
||||
&ReportOptions {
|
||||
filter: show,
|
||||
max_objects: explicit_max,
|
||||
hierarchy: format == "graph",
|
||||
},
|
||||
);
|
||||
return json_diff(&paths, &mut selectors, explicit_max, format == "graph");
|
||||
}
|
||||
if !matches!(format.as_str(), "ascii" | "mermaid" | "none")
|
||||
|| (command == "hierarchy" && format == "none")
|
||||
|
|
@ -364,7 +422,7 @@ fn run(args: &[OsString]) -> Result<u8, String> {
|
|||
}
|
||||
let read = |path: &OsString| read_input(path).map_err(|error| error.message);
|
||||
if raw {
|
||||
if scope != Scope::default() {
|
||||
if selectors.scope != Scope::default() || selectors.layer_name.is_some() {
|
||||
return Err("record dumps do not accept object scope selectors".to_string());
|
||||
}
|
||||
color::print(
|
||||
|
|
@ -377,7 +435,11 @@ fn run(args: &[OsString]) -> Result<u8, String> {
|
|||
}
|
||||
if !compare {
|
||||
let bytes = read(&paths[0])?;
|
||||
let doc = Document::parse(&bytes)?.selected(&scope, false)?;
|
||||
let doc = Document::parse(&bytes)?;
|
||||
selectors
|
||||
.resolve_layers(|name| resolve_layer_name(name, [&doc.layer_names]))
|
||||
.map_err(|error| error.message)?;
|
||||
let doc = doc.selected(&selectors.scope, false)?;
|
||||
if command == "dump" {
|
||||
color::print(&doc.canonical_dump(), color::Report::Dump, color_choice)
|
||||
.map_err(|error| error.to_string())?;
|
||||
|
|
@ -395,7 +457,7 @@ fn run(args: &[OsString]) -> Result<u8, String> {
|
|||
let diff = prepare_comparison(
|
||||
(!old_missing).then_some(paths[if git { 1 } else { 0 }].as_os_str()),
|
||||
(!new_missing).then_some(paths[if git { 4 } else { 1 }].as_os_str()),
|
||||
&scope,
|
||||
&mut selectors,
|
||||
TextComparison::between,
|
||||
|pair| pair.compare_text(),
|
||||
)
|
||||
|
|
@ -423,12 +485,12 @@ fn run(args: &[OsString]) -> Result<u8, String> {
|
|||
if format == "ascii" {
|
||||
output.push_str(&diff.render_text_with_ascii_hierarchy(
|
||||
max_changes,
|
||||
&show,
|
||||
&selectors.filter,
|
||||
show_library_presence,
|
||||
depth,
|
||||
));
|
||||
} else {
|
||||
output.push_str(&diff.render_text(max_changes, &show, show_library_presence));
|
||||
output.push_str(&diff.render_text(max_changes, &selectors.filter, show_library_presence));
|
||||
if format == "mermaid" {
|
||||
output.push_str("Hierarchy\n```mermaid\n");
|
||||
output.push_str(&diff.hierarchy(true, depth));
|
||||
|
|
|
|||
|
|
@ -68,6 +68,30 @@ pub fn parse_layer(value: &str) -> Result<Layer, String> {
|
|||
Ok((decimal(a)?, decimal(b)?))
|
||||
}
|
||||
|
||||
/// Find the unique numeric pair for an exact name across the supplied revisions.
|
||||
pub fn resolve_layer_name<'a>(
|
||||
name: &str,
|
||||
revisions: impl IntoIterator<Item = &'a BTreeMap<Layer, String>>,
|
||||
) -> Result<Layer, String> {
|
||||
let matches: BTreeSet<_> = revisions
|
||||
.into_iter()
|
||||
.flatten()
|
||||
.filter_map(|(&pair, label)| (label == name).then_some(pair))
|
||||
.collect();
|
||||
match matches.len() {
|
||||
0 => Err(format!("unknown layer name {name:?}")),
|
||||
1 => Ok(*matches.first().unwrap()),
|
||||
_ => {
|
||||
let choices = matches
|
||||
.into_iter()
|
||||
.map(|(layer, datatype)| format!("{layer}/{datatype}"))
|
||||
.collect::<Vec<_>>()
|
||||
.join(", ");
|
||||
Err(format!("ambiguous layer name {name:?} (choose {choices})"))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn decimal(value: &str) -> Result<u16, String> {
|
||||
if value.is_empty() || !value.bytes().all(|b| b.is_ascii_digit()) {
|
||||
return Err("layer numbers must be unsigned decimal integers".to_string());
|
||||
|
|
|
|||
|
|
@ -184,6 +184,11 @@ impl<'a> RevisionPair<'a> {
|
|||
Comparison::collect(&self.old, &self.new, &self.reused_cells, true)
|
||||
}
|
||||
|
||||
/// Resolve a layer name from the embedded metadata in either revision.
|
||||
pub fn resolve_layer_name(&self, name: &str) -> Result<Layer, String> {
|
||||
names::resolve_layer_name(name, [&self.old.layer_names, &self.new.layer_names])
|
||||
}
|
||||
|
||||
pub fn compare_text(self) -> TextComparison {
|
||||
TextComparison::collect(&self.old, &self.new, &self.reused_cells)
|
||||
}
|
||||
|
|
|
|||
|
|
@ -2164,6 +2164,85 @@ fn cli_scope_and_display_filters_have_distinct_exit_behavior() {
|
|||
fs::remove_dir_all(directory).unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn cli_resolves_layer_names_before_applying_scope_and_display_filters() {
|
||||
let directory = std::env::temp_dir().join(format!("pheon-named-layer-{}", std::process::id()));
|
||||
fs::create_dir_all(&directory).unwrap();
|
||||
struct Cleanup(PathBuf);
|
||||
impl Drop for Cleanup {
|
||||
fn drop(&mut self) {
|
||||
let _ = fs::remove_dir_all(&self.0);
|
||||
}
|
||||
}
|
||||
let _cleanup = Cleanup(directory.clone());
|
||||
let old = directory.join("old.gds");
|
||||
let new = directory.join("new.gds");
|
||||
let fixture = |shape, text, name| {
|
||||
layout(&[
|
||||
("CHIP", vec![shape, label((2, 0), text)]),
|
||||
(
|
||||
"legend",
|
||||
vec![label((900, 7), LAYER_SENTINEL), label((900, 7), name)],
|
||||
),
|
||||
])
|
||||
};
|
||||
fs::write(&old, fixture(square(), "before", "1:0:WG")).unwrap();
|
||||
fs::write(&new, fixture(triangle(), "after", "1:0:CORE")).unwrap();
|
||||
let command = || Command::new(env!("CARGO_BIN_EXE_pheon"));
|
||||
let diff = |options: &[&str]| {
|
||||
command()
|
||||
.arg("diff")
|
||||
.arg(&old)
|
||||
.arg(&new)
|
||||
.args(options)
|
||||
.output()
|
||||
.unwrap()
|
||||
};
|
||||
for (option, name) in [("--layer", "WG"), ("--show-layer", "CORE")] {
|
||||
for format in ["text", "json"] {
|
||||
let named = diff(&[option, name, "--cell", "CHIP", "--format", format]);
|
||||
let numeric = diff(&[option, "1/0", "--cell", "CHIP", "--format", format]);
|
||||
assert_eq!(
|
||||
named.status.code(),
|
||||
Some(1),
|
||||
"{}",
|
||||
String::from_utf8_lossy(&named.stderr)
|
||||
);
|
||||
assert_eq!(named.stdout, numeric.stdout);
|
||||
}
|
||||
}
|
||||
|
||||
let dump = |layer| {
|
||||
let output = command()
|
||||
.arg("dump")
|
||||
.arg(&old)
|
||||
.args(["--layer", layer])
|
||||
.output()
|
||||
.unwrap();
|
||||
assert!(output.status.success());
|
||||
output.stdout
|
||||
};
|
||||
assert_eq!(dump("WG"), dump("1/0"));
|
||||
|
||||
let unknown = diff(&["--show-layer", "wg", "--format", "json"]);
|
||||
assert_eq!(unknown.status.code(), Some(2));
|
||||
let report: serde_json::Value = serde_json::from_slice(&unknown.stdout).unwrap();
|
||||
assert_eq!(report["diagnostics"][0]["code"], "command_error");
|
||||
assert_eq!(
|
||||
report["diagnostics"][0]["message"],
|
||||
"--show-layer unknown layer name \"wg\""
|
||||
);
|
||||
|
||||
fs::write(&new, fixture(triangle(), "after", "2:0:WG")).unwrap();
|
||||
let ambiguous = diff(&["--layer", "WG"]);
|
||||
assert_eq!(ambiguous.status.code(), Some(2));
|
||||
assert_eq!(
|
||||
String::from_utf8(ambiguous.stderr).unwrap().trim_end(),
|
||||
"pheon: --layer ambiguous layer name \"WG\" (choose 1/0, 2/0)"
|
||||
);
|
||||
assert_eq!(diff(&["--layer", "1/0"]).status.code(), Some(1));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn large_polygons_and_billion_instance_arrays_stay_compact() {
|
||||
let mut points = vec![[0, 0], [0, 1]];
|
||||
|
|
|
|||
Loading…
Reference in a new issue