Parameters: unit-aware parameters (an inch parameter reads bare numbers as inches), atan2/mod/trunc and clearer unit errors, cycle paths (a → b → a), rename with every reference following (expressions, feature inputs, dimensions, favourites, comments), deletes refused with the list of users, parameter errors shown on the features using them, parameters.add/rename/delete/comment/users/graph/complete and expr.evaluate; ChangeParameterCommand renames and favourites; hostile test no longer writes stray files
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01AS5Tn3xieewUSg3uxrMVdL
This commit is contained in:
bherbruckandClaude Opus 5.5 committed
1 parent
a88b8eb6b3
commit
dd7485503a
13 files changed
+1470
-322
No files matched your search
@@ -1,4 +1,4 @@
|
||||
//! Undo/redo, parameters, the timeline, deletion and selection.
|
||||
//! Undo/redo, the timeline, deletion and selection.
|
||||
|
||||
use serde_json::{Value, json};
|
||||
use solvecraft_doc::{Feature, FeatureKind};
|
||||
@@ -10,17 +10,6 @@ use crate::{EngineError, Result, Sel, Session, Snapshot};
|
||||
pub static COMMANDS: &[CommandSpec] = &[
|
||||
CommandSpec::new("UndoCommand", "Undo", undo).icon("undo").key("Ctrl+Z").noundo(),
|
||||
CommandSpec::new("RedoCommand", "Redo", redo).icon("redo").key("Ctrl+Y").noundo(),
|
||||
CommandSpec::new("parameters.list", "List Parameters", params_list).noundo().params("favorites?: bool (only favourites)"),
|
||||
CommandSpec::new("parameters.favorite", "Favourite Parameter", params_favorite).params("name, favorite?: bool (default true)"),
|
||||
CommandSpec::new("parameters.export", "Export Parameters", params_export)
|
||||
.noundo()
|
||||
.params("format?: csv|json (default csv), path?: write to a file"),
|
||||
CommandSpec::new("parameters.import", "Import Parameters", params_import)
|
||||
.params("text: CSV (name,unit,expression,comment) or JSON [{name, expression, unit?, comment?}] | path"),
|
||||
CommandSpec::new("ChangeParameterCommand", "Change Parameters", change_param)
|
||||
.at("SOLID", "MODIFY")
|
||||
.icon("params")
|
||||
.params("name, expression (number or text), unit?: mm|deg|\"\", comment?; or delete: name"),
|
||||
CommandSpec::new("FusionComputeAllCommand", "Compute All", compute_all).at("SOLID", "MODIFY").icon("compute").noundo(),
|
||||
CommandSpec::new("FusionDeleteCommand", "Delete", delete)
|
||||
.at("SOLID", "MODIFY")
|
||||
@@ -69,29 +58,6 @@ fn redo(s: &mut Session, _p: &Value) -> Result<Value> {
|
||||
Ok(json!({"redone": label}))
|
||||
}
|
||||
|
||||
fn change_param(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
let cmd = "ChangeParameterCommand";
|
||||
if let Some(n) = str_(p, "delete") {
|
||||
s.doc_mut().remove_param(n)?;
|
||||
return Ok(json!({"deleted": n}));
|
||||
}
|
||||
let name = str_(p, "name").ok_or_else(|| bad(cmd, "`name` is required"))?;
|
||||
let e = match p.get("expression").or_else(|| p.get("value")) {
|
||||
Some(Value::String(x)) => x.clone(),
|
||||
Some(Value::Number(n)) => n.to_string(),
|
||||
_ => return Err(bad(cmd, "`expression` must be a number or text")),
|
||||
};
|
||||
let unit = str_(p, "unit");
|
||||
let comment = str_(p, "comment");
|
||||
s.doc_mut().change_param(name, &e, unit, comment)?;
|
||||
s.refresh();
|
||||
let (vals, _) = s.doc.param_values();
|
||||
let v = vals.get(name).map(|v| v.v);
|
||||
// Report features that now fail.
|
||||
let errors: Vec<Value> = s.model.results.iter().filter_map(|r| r.error.as_ref().map(|e| json!({"feature": r.name, "error": e}))).collect();
|
||||
Ok(json!({"name": name, "expression": e, "value": v, "recomputed": s.model.last_recomputed, "errors": errors}))
|
||||
}
|
||||
|
||||
fn compute_all(s: &mut Session, _p: &Value) -> Result<Value> {
|
||||
s.model = solvecraft_doc::Model::new();
|
||||
s.refresh();
|
||||
@@ -340,57 +306,3 @@ fn dependents(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
let broken: Vec<String> = newly_broken(&s.model, &after).into_iter().map(|(n, _)| n).collect();
|
||||
Ok(json!({"deleted_with_it": names(&gone), "would_fail": broken}))
|
||||
}
|
||||
|
||||
fn params_list(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
let only_fav = bool_(p, "favorites").unwrap_or(false);
|
||||
let rows: Vec<solvecraft_doc::ParamRow> = s.doc.param_rows().into_iter().filter(|r| !only_fav || r.favorite).collect();
|
||||
let cycles = solvecraft_doc::cycles(&s.doc.all_param_exprs());
|
||||
Ok(json!({"parameters": rows, "cycles": cycles}))
|
||||
}
|
||||
|
||||
fn params_favorite(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
let cmd = "parameters.favorite";
|
||||
let name = str_(p, "name").ok_or_else(|| bad(cmd, "`name` is required"))?;
|
||||
let on = bool_(p, "favorite").unwrap_or(true);
|
||||
s.doc_mut().set_favorite(name, on)?;
|
||||
Ok(json!({"name": name, "favorite": on}))
|
||||
}
|
||||
|
||||
fn params_export(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
let cmd = "parameters.export";
|
||||
let text = match str_(p, "format").unwrap_or("csv") {
|
||||
"csv" => s.doc.params_csv(),
|
||||
"json" => {
|
||||
let rows: Vec<Value> = s
|
||||
.doc
|
||||
.param_rows()
|
||||
.into_iter()
|
||||
.filter(|r| r.source == "user")
|
||||
.map(|r| json!({"name": r.name, "expression": r.expression, "unit": r.unit, "value": r.value, "comment": r.comment, "favorite": r.favorite}))
|
||||
.collect();
|
||||
serde_json::to_string_pretty(&rows).map_err(|e| bad(cmd, e.to_string()))?
|
||||
}
|
||||
other => return Err(bad(cmd, format!("unknown format `{other}`"))),
|
||||
};
|
||||
if let Some(path) = str_(p, "path") {
|
||||
std::fs::write(path, &text).map_err(|e| EngineError::Other(format!("{path}: {e}")))?;
|
||||
}
|
||||
Ok(json!({ "text": text }))
|
||||
}
|
||||
|
||||
fn params_import(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
let cmd = "parameters.import";
|
||||
let text = match (str_(p, "text"), str_(p, "path")) {
|
||||
(Some(t), _) => t.to_string(),
|
||||
(None, Some(path)) => {
|
||||
let meta = std::fs::metadata(path).map_err(|e| EngineError::Other(format!("{path}: {e}")))?;
|
||||
if meta.len() > 16 << 20 {
|
||||
return Err(bad(cmd, "file too large"));
|
||||
}
|
||||
std::fs::read_to_string(path).map_err(|e| EngineError::Other(format!("{path}: {e}")))?
|
||||
}
|
||||
_ => return Err(bad(cmd, "give `text` or `path`")),
|
||||
};
|
||||
let names = s.doc_mut().import_params(&text)?;
|
||||
Ok(json!({ "imported": names }))
|
||||
}
|
||||
@@ -11,6 +11,7 @@ mod file;
|
||||
mod inspect;
|
||||
mod measure_sel;
|
||||
pub(crate) use measure_sel::measure_items;
|
||||
mod parameters;
|
||||
mod sketch;
|
||||
mod sketch_constraints;
|
||||
mod sketch_create;
|
||||
@@ -121,6 +122,7 @@ pub fn command_specs() -> Vec<&'static CommandSpec> {
|
||||
v.extend(features::COMMANDS.iter());
|
||||
v.extend(component::COMMANDS.iter());
|
||||
v.extend(edit::COMMANDS.iter());
|
||||
v.extend(parameters::COMMANDS.iter());
|
||||
v.extend(file::COMMANDS.iter());
|
||||
v.extend(inspect::COMMANDS.iter());
|
||||
v
|
||||
|
||||
@@ -0,0 +1,326 @@
|
||||
//! Parameters: Change Parameters (add, edit, rename, delete) and the `parameters.*` commands
|
||||
//! behind the parameters dialog — list, add, rename, favourite, comment, users, dependency
|
||||
//! graph, CSV/JSON import and export, expression evaluation and autocomplete.
|
||||
|
||||
use serde_json::{Value, json};
|
||||
use solvecraft_doc::expr::{self, Kind};
|
||||
|
||||
use super::CommandSpec;
|
||||
use crate::params::{bad, bool_, str_};
|
||||
use crate::{EngineError, Result, Session};
|
||||
|
||||
pub static COMMANDS: &[CommandSpec] = &[
|
||||
CommandSpec::new("ChangeParameterCommand", "Change Parameters", change_param).at("SOLID", "MODIFY").icon("params").params(
|
||||
"name, expression (number or text), unit?: mm|cm|m|in|ft|deg|rad|\"\" (new parameters default to their value's unit), comment?, \
|
||||
favorite?: bool, new_name?: rename (references follow); or delete: name",
|
||||
),
|
||||
CommandSpec::new("parameters.list", "List Parameters", list).noundo().params(
|
||||
"favorites?: bool (only favourites), filter?: all|user|sketch|feature|favorites → parameters (name, expression, unit, value in its unit, \
|
||||
source, feature/input, comment, favorite, uses, used_by, error) and cycles",
|
||||
),
|
||||
CommandSpec::new("parameters.add", "Add User Parameter", add).params("name, expression, unit?, comment?, favorite?: bool"),
|
||||
CommandSpec::new("parameters.rename", "Rename Parameter", rename)
|
||||
.params("name, new_name (expressions, feature inputs and dimensions that use it follow)"),
|
||||
CommandSpec::new("parameters.delete", "Delete Parameter", delete).params("name (refused while something uses it; the error lists the users)"),
|
||||
CommandSpec::new("parameters.favorite", "Favourite Parameter", favorite).params("name, favorite?: bool (default true)"),
|
||||
CommandSpec::new("parameters.comment", "Comment Parameter", comment).params("name, comment"),
|
||||
CommandSpec::new("parameters.users", "Parameter Users", users)
|
||||
.noundo()
|
||||
.params("name → users (parameters, feature inputs, dimensions) and the features it drives"),
|
||||
CommandSpec::new("parameters.graph", "Parameter Graph", graph)
|
||||
.noundo()
|
||||
.params("→ nodes, edges [user, used] (users include Feature:<name>), cycles, errors"),
|
||||
CommandSpec::new("parameters.export", "Export Parameters", export)
|
||||
.noundo()
|
||||
.params("format?: csv|json (default csv, or from the path), path?: write to a file → text"),
|
||||
CommandSpec::new("parameters.import", "Import Parameters", import)
|
||||
.params("text: CSV (header with name, expression, unit?, comment?) or JSON [{name, expression, unit?, comment?}] | path; all or nothing"),
|
||||
CommandSpec::new("expr.evaluate", "Evaluate Expression", evaluate)
|
||||
.noundo()
|
||||
.params("expression, kind?: length|angle|unitless (or unit?: mm|in|deg…) → ok, value (mm/rad), display_value, references, error"),
|
||||
CommandSpec::new("parameters.complete", "Complete Expression", complete)
|
||||
.noundo()
|
||||
.params("prefix?: the text before the cursor → word, suggestions [{text, kind: parameter|function|unit|constant, detail}]"),
|
||||
];
|
||||
|
||||
fn expr_arg(p: &Value, k: &str) -> Option<String> {
|
||||
match p.get(k)? {
|
||||
Value::String(x) => Some(x.clone()),
|
||||
Value::Number(n) => n.as_f64().filter(|v| v.is_finite()).map(|v| format!("{v}")),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
|
||||
fn param_name<'a>(cmd: &str, p: &'a Value) -> Result<&'a str> {
|
||||
str_(p, "name").map(str::trim).filter(|n| !n.is_empty()).ok_or_else(|| bad(cmd, "`name` is required"))
|
||||
}
|
||||
|
||||
/// Features that fail (name and error).
|
||||
fn failing(s: &Session) -> Vec<Value> {
|
||||
s.model.results.iter().filter_map(|r| r.error.as_ref().map(|e| json!({"feature": r.name, "error": e}))).collect()
|
||||
}
|
||||
|
||||
fn known(s: &Session, name: &str) -> bool {
|
||||
s.doc.param(name).is_some() || s.doc.features.iter().any(|f| f.param_names.iter().any(|n| n == name))
|
||||
}
|
||||
|
||||
fn change_param(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
let cmd = "ChangeParameterCommand";
|
||||
if let Some(n) = str_(p, "delete") {
|
||||
s.doc_mut().remove_param(n.trim())?;
|
||||
return Ok(json!({"deleted": n.trim()}));
|
||||
}
|
||||
let mut name = param_name(cmd, p)?.to_string();
|
||||
let mut out = json!({});
|
||||
if let Some(new) = str_(p, "new_name") {
|
||||
let n = s.doc_mut().rename_param(&name, new)?;
|
||||
out["renamed"] = json!({"from": name, "to": new.trim(), "references_updated": n});
|
||||
name = new.trim().to_string();
|
||||
}
|
||||
let has_expr = p.get("expression").is_some() || p.get("value").is_some();
|
||||
let e = if has_expr {
|
||||
Some(expr_arg(p, "expression").or_else(|| expr_arg(p, "value")).ok_or_else(|| bad(cmd, "`expression` must be a number or text"))?)
|
||||
} else if out.get("renamed").is_some() || p.get("favorite").is_some() || p.get("comment").is_some() {
|
||||
None
|
||||
} else {
|
||||
return Err(bad(cmd, "`expression` must be a number or text"));
|
||||
};
|
||||
let (unit, comment) = (str_(p, "unit"), str_(p, "comment"));
|
||||
match &e {
|
||||
Some(e) => s.doc_mut().change_param(&name, e, unit, comment)?,
|
||||
None => {
|
||||
if !known(s, &name) {
|
||||
return Err(bad(cmd, format!("no parameter `{name}`")));
|
||||
}
|
||||
if let Some(c) = comment {
|
||||
s.doc_mut().set_param_comment(&name, c)?;
|
||||
}
|
||||
}
|
||||
}
|
||||
if let Some(f) = bool_(p, "favorite") {
|
||||
s.doc_mut().set_favorite(&name, f)?;
|
||||
}
|
||||
s.refresh();
|
||||
let (vals, _) = s.doc.param_values();
|
||||
out["name"] = json!(name);
|
||||
out["expression"] = json!(e);
|
||||
out["value"] = json!(vals.get(&name).map(|v| v.v));
|
||||
out["display_value"] = json!(s.doc.param_display_value(&vals, &name));
|
||||
out["recomputed"] = json!(s.model.last_recomputed);
|
||||
out["errors"] = json!(failing(s));
|
||||
Ok(out)
|
||||
}
|
||||
|
||||
fn list(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
let filter = match (bool_(p, "favorites"), str_(p, "filter")) {
|
||||
(Some(true), _) => "favorites".to_string(),
|
||||
(_, Some(f)) => f.to_ascii_lowercase(),
|
||||
_ => "all".to_string(),
|
||||
};
|
||||
let mut rows: Vec<solvecraft_doc::ParamRow> = s
|
||||
.doc
|
||||
.param_rows()
|
||||
.into_iter()
|
||||
.filter(|r| match filter.as_str() {
|
||||
"favorites" | "favourites" | "favorite" => r.favorite,
|
||||
"user" | "sketch" | "feature" => r.source == filter,
|
||||
"model" => r.source != "user",
|
||||
_ => true,
|
||||
})
|
||||
.collect();
|
||||
// Favourites first; otherwise the table order (user, sketch, feature).
|
||||
rows.sort_by_key(|r| !r.favorite);
|
||||
let cycles = solvecraft_doc::cycles(&s.doc.all_param_exprs());
|
||||
Ok(json!({"parameters": rows, "count": rows.len(), "cycles": cycles}))
|
||||
}
|
||||
|
||||
fn add(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
let cmd = "parameters.add";
|
||||
let name = param_name(cmd, p)?.to_string();
|
||||
let e = expr_arg(p, "expression").or_else(|| expr_arg(p, "value")).ok_or_else(|| bad(cmd, "`expression` must be a number or text"))?;
|
||||
s.doc_mut().add_user_param(&name, &e, str_(p, "unit"), str_(p, "comment"))?;
|
||||
if let Some(f) = bool_(p, "favorite") {
|
||||
s.doc_mut().set_favorite(&name, f)?;
|
||||
}
|
||||
let (vals, _) = s.doc.param_values();
|
||||
Ok(
|
||||
json!({"name": name, "unit": s.doc.param(&name).map(|x| x.unit.clone()), "value": vals.get(&name).map(|v| v.v), "display_value": s.doc.param_display_value(&vals, &name)}),
|
||||
)
|
||||
}
|
||||
|
||||
fn rename(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
let cmd = "parameters.rename";
|
||||
let name = param_name(cmd, p)?.to_string();
|
||||
let new = str_(p, "new_name").ok_or_else(|| bad(cmd, "`new_name` is required"))?;
|
||||
let n = s.doc_mut().rename_param(&name, new)?;
|
||||
Ok(json!({"from": name, "to": new.trim(), "references_updated": n}))
|
||||
}
|
||||
|
||||
fn delete(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
let name = param_name("parameters.delete", p)?.to_string();
|
||||
s.doc_mut().remove_param(&name)?;
|
||||
Ok(json!({"deleted": name}))
|
||||
}
|
||||
|
||||
fn favorite(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
let name = param_name("parameters.favorite", p)?.to_string();
|
||||
let on = bool_(p, "favorite").unwrap_or(true);
|
||||
s.doc_mut().set_favorite(&name, on)?;
|
||||
Ok(json!({"name": name, "favorite": on}))
|
||||
}
|
||||
|
||||
fn comment(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
let cmd = "parameters.comment";
|
||||
let name = param_name(cmd, p)?.to_string();
|
||||
let c = str_(p, "comment").ok_or_else(|| bad(cmd, "`comment` must be text"))?;
|
||||
s.doc_mut().set_param_comment(&name, c)?;
|
||||
Ok(json!({"name": name, "comment": c}))
|
||||
}
|
||||
|
||||
fn users(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
let cmd = "parameters.users";
|
||||
let name = param_name(cmd, p)?;
|
||||
if !known(s, name) {
|
||||
return Err(bad(cmd, format!("no parameter `{name}`")));
|
||||
}
|
||||
let users = s.doc.param_users(name);
|
||||
let drives: Vec<Value> =
|
||||
s.doc.features_using_param(name).iter().filter_map(|id| s.doc.feature(*id)).map(|f| json!({"id": f.id, "name": f.name})).collect();
|
||||
Ok(json!({"name": name, "users": users, "drives": drives}))
|
||||
}
|
||||
|
||||
fn graph(s: &mut Session, _p: &Value) -> Result<Value> {
|
||||
let (_, errs) = s.doc.param_values();
|
||||
let nodes: Vec<String> = s.doc.param_defs().into_iter().map(|d| d.name).collect();
|
||||
let edges: Vec<[String; 2]> = s.doc.param_graph().into_iter().map(|(a, b)| [a, b]).collect();
|
||||
let cycles = solvecraft_doc::cycles(&s.doc.all_param_exprs());
|
||||
Ok(json!({"nodes": nodes, "edges": edges, "cycles": cycles, "errors": errs}))
|
||||
}
|
||||
|
||||
fn export(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
let cmd = "parameters.export";
|
||||
let path = str_(p, "path");
|
||||
let format = str_(p, "format").map(str::to_ascii_lowercase).unwrap_or_else(|| match path {
|
||||
Some(x) if x.to_ascii_lowercase().ends_with(".json") => "json".into(),
|
||||
_ => "csv".into(),
|
||||
});
|
||||
let text = match format.as_str() {
|
||||
"csv" => s.doc.params_csv(),
|
||||
"json" => {
|
||||
let rows: Vec<Value> = s
|
||||
.doc
|
||||
.param_rows()
|
||||
.into_iter()
|
||||
.filter(|r| r.source == "user")
|
||||
.map(|r| json!({"name": r.name, "expression": r.expression, "unit": r.unit, "value": r.value, "comment": r.comment, "favorite": r.favorite}))
|
||||
.collect();
|
||||
serde_json::to_string_pretty(&rows).map_err(|e| bad(cmd, e.to_string()))?
|
||||
}
|
||||
other => return Err(bad(cmd, format!("unknown format `{other}` (csv or json)"))),
|
||||
};
|
||||
if let Some(path) = path {
|
||||
std::fs::write(path, &text).map_err(|e| EngineError::Other(format!("{path}: {e}")))?;
|
||||
}
|
||||
Ok(json!({"format": format, "path": path, "text": text}))
|
||||
}
|
||||
|
||||
fn import(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
let cmd = "parameters.import";
|
||||
let text = match (str_(p, "text"), str_(p, "path")) {
|
||||
(Some(t), _) => t.to_string(),
|
||||
(None, Some(path)) => {
|
||||
let meta = std::fs::metadata(path).map_err(|e| EngineError::Other(format!("{path}: {e}")))?;
|
||||
if meta.len() > 16 << 20 {
|
||||
return Err(bad(cmd, "file too large"));
|
||||
}
|
||||
std::fs::read_to_string(path).map_err(|e| EngineError::Other(format!("{path}: {e}")))?
|
||||
}
|
||||
_ => return Err(bad(cmd, "give `text` or `path`")),
|
||||
};
|
||||
let names = s.doc_mut().import_params(&text)?;
|
||||
s.refresh();
|
||||
Ok(json!({"imported": names, "errors": failing(s)}))
|
||||
}
|
||||
|
||||
fn evaluate(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
let cmd = "expr.evaluate";
|
||||
let e = expr_arg(p, "expression").ok_or_else(|| bad(cmd, "`expression` must be text or a number"))?;
|
||||
let unit = str_(p, "unit");
|
||||
if let Some(u) = unit
|
||||
&& expr::unit_info(u).is_none()
|
||||
{
|
||||
return Err(bad(cmd, format!("unknown unit `{u}`")));
|
||||
}
|
||||
let kind = match (str_(p, "kind"), unit) {
|
||||
(Some("length"), _) => Some(Kind::Length),
|
||||
(Some("angle"), _) => Some(Kind::Angle),
|
||||
(Some("unitless" | "number"), _) => Some(Kind::Unitless),
|
||||
(Some(other), _) => return Err(bad(cmd, format!("unknown kind `{other}` (length, angle or unitless)"))),
|
||||
(None, Some(u)) => Some(Kind::from_unit(u)),
|
||||
(None, None) => None,
|
||||
};
|
||||
let (vals, _) = s.doc.param_values();
|
||||
let defaults = expr::Defaults::for_unit(unit.unwrap_or(""), 1.0);
|
||||
let refs = expr::references(&e);
|
||||
let lookup = |n: &str| vals.get(n).copied().ok_or_else(|| solvecraft_doc::DocError::Expr(format!("unknown parameter `{n}`")));
|
||||
let r = expr::eval_with_defaults(&e, &lookup, defaults).and_then(|v| match kind {
|
||||
Some(k) => v.to_kind_in(k, defaults).map(|x| (x, k)),
|
||||
None => v.kind().map(|k| (v.v, k)).ok_or_else(|| solvecraft_doc::DocError::Expr(format!("the result is {}", v.describe()))),
|
||||
});
|
||||
Ok(match r {
|
||||
Ok((v, k)) => {
|
||||
let value = match k {
|
||||
Kind::Length => expr::Value::length(v),
|
||||
Kind::Angle => expr::Value::angle(v),
|
||||
Kind::Unitless => expr::Value::num(v),
|
||||
};
|
||||
let shown = match (unit, k) {
|
||||
(Some(u), _) => expr::value_in_unit(value, u),
|
||||
(None, Kind::Angle) => v.to_degrees(),
|
||||
(None, _) => v,
|
||||
};
|
||||
json!({"ok": true, "value": v, "kind": k, "display_value": shown, "references": refs})
|
||||
}
|
||||
Err(err) => json!({"ok": false, "error": err.to_string().trim_start_matches("expression: ").to_string(), "references": refs}),
|
||||
})
|
||||
}
|
||||
|
||||
fn complete(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
let text = str_(p, "prefix").unwrap_or("");
|
||||
// The identifier being typed: trailing letters, digits and underscores.
|
||||
let word: String = text.chars().rev().take_while(|c| c.is_alphanumeric() || *c == '_').collect::<Vec<_>>().into_iter().rev().collect();
|
||||
let starts = |n: &str| word.is_empty() || n.to_ascii_lowercase().starts_with(&word.to_ascii_lowercase());
|
||||
let mut out: Vec<Value> = Vec::new();
|
||||
let mut rows: Vec<solvecraft_doc::ParamRow> = s.doc.param_rows().into_iter().filter(|r| starts(&r.name)).collect();
|
||||
// Favourites, then user parameters, then the rest.
|
||||
rows.sort_by_key(|r| (!r.favorite, r.source != "user"));
|
||||
for r in rows.into_iter().take(200) {
|
||||
let v = r.value.map(|v| format!("{v:.4} {}", r.unit).trim().to_string()).unwrap_or_else(|| "error".into());
|
||||
let mut detail = format!("{} = {v}", r.expression);
|
||||
if let (Some(f), Some(i)) = (&r.feature, r.input) {
|
||||
detail.push_str(&format!(" ({f} {i})"));
|
||||
}
|
||||
if !r.comment.is_empty() {
|
||||
detail.push_str(&format!(" — {}", r.comment));
|
||||
}
|
||||
out.push(json!({"text": r.name, "kind": "parameter", "detail": detail}));
|
||||
}
|
||||
for (f, sig) in expr::FUNCTIONS {
|
||||
if starts(f) {
|
||||
out.push(json!({"text": format!("{f}("), "kind": "function", "detail": sig}));
|
||||
}
|
||||
}
|
||||
if starts("pi") {
|
||||
out.push(json!({"text": "pi", "kind": "constant", "detail": "3.14159…"}));
|
||||
}
|
||||
for (u, k, _) in expr::UNITS {
|
||||
if !word.is_empty() && starts(u) {
|
||||
out.push(json!({"text": u, "kind": "unit", "detail": k}));
|
||||
}
|
||||
}
|
||||
Ok(json!({"word": word, "suggestions": out}))
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
#[path = "parameters_tests.rs"]
|
||||
mod tests;
|
||||
@@ -0,0 +1,226 @@
|
||||
use serde_json::{Value, json};
|
||||
|
||||
use crate::{EngineError, Session};
|
||||
|
||||
fn run(s: &mut Session, id: &str, p: Value) -> Value {
|
||||
match s.execute(id, &p) {
|
||||
Ok(v) => v,
|
||||
Err(e) => panic!("{id} {p}: {e}"),
|
||||
}
|
||||
}
|
||||
|
||||
fn err(s: &mut Session, id: &str, p: Value) -> String {
|
||||
match s.execute(id, &p) {
|
||||
Ok(v) => panic!("{id} {p} should fail, gave {v}"),
|
||||
Err(e) => e.to_string(),
|
||||
}
|
||||
}
|
||||
|
||||
fn volume(s: &mut Session) -> f64 {
|
||||
run(s, "MeasureCommand", json!({}))["total"]["volume_mm3"].as_f64().unwrap_or(f64::NAN)
|
||||
}
|
||||
|
||||
fn rel(a: f64, b: f64) -> f64 {
|
||||
(a - b).abs() / b.abs().max(1e-12)
|
||||
}
|
||||
|
||||
fn row<'a>(list: &'a Value, name: &str) -> &'a Value {
|
||||
list["parameters"].as_array().and_then(|a| a.iter().find(|p| p["name"] == name)).unwrap_or(&Value::Null)
|
||||
}
|
||||
|
||||
fn expr_of(s: &mut Session, name: &str) -> String {
|
||||
let l = run(s, "parameters.list", json!({}));
|
||||
row(&l, name)["expression"].as_str().unwrap_or_default().to_string()
|
||||
}
|
||||
|
||||
/// A sketched block 40 x (len / 2) x 10 whose width is an expression of a user parameter.
|
||||
fn block(s: &mut Session) {
|
||||
run(s, "parameters.add", json!({"name": "len", "expression": "60 mm", "comment": "overall length", "favorite": true}));
|
||||
run(s, "SketchCreate", json!({"plane": "XY", "name": "Base"}));
|
||||
run(s, "ShapeRectangleTwoPoint", json!({"p0": [0, 0], "p1": [40, 30]}));
|
||||
run(s, "ConstraintCoincident", json!({"a": "p1", "b": "origin"}));
|
||||
run(s, "SketchDimension", json!({"entities": ["l1"], "value": 40}));
|
||||
run(s, "SketchDimension", json!({"entities": ["l2"], "value": "len/2"}));
|
||||
run(s, "SketchStop", json!({}));
|
||||
run(s, "Extrude", json!({"distance": 10, "body_name": "Block"}));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn width_follows_an_expression() {
|
||||
let mut s = Session::default();
|
||||
block(&mut s);
|
||||
assert!(rel(volume(&mut s), 40.0 * 30.0 * 10.0) < 1e-9);
|
||||
let r = run(&mut s, "ChangeParameterCommand", json!({"name": "len", "expression": "100 mm"}));
|
||||
assert_eq!(r["errors"].as_array().map(Vec::len), Some(0), "{r}");
|
||||
assert!(rel(volume(&mut s), 40.0 * 50.0 * 10.0) < 1e-9);
|
||||
// Units convert: 4 in = 101.6 mm.
|
||||
run(&mut s, "ChangeParameterCommand", json!({"name": "len", "expression": "4 in"}));
|
||||
assert!(rel(volume(&mut s), 40.0 * 50.8 * 10.0) < 1e-9);
|
||||
// A parameter in inches reads bare numbers as inches.
|
||||
run(&mut s, "ChangeParameterCommand", json!({"name": "len", "expression": "5", "unit": "in"}));
|
||||
assert!(rel(volume(&mut s), 40.0 * 63.5 * 10.0) < 1e-9);
|
||||
let l = run(&mut s, "parameters.list", json!({}));
|
||||
assert_eq!(row(&l, "len")["value"], 5.0, "{l}");
|
||||
assert_eq!(row(&l, "len")["unit"], "in");
|
||||
// A failing parameter fails the features using it, with its error.
|
||||
let e = err(&mut s, "ChangeParameterCommand", json!({"name": "len", "expression": "5 deg"}));
|
||||
assert!(e.contains("expected a length, got an angle"), "{e}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn feature_inputs_are_named_and_editable() {
|
||||
let mut s = Session::default();
|
||||
block(&mut s);
|
||||
let l = run(&mut s, "parameters.list", json!({"filter": "feature"}));
|
||||
let dist = l["parameters"].as_array().unwrap().iter().find(|r| r["input"] == "Distance").unwrap().clone();
|
||||
assert_eq!(dist["feature"], "Extrude1", "{l}");
|
||||
let d = dist["name"].as_str().unwrap().to_string();
|
||||
run(&mut s, "ChangeParameterCommand", json!({"name": d, "expression": "len / 3"}));
|
||||
assert!(rel(volume(&mut s), 40.0 * 30.0 * 20.0) < 1e-9);
|
||||
// Editing the feature keeps its parameter name.
|
||||
run(&mut s, "timeline.edit", json!({"feature": "Extrude1", "set": {"extent": {"distance": "12 mm"}}}));
|
||||
assert!(rel(volume(&mut s), 40.0 * 30.0 * 12.0) < 1e-9);
|
||||
assert_eq!(expr_of(&mut s, &d), "12 mm");
|
||||
// Another feature can use it.
|
||||
run(&mut s, "PrimitiveBox", json!({"length": d, "width": 5, "height": 5, "corner": [100, 0, 0]}));
|
||||
assert!(rel(volume(&mut s), 40.0 * 30.0 * 12.0 + 12.0 * 25.0) < 1e-9);
|
||||
let u = run(&mut s, "parameters.users", json!({"name": d}));
|
||||
assert_eq!(u["users"].as_array().map(Vec::len), Some(1), "{u}");
|
||||
assert_eq!(u["drives"].as_array().map(Vec::len), Some(2), "{u}");
|
||||
// Feature inputs can't be deleted on their own.
|
||||
assert!(err(&mut s, "parameters.delete", json!({"name": d})).contains("feature's input"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn unit_errors_and_cycles_are_refused() {
|
||||
let mut s = Session::default();
|
||||
run(&mut s, "parameters.add", json!({"name": "a", "expression": "10 mm"}));
|
||||
let e = err(&mut s, "parameters.add", json!({"name": "bad", "expression": "a + 5 deg"}));
|
||||
assert!(e.contains("cannot add a length and an angle"), "{e}");
|
||||
let e = err(&mut s, "parameters.add", json!({"name": "ang", "expression": "a", "unit": "deg"}));
|
||||
assert!(e.contains("expected an angle, got a length"), "{e}");
|
||||
assert!(err(&mut s, "parameters.add", json!({"name": "x", "expression": "1", "unit": "furlong"})).contains("unknown unit"));
|
||||
run(&mut s, "parameters.add", json!({"name": "b", "expression": "a * 2"}));
|
||||
let e = err(&mut s, "ChangeParameterCommand", json!({"name": "a", "expression": "b + 1"}));
|
||||
assert!(e.contains("circular reference: a → b → a"), "{e}");
|
||||
assert!(err(&mut s, "parameters.add", json!({"name": "selfref", "expression": "selfref"})).contains("circular"));
|
||||
assert!(err(&mut s, "parameters.add", json!({"name": "a", "expression": "1"})).contains("already"));
|
||||
assert!(err(&mut s, "parameters.add", json!({"name": "sin", "expression": "1"})).contains("function"));
|
||||
assert!(err(&mut s, "parameters.add", json!({"name": "2x", "expression": "1"})).contains("not a valid parameter name"));
|
||||
// Units are inferred for new parameters.
|
||||
run(&mut s, "parameters.add", json!({"name": "tilt", "expression": "30 deg"}));
|
||||
run(&mut s, "parameters.add", json!({"name": "n", "expression": "b / a"}));
|
||||
assert_eq!(s.doc.param("tilt").map(|p| p.unit.as_str()), Some("deg"));
|
||||
assert_eq!(s.doc.param("n").map(|p| p.unit.as_str()), Some(""));
|
||||
let r = run(&mut s, "expr.evaluate", json!({"expression": "atan2(b; a) + tilt", "kind": "angle"}));
|
||||
assert!((r["display_value"].as_f64().unwrap_or(0.0) - (2.0f64.atan().to_degrees() + 30.0)).abs() < 1e-9, "{r}");
|
||||
let r = run(&mut s, "expr.evaluate", json!({"expression": "a + tilt"}));
|
||||
assert_eq!(r["ok"], false);
|
||||
assert!(r["error"].as_str().unwrap_or("").contains("cannot add"), "{r}");
|
||||
let r = run(&mut s, "expr.evaluate", json!({"expression": "2", "unit": "in"}));
|
||||
assert!((r["value"].as_f64().unwrap_or(0.0) - 50.8).abs() < 1e-9, "{r}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn rename_updates_every_reference() {
|
||||
let mut s = Session::default();
|
||||
block(&mut s);
|
||||
run(&mut s, "parameters.add", json!({"name": "twice", "expression": "len * 2"}));
|
||||
let r = run(&mut s, "parameters.rename", json!({"name": "len", "new_name": "length"}));
|
||||
assert_eq!(r["references_updated"], 2, "{r}");
|
||||
assert_eq!(expr_of(&mut s, "twice"), "length * 2");
|
||||
let l = run(&mut s, "parameters.list", json!({"favorites": true}));
|
||||
assert_eq!(l["count"], 1, "the favourite follows the rename");
|
||||
assert_eq!(row(&l, "length")["comment"], "overall length");
|
||||
run(&mut s, "ChangeParameterCommand", json!({"name": "length", "expression": "80"}));
|
||||
assert!(rel(volume(&mut s), 40.0 * 40.0 * 10.0) < 1e-9);
|
||||
// Model and feature parameters can be renamed too: dimensions and features follow.
|
||||
let dim = s.doc.features.first().and_then(|f| match &f.kind {
|
||||
solvecraft_doc::FeatureKind::Sketch { sketch, .. } => sketch.constraints.iter().filter_map(|c| c.param.clone()).next(),
|
||||
_ => None,
|
||||
});
|
||||
let dim = dim.unwrap_or_default();
|
||||
run(&mut s, "ChangeParameterCommand", json!({"name": dim, "new_name": "base_w", "expression": "50"}));
|
||||
assert!(rel(volume(&mut s), 50.0 * 40.0 * 10.0) < 1e-9);
|
||||
let ext = s.doc.features.get(1).and_then(|f| f.param_names.first().cloned()).unwrap_or_default();
|
||||
run(&mut s, "parameters.rename", json!({"name": ext, "new_name": "thick"}));
|
||||
run(&mut s, "ChangeParameterCommand", json!({"name": "thick", "expression": "base_w / 10"}));
|
||||
assert!(rel(volume(&mut s), 50.0 * 40.0 * 5.0) < 1e-9);
|
||||
assert!(err(&mut s, "parameters.rename", json!({"name": "twice", "new_name": "length"})).contains("already"));
|
||||
assert!(err(&mut s, "parameters.rename", json!({"name": "nope", "new_name": "x"})).contains("unknown"));
|
||||
// Undo puts the old name back.
|
||||
run(&mut s, "UndoCommand", json!({}));
|
||||
run(&mut s, "UndoCommand", json!({}));
|
||||
assert!(s.doc.features.get(1).is_some_and(|f| f.param_names.first() == Some(&ext)));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn deleting_a_used_parameter_lists_its_users() {
|
||||
let mut s = Session::default();
|
||||
block(&mut s);
|
||||
run(&mut s, "parameters.add", json!({"name": "spare", "expression": "len + 1"}));
|
||||
let e = err(&mut s, "parameters.delete", json!({"name": "len"}));
|
||||
assert!(e.contains("parameter spare") && e.contains("parameter d"), "{e}");
|
||||
let u = run(&mut s, "parameters.users", json!({"name": "len"}));
|
||||
assert_eq!(u["users"].as_array().map(Vec::len), Some(2), "{u}");
|
||||
assert_eq!(u["drives"][0]["name"], "Base", "{u}");
|
||||
let dim = u["users"].as_array().unwrap().iter().find(|x| x["name"] != "spare").unwrap()["name"].as_str().unwrap().to_string();
|
||||
let e = err(&mut s, "ChangeParameterCommand", json!({"delete": dim}));
|
||||
assert!(e.contains("Base dimension"), "{e}");
|
||||
run(&mut s, "parameters.delete", json!({"name": "spare"}));
|
||||
assert!(s.doc.param("spare").is_none());
|
||||
let g = run(&mut s, "parameters.graph", json!({}));
|
||||
assert!(g["edges"].as_array().unwrap().iter().any(|e| e[0] == dim.as_str() && e[1] == "len"), "{g}");
|
||||
assert!(g["edges"].as_array().unwrap().iter().any(|e| e[0] == "Feature:Base" && e[1] == dim.as_str()), "{g}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn favorites_comments_and_completion() {
|
||||
let mut s = Session::default();
|
||||
block(&mut s);
|
||||
run(&mut s, "parameters.favorite", json!({"name": "len", "favorite": false}));
|
||||
assert_eq!(run(&mut s, "parameters.list", json!({"favorites": true}))["count"], 0);
|
||||
let ext = s.doc.features.get(1).and_then(|f| f.param_names.first().cloned()).unwrap_or_default();
|
||||
run(&mut s, "parameters.comment", json!({"name": ext, "comment": "plate thickness"}));
|
||||
let l = run(&mut s, "parameters.list", json!({}));
|
||||
assert_eq!(row(&l, &ext)["comment"], "plate thickness");
|
||||
let c = run(&mut s, "parameters.complete", json!({"prefix": "2 * le"}));
|
||||
assert_eq!(c["word"], "le");
|
||||
assert_eq!(c["suggestions"][0]["text"], "len", "{c}");
|
||||
let c = run(&mut s, "parameters.complete", json!({"prefix": "at"}));
|
||||
assert!(c["suggestions"].as_array().unwrap().iter().any(|x| x["text"] == "atan2("), "{c}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn csv_and_json_round_trip() {
|
||||
let mut s = Session::default();
|
||||
block(&mut s);
|
||||
run(&mut s, "parameters.add", json!({"name": "note", "expression": "len / 4", "comment": "has, a \"comma\""}));
|
||||
let csv = run(&mut s, "parameters.export", json!({"format": "csv"}))["text"].as_str().unwrap_or_default().to_string();
|
||||
assert!(csv.contains("note,mm,len / 4,15,\"has, a \"\"comma\"\"\",false"), "{csv}");
|
||||
let json_text = run(&mut s, "parameters.export", json!({"format": "json"}))["text"].as_str().unwrap_or_default().to_string();
|
||||
|
||||
let mut t = Session::default();
|
||||
run(&mut t, "parameters.import", json!({"text": csv}));
|
||||
assert_eq!(t.doc.param("note").map(|p| p.comment.as_str()), Some("has, a \"comma\""));
|
||||
let mut u = Session::default();
|
||||
run(&mut u, "parameters.import", json!({"text": json_text}));
|
||||
assert_eq!(u.doc.param("note").map(|p| p.expr.as_str()), Some("len / 4"));
|
||||
|
||||
// Importing into the design updates values and rebuilds; all or nothing.
|
||||
run(&mut s, "parameters.import", json!({"text": "name,expression\nlen,80 mm\nextra,3\n"}));
|
||||
assert!(rel(volume(&mut s), 40.0 * 40.0 * 10.0) < 1e-9);
|
||||
assert!(s.execute("parameters.import", &json!({"text": "name,expression\nlen,90 mm\nbroken,len + 1 deg\n"})).is_err());
|
||||
assert_eq!(s.doc.param("len").map(|p| p.expr.as_str()), Some("80 mm"));
|
||||
assert!(matches!(s.execute("parameters.import", &json!({})), Err(EngineError::BadParams { .. })));
|
||||
|
||||
let dir = std::env::temp_dir().join(format!("solvecraft-params-{}", std::process::id()));
|
||||
let _ = std::fs::create_dir_all(&dir);
|
||||
let path = dir.join("p.json");
|
||||
let r = run(&mut s, "parameters.export", json!({"path": path.to_string_lossy()}));
|
||||
assert_eq!(r["format"], "json");
|
||||
let mut v = Session::default();
|
||||
run(&mut v, "parameters.import", json!({"path": path.to_string_lossy()}));
|
||||
assert_eq!(v.doc.param("len").map(|p| p.expr.as_str()), Some("80 mm"));
|
||||
let _ = std::fs::remove_dir_all(&dir);
|
||||
}
|
||||
Reference in new issue
Block a user