SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
parameters: import evaluates once; parameters.change takes several names (#2777)
NOWN-DEV3d105fb281f7
diff --git a/crates/doc/src/expr.rs b/crates/doc/src/expr.rsindex 1ccb440181..25c9f89f91 100644--- a/crates/doc/src/expr.rs+++ b/crates/doc/src/expr.rs@@ -897,10 +897,6 @@ pub fn eval_params(params: &[ParamDef], doc_len: f64) -> (BTreeMap<String, Valueif cx.stack.len() > 512 {return Err(DocError::Expr("parameters nested too deeply".into()));}- let Some((kind, _)) = unit_info(&p.unit).or(Some((Kind::Length, 1.0))) else {- return Err(DocError::Expr(format!("unknown unit `{}`", p.unit)));- };- let defaults = Defaults::for_unit(&p.unit, cx.doc_len);cx.stack.push(name.to_string());let mut vals: BTreeMap<String, Value> = BTreeMap::new();let mut err = None;@@ -918,17 +914,7 @@ pub fn eval_params(params: &[ParamDef], doc_len: f64) -> (BTreeMap<String, Valuecx.stack.pop();let r = match err {Some(e) => Err(e),- None => {- eval_with_defaults(&p.expr, &|n| vals.get(n).copied().ok_or_else(|| DocError::Expr(format!("unknown parameter `{n}`"))), defaults)- .and_then(|v| {- let x = v.to_kind_in(kind, defaults)?;- Ok(match kind {- Kind::Length => Value::length(x),- Kind::Angle => Value::angle(x),- Kind::Unitless => Value::num(x),- })- })- }+ None => eval_def(p, &|n| vals.get(n).copied().ok_or_else(|| DocError::Expr(format!("unknown parameter `{n}`"))), cx.doc_len),};match &r {Ok(v) => {@@ -949,6 +935,19 @@ pub fn eval_params(params: &[ParamDef], doc_len: f64) -> (BTreeMap<String, Value(cx.done, cx.errors)}+/// One parameter's value: its expression in its unit, with the values of the parameters it+/// refers to from `lookup`.+pub fn eval_def(p: &ParamDef, lookup: &dyn Fn(&str) -> Result<Value, DocError>, doc_len: f64) -> Result<Value, DocError> {+ let (kind, _) = unit_info(&p.unit).unwrap_or((Kind::Length, 1.0));+ let defaults = Defaults::for_unit(&p.unit, doc_len);+ let x = eval_with_defaults(&p.expr, lookup, defaults)?.to_kind_in(kind, defaults)?;+ Ok(match kind {+ Kind::Length => Value::length(x),+ Kind::Angle => Value::angle(x),+ Kind::Unitless => Value::num(x),+ })+}+/// Dependency edges between parameters: (parameter, parameter it references).pub fn param_edges(params: &[ParamDef]) -> Vec<(String, String)> {let mut out = Vec::new();diff --git a/crates/doc/src/params.rs b/crates/doc/src/params.rsindex 25e0fc2c4f..1ec392c431 100644--- a/crates/doc/src/params.rs+++ b/crates/doc/src/params.rs@@ -463,14 +463,92 @@ impl Document {if rows.len() > 10_000 {return Err(DocError::Invalid("too many parameters".into()));}+ // Each row is checked and applied as `change_param` would, but the parameters are+ // evaluated once for all of them, not once per row (thousands of rows took minutes).let mut next = self.clone();- let mut names = Vec::new();- for (n, e, u, c) in rows {- next.change_param(&n, &e, u.as_deref(), c.as_deref())?;- names.push(n);+ let (mut vals, _) = next.param_values();+ for (n, e, u, c) in &rows {+ next.import_row(n, e, u.as_deref(), c.as_deref(), &mut vals)?;+ }+ let (_, errors) = next.param_values();+ if let Some(e) = rows.iter().find_map(|(n, ..)| errors.get(n)) {+ return Err(DocError::Expr(e.clone()));}*self = next;- Ok(names)+ Ok(rows.into_iter().map(|(n, ..)| n).collect())+ }++ /// One imported row: the checks and change of `change_param` (a feature's parameter) or+ /// `set_param` (a user parameter, a new one taking the unit of its value) without evaluating+ /// every parameter. `vals` are the values so far, for the units of the rows after it.+ fn import_row(&mut self, name: &str, expr_s: &str, unit: Option<&str>, comment: Option<&str>, vals: &mut BTreeMap<String, Value>) -> Result<()> {+ if expr_s.len() > 4096 {+ return Err(DocError::Expr("expression too long".into()));+ }+ let hit = self.features.iter().enumerate().find_map(|(i, f)| f.param_names.iter().position(|n| n == name).map(|k| (i, k)));+ if let Some((i, k)) = hit {+ let kind = self.features.get(i).and_then(|f| f.kind.inputs().get(k).map(|x| x.2)).unwrap_or(Kind::Unitless);+ let expr_s = self.with_design_unit(expr_s, kind);+ if let Some(f) = self.features.get_mut(i)+ && let Some((_, e, _)) = f.kind.inputs_mut().into_iter().nth(k)+ {+ *e = expr_s.into();+ }+ if let Some(c) = comment {+ self.param_comments.insert(name.to_string(), c.to_string());+ }+ return Ok(());+ }+ if let Some(p) = Self::param_name_problem(name) {+ return Err(DocError::Invalid(p));+ }+ if expr_s.trim().is_empty() {+ return Err(DocError::Expr("empty expression".into()));+ }+ if let Some(u) = unit+ && expr::unit_info(u).is_none()+ {+ return Err(DocError::Expr(format!("unknown unit `{u}` (mm, cm, m, in, ft, deg, rad or none)")));+ }+ if comment.is_some_and(|c| c.len() > 4096) {+ return Err(DocError::Invalid("comment too long".into()));+ }+ match self.params.iter_mut().find(|p| p.name == name) {+ Some(p) => {+ p.expr = expr_s.trim().to_string();+ if let Some(u) = unit {+ p.unit = u.trim().to_string();+ }+ if let Some(c) = comment {+ p.comment = c.to_string();+ }+ }+ None => {+ if self.params.len() >= MAX_PARAMS {+ return Err(DocError::Invalid("too many parameters".into()));+ }+ let unit = match unit {+ Some(u) => u.trim().to_string(),+ None => Self::infer_unit_in(vals, expr_s),+ };+ self.params.push(crate::Param {+ name: name.into(),+ expr: expr_s.trim().into(),+ unit,+ comment: comment.unwrap_or_default().into(),+ model: false,+ });+ }+ }+ let def = self.params.iter().find(|p| p.name == name).map(|p| ParamDef { name: p.name.clone(), expr: p.expr.clone(), unit: p.unit.clone() });+ let value = def.and_then(|d| {+ expr::eval_def(&d, &|n| vals.get(n).copied().ok_or_else(|| DocError::Expr(format!("unknown parameter `{n}`"))), doc_len(&self.units)).ok()+ });+ match value {+ Some(v) => vals.insert(name.to_string(), v),+ None => vals.remove(name),+ };+ Ok(())}}@@ -558,7 +636,11 @@ impl Document {/// The unit for a new parameter with this expression: that of its value; a bare number is/// a length (mm).pub(crate) fn infer_unit(&self, e: &str) -> String {- let (vals, _) = self.param_values();+ Self::infer_unit_in(&self.param_values().0, e)+ }++ /// [`Document::infer_unit`] against parameter values already worked out.+ fn infer_unit_in(vals: &BTreeMap<String, Value>, e: &str) -> String {let v = expr::eval_with(e, &|n| vals.get(n).copied().ok_or_else(|| DocError::Expr(format!("unknown parameter `{n}`"))));match v.ok().and_then(|v| v.kind()) {Some(Kind::Unitless) if !expr::references(e).is_empty() => String::new(),diff --git a/crates/engine/src/cmd/parameters.rs b/crates/engine/src/cmd/parameters.rsindex daa74cbcbd..c15b57aca2 100644--- a/crates/engine/src/cmd/parameters.rs+++ b/crates/engine/src/cmd/parameters.rs@@ -12,7 +12,8 @@ use crate::{EngineError, Result, Session};pub static COMMANDS: &[CommandSpec] = &[CommandSpec::new("parameters.change", "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 → recomputed: features rebuilt, \+ favorite?: bool, new_name?: rename (references follow); or delete: name; or changes: {name: expression, …} (existing \+ parameters, checked together and rebuilt once, all or nothing) → changed?: {name: value} (with changes), recomputed: features rebuilt, \restored: features whose earlier result for the same inputs was reused (e.g. a value set back)",),CommandSpec::new("parameters.list", "List Parameters", list).icon("list").noundo().doc_only().params(@@ -82,6 +83,9 @@ fn known(s: &Session, name: &str) -> bool {fn change_param(s: &mut Session, p: &Value) -> Result<Value> {let cmd = "parameters.change";let solved = s.solved_sketches();+ if let Some(changes) = p.get("changes") {+ return change_many(s, changes, &solved);+ }if let Some(n) = str_(p, "delete") {s.doc_mut().remove_param(n.trim())?;s.settle_value_edit(&solved)?;@@ -129,6 +133,26 @@ fn change_param(s: &mut Session, p: &Value) -> Result<Value> {Ok(out)}+/// `parameters.change {changes}`: several existing parameters set at once, so a design is+/// rebuilt once for all of them instead of once per parameter.+fn change_many(s: &mut Session, changes: &Value, solved: &crate::SketchValues) -> Result<Value> {+ let cmd = "parameters.change";+ let Some(map) = changes.as_object() else { return Err(bad(cmd, "`changes` must be an object of name: expression")) };+ if map.is_empty() {+ return Err(bad(cmd, "`changes` is empty"));+ }+ let mut list = Vec::with_capacity(map.len());+ for (name, e) in map {+ let e = expr_arg(&json!({"e": e}), "e").ok_or_else(|| bad(cmd, format!("`changes.{name}` must be a number or text")))?;+ list.push((name.trim().to_string(), e));+ }+ s.doc_mut().change_params_atomic(&list)?;+ s.settle_value_edit(solved)?;+ let (vals, _) = s.doc.param_values();+ let values: serde_json::Map<String, Value> = list.iter().map(|(n, _)| (n.clone(), json!(vals.get(n).map(|v| v.v)))).collect();+ Ok(json!({"changed": values, "recomputed": s.model.last_recomputed, "restored": s.model.last_restored, "errors": failing(s)}))+}+fn list(s: &mut Session, p: &Value) -> Result<Value> {let filter = match (bool_(p, "favorites"), str_(p, "filter")) {(Some(true), _) => "favorites".to_string(),diff --git a/crates/engine/src/cmd/parameters_tests.rs b/crates/engine/src/cmd/parameters_tests.rsindex 1b9601e461..66a88f1abf 100644--- a/crates/engine/src/cmd/parameters_tests.rs+++ b/crates/engine/src/cmd/parameters_tests.rs@@ -593,3 +593,65 @@ fn moving_a_parameter_refuses_bad_targets() {}assert_eq!(s.doc.to_json(), before);}++#[test]+fn a_large_import_is_checked_once_and_keeps_each_rows_unit() {+ // 3000 parameters, each the one before plus a millimetre, then an angle, a unit-less+ // ratio and a row that names a parameter defined further down: all new, in one import.+ let mut csv = String::from("name,expression\n");+ csv.push_str("a,later * 2\np0,1 mm\n");+ for i in 1..3000 {+ csv.push_str(&format!("p{i},p{} + 1 mm\n", i - 1));+ }+ csv.push_str("turn,30 deg\nratio,p10 / p4\nlater,5\n");+ let mut s = Session::default();+ let t = std::time::Instant::now();+ run(&mut s, "parameters.import", json!({"text": csv}));+ println!("import of {} rows: {:.2} s", 3005, t.elapsed().as_secs_f64());+ let (vals, errors) = s.doc.param_values();+ assert!(errors.is_empty(), "{errors:?}");+ let unit = |n: &str| s.doc.param(n).map(|p| p.unit.clone()).unwrap_or_default();+ assert_eq!((unit("p2999"), unit("turn"), unit("ratio"), unit("later")), ("mm".into(), "deg".into(), String::new(), "mm".into()));+ assert!(+ vals.get("p2999").is_some_and(|v| (v.to_kind(solidcraft_doc::expr::Kind::Length).unwrap_or(f64::NAN) - 3000.0).abs() < 1e-9),+ "{:?}",+ vals.get("p2999")+ );+ assert!(+ vals.get("a").is_some_and(|v| (v.to_kind(solidcraft_doc::expr::Kind::Length).unwrap_or(f64::NAN) - 10.0).abs() < 1e-9),+ "{:?}",+ vals.get("a")+ );+ // Changing the first moves the whole chain; a row that breaks changes nothing.+ run(&mut s, "parameters.import", json!({"text": "name,expression\np0,101 mm\n"}));+ assert!(+ s.doc+ .param_values()+ .0+ .get("p2999")+ .is_some_and(|v| (v.to_kind(solidcraft_doc::expr::Kind::Length).unwrap_or(f64::NAN) - 3100.0).abs() < 1e-9)+ );+ assert!(s.execute("parameters.import", &json!({"text": "name,expression\np0,2 mm\np5,p0 + 1 deg\n"})).is_err());+ assert_eq!(s.doc.param("p0").map(|p| p.expr.as_str()), Some("101 mm"));+}++#[test]+fn several_parameters_change_in_one_rebuild_and_one_undo() {+ let mut s = Session::default();+ run(&mut s, "parameters.add", json!({"name": "h", "expression": "10 mm"}));+ block(&mut s);+ let d = run(&mut s, "parameters.list", json!({"filter": "feature"}))["parameters"][0]["name"].as_str().unwrap_or_default().to_string();+ run(&mut s, "parameters.change", json!({"name": d, "expression": "h"}));+ let r = run(&mut s, "parameters.change", json!({"changes": {"len": "100 mm", "h": 20}}));+ assert_eq!(r["errors"].as_array().map(Vec::len), Some(0), "{r}");+ assert_eq!(r["changed"]["len"], 100.0, "{r}");+ assert!(rel(volume(&mut s), 40.0 * 50.0 * 20.0) < 1e-9);+ // All or nothing: an unknown name or a broken expression changes nothing.+ assert!(err(&mut s, "parameters.change", json!({"changes": {"len": "60 mm", "nope": "1 mm"}})).contains("nope"));+ assert!(s.execute("parameters.change", &json!({"changes": {"len": "60 mm", "h": "1 / 0"}})).is_err());+ assert!(s.execute("parameters.change", &json!({"changes": {}})).is_err());+ assert_eq!(expr_of(&mut s, "len"), "100 mm");+ run(&mut s, "edit.undo", json!({}));+ assert_eq!((expr_of(&mut s, "len"), expr_of(&mut s, "h")), ("60 mm".to_string(), "10 mm".to_string()));+ assert!(rel(volume(&mut s), 40.0 * 30.0 * 10.0) < 1e-9);+}