SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
Parameters engine: feature inputs as named model parameters (dN, editable, referenceable), parameters table with sources, values, dependencies (uses/used by) and cycles, favourites, comments, CSV/JSON export and import; more units (inch, mil, yd, km, nm) and functions (exp, ln, log, sign, pow, hypot)
bherbruckf0cfeba59b1a
diff --git a/crates/doc/src/document.rs b/crates/doc/src/document.rsindex ef0c951a26..cadfb50218 100644--- a/crates/doc/src/document.rs+++ b/crates/doc/src/document.rs@@ -605,6 +605,9 @@ pub struct Feature {/// Names for the bodies this feature creates (in order); missing ones get `BodyN`.#[serde(default, skip_serializing_if = "Vec::is_empty")]pub body_names: Vec<String>,+ /// Parameter names of the feature's inputs (see `FeatureKind::inputs`), e.g. `d3`.+ #[serde(default, skip_serializing_if = "Vec::is_empty")]+ pub param_names: Vec<String>,/// The component the feature (and what it makes) belongs to; 0 = the root.#[serde(default, skip_serializing_if = "is_root")]pub component: u64,@@ -641,6 +644,12 @@ pub struct Document {/// Placements of components in their parents (each non-root component has at least one).#[serde(default, skip_serializing_if = "Vec::is_empty")]pub occurrences: Vec<crate::Occurrence>,+ /// Favourite parameters (by name).+ #[serde(default, skip_serializing_if = "std::collections::BTreeSet::is_empty")]+ pub favorites: std::collections::BTreeSet<String>,+ /// Comments of feature-input parameters (by name).+ #[serde(default, skip_serializing_if = "std::collections::BTreeMap::is_empty")]+ pub param_comments: std::collections::BTreeMap<String, String>,/// Physical material per body (by body name); others use the default.#[serde(default, skip_serializing_if = "std::collections::BTreeMap::is_empty")]pub materials: std::collections::BTreeMap<String, String>,@@ -676,6 +685,8 @@ impl Document {occurrences: Vec::new(),body_components: Default::default(),materials: Default::default(),+ favorites: Default::default(),+ param_comments: Default::default(),}}@@ -724,6 +735,12 @@ impl Document {pub fn from_json(s: &str) -> Result<Document> {let d: Document = serde_json::from_str(s).map_err(|e| DocError::Invalid(format!("document: {e}")))?;+ // Feature inputs get parameter names (designs from before they had them).+ let mut d = d;+ let ids: Vec<u64> = d.features.iter().map(|f| f.id).collect();+ for id in ids {+ d.name_feature_inputs(id);+ }// Designs from before occurrences: every component gets one, in place.let mut d = d;let missing: Vec<(u64, u64)> =@@ -781,7 +798,7 @@ impl Document {Some(n) if !n.trim().is_empty() => n.trim().to_string(),_ => self.unique_name(kind.base_name()),};- let f = Feature { id, name, suppressed: false, body_names: Vec::new(), component: 0, kind };+ let f = Feature { id, name, suppressed: false, body_names: Vec::new(), param_names: Vec::new(), component: 0, kind };match self.marker {Some(m) if m < self.features.len() => {self.features.insert(m, f);@@ -845,7 +862,7 @@ impl Document {let mut cs = name.chars();matches!(cs.next(), Some(c) if c.is_alphabetic() || c == '_')&& cs.all(|c| c.is_alphanumeric() || c == '_')- && !matches!(name, "mm" | "cm" | "m" | "um" | "in" | "ft" | "deg" | "rad" | "pi" | "PI")+ && !matches!(name, "mm" | "cm" | "m" | "um" | "in" | "inch" | "mil" | "yd" | "km" | "nm" | "ft" | "deg" | "rad" | "pi" | "PI")&& name.len() <= 64}@@ -857,6 +874,9 @@ impl Document {if expr_s.len() > 4096 {return Err(DocError::Expr("expression too long".into()));}+ if self.features.iter().any(|f| f.param_names.iter().any(|n| n == name)) {+ return Err(DocError::Invalid(format!("`{name}` is a feature's parameter")));+ }let mut next = self.clone();match next.params.iter_mut().find(|p| p.name == name) {Some(p) => {@@ -891,14 +911,7 @@ impl Document {/// Create the next free model parameter `dN` with the given expression and unit.pub fn new_model_param(&mut self, expr_s: &str, unit: &str) -> String {- let mut n = 1;- let name = loop {- let c = format!("d{n}");- if self.param(&c).is_none() {- break c;- }- n += 1;- };+ let name = self.next_d_name();self.params.push(Param { name: name.clone(), expr: expr_s.into(), unit: unit.into(), comment: String::new(), model: true });name}@@ -919,8 +932,7 @@ impl Document {/// Evaluate all parameters: values (mm / rad / unit-less) and errors by name.pub fn param_values(&self) -> (std::collections::BTreeMap<String, expr::Value>, std::collections::BTreeMap<String, String>) {- let list: Vec<(String, String, Kind)> = self.params.iter().map(|p| (p.name.clone(), p.expr.clone(), p.kind())).collect();- expr::eval_params(&list)+ expr::eval_params(&self.all_param_exprs())}/// Evaluate an expression against the document's parameters.diff --git a/crates/doc/src/expr.rs b/crates/doc/src/expr.rsindex cb4a72e2bc..cc891c3621 100644--- a/crates/doc/src/expr.rs+++ b/crates/doc/src/expr.rs@@ -73,7 +73,11 @@ fn unit(name: &str) -> Option<Value> {"cm" => Value::length(10.0),"m" => Value::length(1000.0),"um" => Value::length(0.001),- "in" => Value::length(25.4),+ "in" | "inch" => Value::length(25.4),+ "mil" => Value::length(0.0254),+ "yd" => Value::length(914.4),+ "km" => Value::length(1_000_000.0),+ "nm" => Value::length(1e-6),"ft" => Value::length(304.8),"deg" => Value::angle(std::f64::consts::PI / 180.0),"rad" => Value::angle(1.0),@@ -328,6 +332,43 @@ fn call(f: &str, args: &[Value]) -> Result<Value, DocError> {}Value { v: a.v.sqrt(), len: a.len / 2, ang: a.ang / 2 }}+ "exp" => Value::num(num(one()?)?.exp()),+ "ln" => Value::num(num(one()?)?.ln()),+ "log" | "log10" => Value::num(num(one()?)?.log10()),+ "sign" => {+ let a = one()?;+ Value::num(if a.v > 0.0 {+ 1.0+ } else if a.v < 0.0 {+ -1.0+ } else {+ 0.0+ })+ }+ "pow" => match args {+ [a, b] => {+ let e = num(*b)?;+ if a.unitless() {+ Value::num(a.v.powf(e))+ } else if (e - e.round()).abs() < 1e-12 && e.abs() <= 6.0 {+ let k = e.round() as i8;+ let (Some(len), Some(ang)) = (a.len.checked_mul(k), a.ang.checked_mul(k)) else {+ return Err(DocError::Expr("unit power too large".into()));+ };+ Value { v: a.v.powi(i32::from(k)), len, ang }+ } else {+ return Err(DocError::Expr("pow of a unit needs a whole exponent".into()));+ }+ }+ _ => return Err(DocError::Expr("`pow` takes two arguments".into())),+ },+ "hypot" => match args {+ [a, b] => {+ let s = add(*b, Value { v: 0.0, ..*a }, false)?;+ Value { v: a.v.hypot(s.v), ..*a }+ }+ _ => return Err(DocError::Expr("`hypot` takes two arguments".into())),+ },"abs" => {let a = one()?;Value { v: a.v.abs(), ..a }diff --git a/crates/doc/src/lib.rs b/crates/doc/src/lib.rsindex 57303f8589..02d2188a76 100644--- a/crates/doc/src/lib.rs+++ b/crates/doc/src/lib.rs@@ -9,11 +9,13 @@ mod assembly;mod document;mod eval;pub mod expr;+mod params;pub mod project;pub use assembly::{IDENTITY, Mat, Occurrence, apply_point, apply_vector, is_identity, mat_inverse, mat_mul, rigid};pub use document::*;pub use eval::{FeatureResult, Model, ModelBody, ModelState, SolvedSketch, ThreadInfo, parse_metric_thread, world_state};+pub use params::{ParamRow, cycles};pub use solvecraft_kernel as kernel;pub use solvecraft_sketch as sketch;diff --git a/crates/doc/src/params.rs b/crates/doc/src/params.rsnew file mode 100644index 0000000000..7b74e6f821--- /dev/null+++ b/crates/doc/src/params.rs@@ -0,0 +1,431 @@+//! Parameters: user parameters, model parameters of sketch dimensions, and feature inputs+//! (extrude distance, fillet radius…) which also appear as model parameters `dN` without being+//! stored twice: the feature keeps its expression and the parameter name refers to it. Every+//! parameter can be referenced by name from any expression; the dependency graph and cycles+//! come from the expression references.++use std::collections::{BTreeMap, BTreeSet};++use serde::Serialize;++use crate::expr::{self, Kind};+use crate::{DocError, Document, FeatureKind, HoleKind, PatternKind, PlaneRef, Result};++fn plane_inputs_mut<'a>(p: &'a mut PlaneRef, v: &mut Vec<(&'static str, &'a mut String, Kind)>) {+ match p {+ PlaneRef::Offset { base, distance } => {+ v.push(("Offset", distance, Kind::Length));+ plane_inputs_mut(base, v);+ }+ PlaneRef::AtAngle { base, angle, .. } => {+ v.push(("Angle", angle, Kind::Angle));+ plane_inputs_mut(base, v);+ }+ _ => {}+ }+}++impl FeatureKind {+ /// The feature's numeric inputs: (label, expression, kind), in a fixed order.+ pub fn inputs_mut(&mut self) -> Vec<(&'static str, &mut String, Kind)> {+ use Kind::{Angle as A, Length as L, Unitless as U};+ let mut v: Vec<(&'static str, &mut String, Kind)> = Vec::new();+ match self {+ FeatureKind::Sketch { plane, .. }+ | FeatureKind::ConstructionPlane { plane }+ | FeatureKind::Split { plane, .. }+ | FeatureKind::Mirror { plane, .. } => plane_inputs_mut(plane, &mut v),+ FeatureKind::Extrude { extent, .. } => {+ v.push(("Distance", &mut extent.distance, L));+ if let Some(d) = &mut extent.distance2 {+ v.push(("Distance 2", d, L));+ }+ if let Some(d) = &mut extent.start_offset {+ v.push(("Start offset", d, L));+ }+ if let Some(d) = &mut extent.taper {+ v.push(("Taper angle", d, A));+ }+ }+ FeatureKind::Revolve { angle, .. } => v.push(("Angle", angle, A)),+ FeatureKind::Fillet { radius, .. } => v.push(("Radius", radius, L)),+ FeatureKind::Chamfer { distance, .. } => v.push(("Distance", distance, L)),+ FeatureKind::Box { length, width, height, .. } => {+ v.push(("Length", length, L));+ v.push(("Width", width, L));+ v.push(("Height", height, L));+ }+ FeatureKind::Cylinder { radius, height, .. } => {+ v.push(("Radius", radius, L));+ v.push(("Height", height, L));+ }+ FeatureKind::Sphere { radius, .. } => v.push(("Radius", radius, L)),+ FeatureKind::Torus { major, minor, .. } => {+ v.push(("Major radius", major, L));+ v.push(("Minor radius", minor, L));+ }+ FeatureKind::Pattern { pattern, .. } => match pattern {+ PatternKind::Rectangular { count1, spacing1, count2, spacing2, .. } => {+ v.push(("Quantity", count1, U));+ v.push(("Spacing", spacing1, L));+ if let Some(c) = count2 {+ v.push(("Quantity 2", c, U));+ }+ if let Some(sp) = spacing2 {+ v.push(("Spacing 2", sp, L));+ }+ }+ PatternKind::Circular { count, angle, .. } => {+ v.push(("Quantity", count, U));+ v.push(("Total angle", angle, A));+ }+ },+ FeatureKind::Shell { thickness, .. } => v.push(("Thickness", thickness, L)),+ FeatureKind::Draft { angle, neutral, .. } => {+ v.push(("Angle", angle, A));+ plane_inputs_mut(neutral, &mut v);+ }+ FeatureKind::Hole { diameter, depth, hole, .. } => {+ v.push(("Diameter", diameter, L));+ if let Some(d) = depth {+ v.push(("Depth", d, L));+ }+ match hole {+ HoleKind::Simple => {}+ HoleKind::Drilled { tip_angle } => v.push(("Tip angle", tip_angle, A)),+ HoleKind::Counterbore { cb_diameter, cb_depth } => {+ v.push(("Counterbore diameter", cb_diameter, L));+ v.push(("Counterbore depth", cb_depth, L));+ }+ HoleKind::Countersink { cs_diameter, cs_angle } => {+ v.push(("Countersink diameter", cs_diameter, L));+ v.push(("Countersink angle", cs_angle, A));+ }+ }+ }+ FeatureKind::Thread { length, .. } => {+ if let Some(l) = length {+ v.push(("Length", l, L));+ }+ }+ FeatureKind::Scale { factor, factors, .. } => {+ v.push(("Scale factor", factor, U));+ if let Some([x, y, z]) = factors {+ v.push(("X scale", x, U));+ v.push(("Y scale", y, U));+ v.push(("Z scale", z, U));+ }+ }+ FeatureKind::OffsetFace { distance, .. } => v.push(("Distance", distance, L)),+ FeatureKind::BoundingSolid { margin, .. } => v.push(("Margin", margin, L)),+ FeatureKind::Pipe { diameter, wall, .. } => {+ v.push(("Diameter", diameter, L));+ if let Some(w) = wall {+ v.push(("Wall", w, L));+ }+ }+ FeatureKind::Move { translate, angle, .. } => {+ let [x, y, z] = translate;+ v.push(("X distance", x, L));+ v.push(("Y distance", y, L));+ v.push(("Z distance", z, L));+ if let Some(a) = angle {+ v.push(("Angle", a, A));+ }+ }+ FeatureKind::Combine { .. }+ | FeatureKind::Loft { .. }+ | FeatureKind::Sweep { .. }+ | FeatureKind::Import { .. }+ | FeatureKind::MeshImport { .. } => {}+ }+ v+ }++ /// Read-only view of [`FeatureKind::inputs_mut`]: (label, expression, kind).+ pub fn inputs(&self) -> Vec<(&'static str, String, Kind)> {+ let mut c = self.clone();+ c.inputs_mut().into_iter().map(|(l, e, k)| (l, e.clone(), k)).collect()+ }+}++/// One row of the parameters table.+#[derive(Clone, Debug, Serialize)]+pub struct ParamRow {+ pub name: String,+ pub expression: String,+ pub unit: String,+ pub value: Option<f64>,+ pub error: Option<String>,+ pub comment: String,+ /// "user", "sketch" (a dimension) or "feature".+ pub source: &'static str,+ /// For feature inputs: the feature and the input's label.+ #[serde(skip_serializing_if = "Option::is_none")]+ pub feature: Option<String>,+ #[serde(skip_serializing_if = "Option::is_none")]+ pub input: Option<&'static str>,+ pub favorite: bool,+ /// Names this one's expression uses, and names whose expressions use this one.+ pub uses: Vec<String>,+ pub used_by: Vec<String>,+}++fn unit_of(k: Kind) -> &'static str {+ match k {+ Kind::Length => "mm",+ Kind::Angle => "deg",+ Kind::Unitless => "",+ }+}++impl Document {+ /// Every (name, expression, kind) the expressions can refer to: stored parameters and the+ /// named feature inputs.+ pub fn all_param_exprs(&self) -> Vec<(String, String, Kind)> {+ let mut v: Vec<(String, String, Kind)> = self.params.iter().map(|p| (p.name.clone(), p.expr.clone(), p.kind())).collect();+ for f in &self.features {+ for (name, (_, e, k)) in f.param_names.iter().zip(f.kind.inputs()) {+ if !name.is_empty() {+ v.push((name.clone(), e, k));+ }+ }+ }+ v+ }++ fn name_taken(&self, n: &str) -> bool {+ self.param(n).is_some() || self.features.iter().any(|f| f.param_names.iter().any(|x| x == n))+ }++ /// The next free `dN` name.+ pub fn next_d_name(&self) -> String {+ let mut n = 1;+ loop {+ let c = format!("d{n}");+ if !self.name_taken(&c) {+ return c;+ }+ n += 1;+ }+ }++ /// Give a feature's inputs parameter names (keeping existing names in place).+ pub fn name_feature_inputs(&mut self, id: u64) {+ let Some(idx) = self.feature_index(id) else { return };+ let n = self.features.get(idx).map(|f| f.kind.inputs().len()).unwrap_or(0);+ for k in 0..n {+ let have = self.features.get(idx).and_then(|f| f.param_names.get(k)).is_some_and(|x| !x.is_empty());+ if have {+ continue;+ }+ let name = self.next_d_name();+ if let Some(f) = self.features.get_mut(idx) {+ while f.param_names.len() <= k {+ f.param_names.push(String::new());+ }+ if let Some(slot) = f.param_names.get_mut(k) {+ *slot = name;+ }+ }+ }+ if let Some(f) = self.features.get_mut(idx) {+ f.param_names.truncate(n);+ }+ }++ /// Change a parameter: a stored one, or a feature input by its name.+ pub fn change_param(&mut self, name: &str, expr_s: &str, unit: Option<&str>, comment: Option<&str>) -> Result<()> {+ let hit = self.features.iter().enumerate().find_map(|(i, f)| f.param_names.iter().position(|n| n == name).map(|k| (i, k)));+ let Some((i, k)) = hit else { return self.set_param(name, expr_s, unit, comment) };+ if expr_s.len() > 4096 {+ return Err(DocError::Expr("expression too long".into()));+ }+ let mut next = self.clone();+ if let Some(f) = next.features.get_mut(i)+ && let Some((_, e, _)) = f.kind.inputs_mut().into_iter().nth(k)+ {+ *e = expr_s.to_string();+ }+ if let Some(c) = comment {+ next.param_comments.insert(name.to_string(), c.to_string());+ }+ let (_, errors) = next.param_values();+ if let Some(e) = errors.get(name) {+ return Err(DocError::Expr(e.clone()));+ }+ *self = next;+ Ok(())+ }++ /// The parameters table (user, sketch dimensions, feature inputs).+ pub fn param_rows(&self) -> Vec<ParamRow> {+ let (vals, errs) = self.param_values();+ let all = self.all_param_exprs();+ let refs: BTreeMap<String, Vec<String>> = all.iter().map(|(n, e, _)| (n.clone(), expr::references(e))).collect();+ let used_by = |n: &str| -> Vec<String> { refs.iter().filter(|(_, r)| r.iter().any(|x| x == n)).map(|(k, _)| k.clone()).collect() };+ let value = |n: &str, k: Kind| vals.get(n).and_then(|v| v.to_kind(k).ok()).map(|x| if k == Kind::Angle { x.to_degrees() } else { x });+ let mut rows = Vec::new();+ for p in &self.params {+ rows.push(ParamRow {+ name: p.name.clone(),+ expression: p.expr.clone(),+ unit: p.unit.clone(),+ value: value(&p.name, p.kind()),+ error: errs.get(&p.name).cloned(),+ comment: p.comment.clone(),+ source: if p.model { "sketch" } else { "user" },+ feature: None,+ input: None,+ favorite: self.favorites.contains(&p.name),+ uses: refs.get(&p.name).cloned().unwrap_or_default(),+ used_by: used_by(&p.name),+ });+ }+ for f in &self.features {+ for (name, (label, e, k)) in f.param_names.iter().zip(f.kind.inputs()) {+ if name.is_empty() {+ continue;+ }+ rows.push(ParamRow {+ name: name.clone(),+ expression: e,+ unit: unit_of(k).into(),+ value: value(name, k),+ error: errs.get(name).cloned(),+ comment: self.param_comments.get(name).cloned().unwrap_or_default(),+ source: "feature",+ feature: Some(f.name.clone()),+ input: Some(label),+ favorite: self.favorites.contains(name),+ uses: refs.get(name).cloned().unwrap_or_default(),+ used_by: used_by(name),+ });+ }+ }+ rows+ }++ pub fn set_favorite(&mut self, name: &str, on: bool) -> Result<()> {+ if !self.name_taken(name) {+ return Err(DocError::Unknown(format!("parameter `{name}`")));+ }+ if on {+ self.favorites.insert(name.to_string());+ } else {+ self.favorites.remove(name);+ }+ Ok(())+ }++ /// User parameters as CSV (`name,unit,expression,value,comment`).+ pub fn params_csv(&self) -> String {+ let q = |s: &str| if s.contains([',', '"', '\n']) { format!("\"{}\"", s.replace('"', "\"\"")) } else { s.to_string() };+ let mut out = String::from("name,unit,expression,value,comment,favorite\n");+ for r in self.param_rows().into_iter().filter(|r| r.source == "user") {+ out += &format!(+ "{},{},{},{},{},{}\n",+ q(&r.name),+ q(&r.unit),+ q(&r.expression),+ r.value.map(|v| format!("{v}")).unwrap_or_default(),+ q(&r.comment),+ r.favorite+ );+ }+ out+ }++ /// Import user parameters (CSV with a header, or JSON `[{name, expression, unit?, comment?}]`):+ /// existing ones are updated, new ones added, all checked before anything changes.+ pub fn import_params(&mut self, text: &str) -> Result<Vec<String>> {+ let rows: Vec<(String, String, Option<String>, Option<String>)> = if text.trim_start().starts_with('[') {+ let v: serde_json::Value = serde_json::from_str(text).map_err(|e| DocError::Invalid(format!("parameters JSON: {e}")))?;+ v.as_array()+ .ok_or_else(|| DocError::Invalid("parameters JSON must be a list".into()))?+ .iter()+ .map(|r| {+ let s = |k: &str| r.get(k).and_then(|x| x.as_str().map(str::to_string).or_else(|| x.as_f64().map(|n| n.to_string())));+ Ok((+ s("name").ok_or_else(|| DocError::Invalid("a parameter without `name`".into()))?,+ s("expression").or_else(|| s("value")).unwrap_or_default(),+ s("unit"),+ s("comment"),+ ))+ })+ .collect::<Result<_>>()?+ } else {+ let mut lines = text.lines();+ let header: Vec<String> = parse_csv_line(lines.next().unwrap_or_default()).into_iter().map(|h| h.trim().to_ascii_lowercase()).collect();+ let col = |n: &str| header.iter().position(|h| h == n);+ let (Some(ni), Some(ei)) = (col("name"), col("expression").or(col("value"))) else {+ return Err(DocError::Invalid("the CSV needs `name` and `expression` columns".into()));+ };+ let (ui, ci) = (col("unit"), col("comment"));+ lines+ .filter(|l| !l.trim().is_empty())+ .map(|l| {+ let c = parse_csv_line(l);+ let get = |i: Option<usize>| i.and_then(|i| c.get(i)).map(|s| s.trim().to_string());+ (get(Some(ni)).unwrap_or_default(), get(Some(ei)).unwrap_or_default(), get(ui), get(ci))+ })+ .collect()+ };+ if rows.len() > 10_000 {+ return Err(DocError::Invalid("too many parameters".into()));+ }+ 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);+ }+ *self = next;+ Ok(names)+ }+}++/// One CSV line with quoted fields.+fn parse_csv_line(l: &str) -> Vec<String> {+ let mut out = Vec::new();+ let mut cur = String::new();+ let mut quoted = false;+ let mut chars = l.chars().peekable();+ while let Some(c) = chars.next() {+ match (c, quoted) {+ ('"', true) if chars.peek() == Some(&'"') => {+ cur.push('"');+ chars.next();+ }+ ('"', _) => quoted = !quoted,+ (',', false) => out.push(std::mem::take(&mut cur)),+ (c, _) => cur.push(c),+ }+ }+ out.push(cur);+ out+}++/// Parameters whose definitions depend on each other in a loop.+pub fn cycles(list: &[(String, String, Kind)]) -> BTreeSet<String> {+ let refs: BTreeMap<&str, Vec<String>> = list.iter().map(|(n, e, _)| (n.as_str(), expr::references(e))).collect();+ let mut bad = BTreeSet::new();+ for (start, _, _) in list {+ // Depth-first from `start`; reaching it again is a cycle.+ let mut stack: Vec<(String, usize)> = refs.get(start.as_str()).map(|r| r.iter().map(|x| (x.clone(), 1)).collect()).unwrap_or_default();+ let mut seen = BTreeSet::new();+ while let Some((n, d)) = stack.pop() {+ if &n == start {+ bad.insert(start.clone());+ break;+ }+ if d > 10_000 || !seen.insert(n.clone()) {+ continue;+ }+ if let Some(r) = refs.get(n.as_str()) {+ stack.extend(r.iter().map(|x| (x.clone(), d + 1)));+ }+ }+ }+ bad+}diff --git a/crates/doc/src/tests.rs b/crates/doc/src/tests.rsindex f557e15233..99f27c3182 100644--- a/crates/doc/src/tests.rs+++ b/crates/doc/src/tests.rs@@ -195,3 +195,69 @@ fn primitives_and_combine() {assert_eq!(st.bodies.len(), 1);assert!(rel(measure(&st.bodies[0].body).unwrap().volume, 1000.0 - std::f64::consts::PI * 40.0) < 1e-3);}++#[test]+fn hostile_expressions_never_panic() {+ // A deterministic stream of nasty inputs: random tokens, deep nesting, huge numbers.+ let toks = [+ "(",+ ")",+ "+",+ "-",+ "*",+ "/",+ "^",+ ",",+ "1e308",+ "0",+ "-0",+ "mm",+ "deg",+ "x",+ "sqrt",+ "pow",+ "min",+ "max",+ "°",+ "1.2.3",+ "e",+ "pi",+ "in",+ "nan",+ "9999999999999999999999",+ ];+ let mut state: u64 = 0x9e3779b97f4a7c15;+ let mut next = || {+ state ^= state << 13;+ state ^= state >> 7;+ state ^= state << 17;+ state+ };+ for _ in 0..5000 {+ let n = (next() % 24) as usize;+ let s: String = (0..n).map(|_| toks[(next() % toks.len() as u64) as usize]).collect::<Vec<_>>().join(" ");+ let _ = crate::expr::eval_with(&s, &|n| {+ if n == "x" { Ok(crate::expr::Value::length(2.0)) } else { Err(crate::DocError::Expr("unknown".into())) }+ });+ }+ let deep = format!("{}1{}", "(".repeat(5000), ")".repeat(5000));+ assert!(crate::expr::eval_with(&deep, &|_| Err(crate::DocError::Expr("x".into()))).is_err());+ assert!(crate::expr::eval_with("pow(2 mm, 3)", &|_| Err(crate::DocError::Expr("x".into()))).is_ok());+ assert!(crate::expr::eval_with("pow(2 mm, 300)", &|_| Err(crate::DocError::Expr("x".into()))).is_err());+}++#[test]+fn parameter_cycles_are_found() {+ use crate::expr::Kind;+ let list = vec![+ ("a".to_string(), "b + 1".to_string(), Kind::Length),+ ("b".to_string(), "c * 2".to_string(), Kind::Length),+ ("c".to_string(), "a".to_string(), Kind::Length),+ ("d".to_string(), "5".to_string(), Kind::Length),+ ("e".to_string(), "d + e".to_string(), Kind::Length),+ ];+ let c = crate::cycles(&list);+ assert_eq!(c.into_iter().collect::<Vec<_>>(), vec!["a", "b", "c", "e"]);+ let (vals, errs) = crate::expr::eval_params(&list);+ assert!(vals.contains_key("d") && errs.contains_key("a") && errs.contains_key("e"));+}diff --git a/crates/engine/src/cmd/edit.rs b/crates/engine/src/cmd/edit.rsindex 098c9521b8..896349e9e3 100644--- a/crates/engine/src/cmd/edit.rs+++ b/crates/engine/src/cmd/edit.rs@@ -10,6 +10,13 @@ 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")@@ -76,7 +83,7 @@ fn change_param(s: &mut Session, p: &Value) -> Result<Value> {};let unit = str_(p, "unit");let comment = str_(p, "comment");- s.doc_mut().set_param(name, &e, unit, 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);@@ -333,3 +340,57 @@ 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 }))+}diff --git a/crates/engine/src/cmd/features.rs b/crates/engine/src/cmd/features.rsindex 7b63862bba..cc89341261 100644--- a/crates/engine/src/cmd/features.rs+++ b/crates/engine/src/cmd/features.rs@@ -240,6 +240,7 @@ fn add_feature(s: &mut Session, p: &Value, kind: FeatureKind) -> Result<Value> {let mut kind = kind;super::component::to_active_frame(s, &mut kind);let id = s.doc_mut().add_feature(kind, name)?;+ s.doc_mut().name_feature_inputs(id);let comp = s.active_component;if comp != 0&& let Some(f) = s.doc_mut().feature_mut(id)diff --git a/crates/engine/src/tests.rs b/crates/engine/src/tests.rsindex b3e5877bcc..3440c22834 100644--- a/crates/engine/src/tests.rs+++ b/crates/engine/src/tests.rs@@ -804,3 +804,40 @@ fn components_occurrences_and_world_placement() {let migrated = solvecraft_doc::Document::from_json(&old.to_string()).unwrap();assert_eq!(migrated.occurrences.len(), migrated.components.len());}++#[test]+fn feature_inputs_are_parameters() {+ let mut s = Session::default();+ run(&mut s, "ChangeParameterCommand", json!({"name": "w", "expression": "15 mm", "comment": "width"}));+ run(&mut s, "PrimitiveBox", json!({"length": 10, "width": "w", "height": "1 in", "name": "B"}));+ let l = run(&mut s, "parameters.list", json!({}));+ let rows = l["parameters"].as_array().unwrap();+ let feat: Vec<&Value> = rows.iter().filter(|r| r["source"] == "feature").collect();+ assert_eq!(feat.len(), 3, "{l}");+ let height = feat.iter().find(|r| r["input"] == "Height").unwrap();+ assert!((height["value"].as_f64().unwrap() - 25.4).abs() < 1e-9);+ let length_name = feat.iter().find(|r| r["input"] == "Length").unwrap()["name"].as_str().unwrap().to_string();+ // A feature parameter changes the feature; other expressions can use it.+ run(&mut s, "ChangeParameterCommand", json!({"name": length_name, "expression": "2 * w"}));+ assert!(rel(volume(&mut s), 30.0 * 15.0 * 25.4) < 1e-9);+ run(&mut s, "ChangeParameterCommand", json!({"name": "t", "expression": format!("{length_name} / 3")}));+ let t = run(&mut s, "parameters.list", json!({}))["parameters"].as_array().unwrap().iter().find(|r| r["name"] == "t").unwrap()["value"]+ .as_f64()+ .unwrap();+ assert!((t - 10.0).abs() < 1e-9);+ // Cycles are refused.+ assert!(s.execute("ChangeParameterCommand", &json!({"name": "w", "expression": "t"})).is_err());+ // Favourites, export and import.+ run(&mut s, "parameters.favorite", json!({"name": "w"}));+ assert_eq!(run(&mut s, "parameters.list", json!({"favorites": true}))["parameters"].as_array().unwrap().len(), 1);+ let csv = run(&mut s, "parameters.export", json!({}))["text"].as_str().unwrap().to_string();+ assert!(csv.contains("w,mm,15 mm,15,width,true"), "{csv}");+ run(&mut s, "parameters.import", json!({"text": "name,unit,expression,comment\nw,mm,20 mm,wider\nnew_p,mm,\"w + 1\","}));+ assert!(rel(volume(&mut s), 40.0 * 20.0 * 25.4) < 1e-9);+ run(&mut s, "parameters.import", json!({"text": "[{\"name\": \"w\", \"expression\": \"12\"}]"}));+ assert!(rel(volume(&mut s), 24.0 * 12.0 * 25.4) < 1e-9);+ assert!(s.execute("parameters.import", &json!({"text": "name,expression\nw,1/"})).is_err());+ // Saved and reloaded, the names stay.+ let back = solvecraft_doc::Document::from_json(&s.doc.to_json()).unwrap();+ assert_eq!(back.features[0].param_names, s.doc.features[0].param_names);+}