181 lines
7.9 KiB
Rust
181 lines
7.9 KiB
Rust
//! `cargo xtask parity`: Fusion Design-workspace command parity.
|
||
//!
|
||
//! `xtask/data/fusion-catalog.tsv` lists the toolbar commands of Fusion's Design workspace as
|
||
//! `tab \t panel \t command id \t command name` (ids and names only, nothing else). It is
|
||
//! derived from the local, uncommitted `plan/fusion/menu-tree.json` with `--refresh`. A catalog
|
||
//! entry is live when SolveCraft registers a command with the same id.
|
||
|
||
use std::path::Path;
|
||
use std::process::Command;
|
||
|
||
use serde_json::Value;
|
||
|
||
/// Design workspace tabs in the catalog (menu-tree tab id, display name).
|
||
const TABS: &[(&str, &str)] = &[
|
||
("SolidTab", "SOLID"),
|
||
("SketchTab", "SKETCH"),
|
||
("SurfaceTab", "SURFACE"),
|
||
("ParaMeshOuterTab", "MESH"),
|
||
("FormTab", "FORM"),
|
||
("SheetMetalTab", "SHEET METAL"),
|
||
("PlasticTab", "PLASTIC"),
|
||
("AssemblyTab", "ASSEMBLY"),
|
||
("ManageTab", "MANAGE"),
|
||
("ToolsTab", "UTILITIES"),
|
||
];
|
||
|
||
/// The tabs the headline number counts (M0 scope).
|
||
const HEADLINE: &[&str] = &["SOLID", "SKETCH"];
|
||
|
||
#[derive(Clone, Debug)]
|
||
pub struct Entry {
|
||
pub tab: String,
|
||
pub panel: String,
|
||
pub id: String,
|
||
pub name: String,
|
||
}
|
||
|
||
fn clean(s: &str) -> String {
|
||
s.replace(['\t', '\n', '\r'], " ").trim().to_string()
|
||
}
|
||
|
||
fn walk(controls: &[Value], defs: &[Value], tab: &str, panel: &str, out: &mut Vec<Entry>) {
|
||
for c in controls {
|
||
match c["type"].as_str() {
|
||
Some("CommandControl") => {
|
||
let id = c["command"]["id"].as_str().or(c["id"].as_str()).unwrap_or("");
|
||
if id.is_empty() {
|
||
continue;
|
||
}
|
||
let name = c["command"]["name"]
|
||
.as_str()
|
||
.filter(|n| !n.is_empty())
|
||
.or_else(|| defs.iter().find(|d| d["id"].as_str() == Some(id)).and_then(|d| d["name"].as_str()))
|
||
.unwrap_or(id);
|
||
if !out.iter().any(|e| e.tab == tab && e.id == id) {
|
||
out.push(Entry { tab: tab.into(), panel: panel.into(), id: clean(id), name: clean(name) });
|
||
}
|
||
}
|
||
Some("DropDownControl") => walk(c["controls"].as_array().map(Vec::as_slice).unwrap_or(&[]), defs, tab, panel, out),
|
||
_ => {}
|
||
}
|
||
}
|
||
}
|
||
|
||
/// Catalog entries from Fusion's menu-tree JSON.
|
||
pub fn from_menu_tree(v: &Value) -> Vec<Entry> {
|
||
let defs = v["commandDefinitions"].as_array().map(Vec::as_slice).unwrap_or(&[]);
|
||
let mut out = Vec::new();
|
||
for (tid, tname) in TABS {
|
||
let tab = &v["tabs"][format!("DesignProductType/{tid}")];
|
||
for p in tab["panels"].as_array().into_iter().flatten() {
|
||
let panel = clean(p["name"].as_str().unwrap_or("")).to_uppercase();
|
||
walk(p["controls"].as_array().map(Vec::as_slice).unwrap_or(&[]), defs, tname, &panel, &mut out);
|
||
}
|
||
}
|
||
out
|
||
}
|
||
|
||
pub fn parse_catalog(s: &str) -> Vec<Entry> {
|
||
s.lines()
|
||
.filter(|l| !l.starts_with('#') && !l.trim().is_empty())
|
||
.filter_map(|l| {
|
||
let mut it = l.split('\t');
|
||
Some(Entry { tab: it.next()?.into(), panel: it.next()?.into(), id: it.next()?.into(), name: it.next().unwrap_or("").into() })
|
||
})
|
||
.collect()
|
||
}
|
||
|
||
pub fn run(root: &Path, refresh: bool) -> Result<(), String> {
|
||
let cat_path = root.join("xtask/data/fusion-catalog.tsv");
|
||
if refresh {
|
||
let mt = root.join("plan/fusion/menu-tree.json");
|
||
let s = std::fs::read_to_string(&mt).map_err(|e| format!("{}: {e}", mt.display()))?;
|
||
let v: Value = serde_json::from_str(&s).map_err(|e| format!("menu-tree.json: {e}"))?;
|
||
let entries = from_menu_tree(&v);
|
||
let mut out = String::from(
|
||
"# Fusion Design workspace toolbar: tab, panel, command id, command name (ids and names only).\n# Regenerate with `cargo xtask parity --refresh` (needs the local plan/fusion/menu-tree.json).\n",
|
||
);
|
||
for e in &entries {
|
||
out += &format!("{}\t{}\t{}\t{}\n", e.tab, e.panel, e.id, e.name);
|
||
}
|
||
std::fs::create_dir_all(root.join("xtask/data")).map_err(|e| e.to_string())?;
|
||
std::fs::write(&cat_path, out).map_err(|e| format!("{}: {e}", cat_path.display()))?;
|
||
println!("parity: catalog refreshed with {} entries", entries.len());
|
||
}
|
||
let catalog = parse_catalog(&std::fs::read_to_string(&cat_path).map_err(|e| format!("{}: {e}", cat_path.display()))?);
|
||
let out = Command::new(std::env::var("CARGO").unwrap_or_else(|_| "cargo".into()))
|
||
.current_dir(root)
|
||
.args(["run", "-q", "--release", "-p", "solvecraft-cli", "--", "commands"])
|
||
.output()
|
||
.map_err(|e| format!("solvecraft-cli: {e}"))?;
|
||
let cmds: Value = serde_json::from_slice(&out.stdout).map_err(|e| format!("commands JSON: {e}"))?;
|
||
let ids: Vec<String> = cmds.as_array().into_iter().flatten().filter_map(|c| c["id"].as_str().map(str::to_string)).collect();
|
||
let live = |e: &Entry| ids.contains(&e.id);
|
||
let pct = |a: usize, b: usize| if b == 0 { 0.0 } else { 100.0 * a as f64 / b as f64 };
|
||
|
||
let head: Vec<&Entry> = catalog.iter().filter(|e| HEADLINE.contains(&e.tab.as_str())).collect();
|
||
let head_live = head.iter().filter(|e| live(e)).count();
|
||
let all_live = catalog.iter().filter(|e| live(e)).count();
|
||
let mut md = format!(
|
||
"# Fusion command parity\n\nGenerated by `cargo xtask parity` from `xtask/data/fusion-catalog.tsv` (the toolbar commands of Fusion's Design workspace, ids and names only) and the live command registry (`solvecraft-cli commands`). A command counts as live when SolveCraft registers the same command id. This measures breadth, not depth; see ROADMAP.md and docs/oracle.md for depth.\n\n**SOLID + SKETCH: {head_live} / {} commands live ({:.0}%).** All Design tabs: {all_live} / {} ({:.0}%). Registered commands: {}.\n\n| Tab | Panel | Live | Total | % |\n|---|---|---:|---:|---:|\n",
|
||
head.len(),
|
||
pct(head_live, head.len()),
|
||
catalog.len(),
|
||
pct(all_live, catalog.len()),
|
||
ids.len()
|
||
);
|
||
let mut groups: Vec<(String, String, usize, usize)> = Vec::new();
|
||
for e in &catalog {
|
||
let l = usize::from(live(e));
|
||
match groups.iter_mut().find(|g| g.0 == e.tab && g.1 == e.panel) {
|
||
Some(g) => {
|
||
g.2 += l;
|
||
g.3 += 1;
|
||
}
|
||
None => groups.push((e.tab.clone(), e.panel.clone(), l, 1)),
|
||
}
|
||
}
|
||
for (t, p, l, n) in &groups {
|
||
md += &format!("| {t} | {p} | {l} | {n} | {:.0}% |\n", pct(*l, *n));
|
||
}
|
||
md += "\n## Live (SOLID, SKETCH)\n\n";
|
||
for e in head.iter().filter(|e| live(e)) {
|
||
md += &format!("- {} › {} › {} (`{}`)\n", e.tab, e.panel, e.name, e.id);
|
||
}
|
||
md += "\n## Not yet (SOLID, SKETCH)\n\n";
|
||
for e in head.iter().filter(|e| !live(e)) {
|
||
md += &format!("- {} › {} › {} (`{}`)\n", e.tab, e.panel, e.name, e.id);
|
||
}
|
||
std::fs::write(root.join("docs/parity.md"), md).map_err(|e| format!("docs/parity.md: {e}"))?;
|
||
println!(
|
||
"parity: SOLID+SKETCH {head_live}/{} ({:.0}%), all tabs {all_live}/{} → docs/parity.md",
|
||
head.len(),
|
||
pct(head_live, head.len()),
|
||
catalog.len()
|
||
);
|
||
Ok(())
|
||
}
|
||
|
||
#[cfg(test)]
|
||
mod tests {
|
||
use super::*;
|
||
|
||
#[test]
|
||
fn catalog_from_menu_tree() {
|
||
let v: Value = serde_json::from_str(
|
||
r#"{"commandDefinitions":[{"id":"B","name":"Bee"}],"tabs":{"DesignProductType/SolidTab":{"panels":[{"name":"Create","controls":[
|
||
{"type":"CommandControl","id":"A","command":{"id":"A","name":"Aye"}},
|
||
{"type":"SeparatorControl","id":"s"},
|
||
{"type":"DropDownControl","id":"d","controls":[{"type":"CommandControl","id":"B","command":{"id":"B"}}]}]}]}}}"#,
|
||
)
|
||
.unwrap();
|
||
let e = from_menu_tree(&v);
|
||
assert_eq!(e.len(), 2);
|
||
assert_eq!((e[0].tab.as_str(), e[0].panel.as_str(), e[0].id.as_str(), e[0].name.as_str()), ("SOLID", "CREATE", "A", "Aye"));
|
||
assert_eq!(e[1].name, "Bee");
|
||
let tsv = "# c\nSOLID\tCREATE\tA\tAye\n";
|
||
assert_eq!(parse_catalog(tsv).len(), 1);
|
||
}
|
||
}
|