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
3 changed files with 209 additions and 35 deletions
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)
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in a new issue