Files
makeCAD/crates/engine/src/cmd/parameters.rs
T
CamWight 866029aaa2 Engine: one sketch store for the sketch commands (W38.0, #5425) (#6336)
* Engine: one sketch store for the sketch commands (W38.0, #5425, no behaviour change)

The sketch commands found and kept the sketch they work on in about forty places, each its own
way. They now go through one module, cmd::sketch_store, so a drawing session (W38a/b) can put
sheet and view sketches behind the same calls without the commands changing again.

- target: the command's `sketch` param or the sketch being edited (target_sketch, moved).
- active: the sketch being edited, if any. The thirteen commands that need one keep their own
  refusal text; unifying the three texts is a separate, visible change.
- read and write: the only calls from the sketch commands to Document::sketch and sketch_mut.
- update: change a sketch on a copy of the document and keep both, the edit the text and link
  commands made by hand (sketch.text, sketch.edit_text, the projection, intersection and
  include links, sketch.fit_curves_to_section, sketch.break_link). As before, those paths
  neither solve the sketch nor run its checks.
- checked: the checks an edited sketch passes (the periodic splines), shared by edit_solved and
  sketch.offset.break.

edit and edit_solved stay in sketch.rs and load and keep their sketch through read and write.
Imported text, snap points and the face projections keep their own shape (a text that can't be
linked is skipped, snap points copy the document only when one is needed) through read and
write. The reads and writes that are about the design's own sketches stay as they are, each on
a line marked `// design-only:` (Redefine Sketch Plane, a joint's curve, a motion trace's wire,
and the session's live drag, parameter edits and `created` diff).

A source scan, each_sketch_command_goes_through_the_store, fails when a command reads or writes
a sketch, or asks for the active one, anywhere but the store or a marked design-only line in the
files that work on the design's sketches. Every existing sketch test is unchanged.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* Engine: the sketch store's scan also catches the active sketch taken as a value (#5425, review of #6336)

The scan only caught `active_sketch.ok_or`, so main's `let Some(id) = s.active_sketch else …`
could have come back unseen (0xlillith's review). It now also flags the value-read forms:
`) = s.active_sketch` (let-else and if let), `=> s.active_sketch` (a match arm),
`s.active_sketch.and_then(` and `s.active_sketch.map(`. State checks (`is_some`, `is_none`,
`== Some(`), assignments and snapshot copies stay allowed.

The wider scan found five commands that hand-rolled the store's `target` rule (a `sketch` param or
the sketch being edited). They now call `sketch_store::target`: sketch.inspect, sketch.glyphs,
sketch.export_dxf, inspect.curvature_comb and inspect.minimum_radius (their `curves` form).
Their refusals become target's:
- no `sketch` and none being edited: "no sketch is being edited" (was "no such sketch (and none
  is active)", or "no such sketch" for sketch.glyphs);
- an unknown name or id: "no sketch `X`" (an unknown id used to reach "that sketch is not
  evaluated");
- a feature that is not a sketch: "`X` is not a sketch";
- a `sketch` that is neither an id nor a name (true, a list, an object): refused,
  where it used to fall back to the sketch being edited. A null `sketch` still means none given
  (the scenario harness sends one): target now reads it that way for every sketch command
  (target_reads_a_null_sketch_as_none_given).
No test, doc or schema text named the old wording; the params docs ("sketch?: id|name (default
active)") still hold.

The two remaining value reads, the default sketch for a feature (features.rs) and the sketch a
measurement prefers (measure_sel.rs), go through `sketch_store::active`, with no change.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* Engine: a number in `sketch` is an exact sketch id, never a name (#5425, review of #6336)

`sketch_store::target` turned a JSON number into text and looked it up with
`Document::find_feature`, which falls back to a name when no feature has that id. So
`{"sketch": 999999}` could pick a sketch named "999999" whose id is something else, and export
or inspect it. sketch.export_dxf, sketch.glyphs and the two curvature inspects read an exact id
before they moved onto the store; the other sketch commands (the old `target_sketch`) and
sketch.inspect read a number as text.

One rule now, for every command that takes `sketch`: a number is an exact id (`as_u64`, then
the feature with that id); text is an id written out or a name, as before. A number that isn't
a whole number of 0 or more (negative, fractional) is refused with "`sketch` must be an id or a
name"; an id no feature has gives "no sketch `N`", as before. Nothing in the tests, docs,
scenarios or examples names a sketch with digits, so nothing relied on the old fallback.

Test (sketch_store): a sketch named "999999" with another id. sketch.export_dxf, sketch.glyphs
(with another sketch being edited, for its enabled check), inspect.curvature_comb and
inspect.minimum_radius (with a real curve id) refuse `{"sketch": 999999}`, find the sketch as
`"999999"` and by its own id, and refuse -1 and 1.5.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* Engine: MidPoint finds its sketch through the store too (#5425, after #5011)

#5011 added a caller of the old `target_sketch` (MidPoint's `line_stays`, which swaps a point
picked after its line) after this branch's base. It now reads the sketch through
`sketch_store::target` and `sketch_store::read`, as the other sketch commands do, so a number
there is an exact id too.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* Engine: standard parts fix their sketch's entities through the store (#5425, after #6376)

#6376 (a standard part's sketches are fully defined) reads the sketch being drawn straight from
the document's features, after this branch's base. `fix_all` now takes it from
`sketch_store::active` and `sketch_store::read`, as the store's scan requires, with the same
result.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* Engine: Toggle Diameter and Delete on a profile find their sketch through the store (#5425)

Two sketch commands landed on main after the store: sketch.toggle_diameter (#7729) still
called the removed sketch::target_sketch, and Delete on a picked profile (#7107) read the
sketch straight from the document. Both now go through sketch_store (target and read), and
the store's source scan passes again.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* Sketch dimensioned: use the sketch store's target after the rebase

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* Sketch dimensioned: read the sketch through the store

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
Co-authored-by: bherbruck <brennen.herbruck@gmail.com>
2026-10-28 20:56:05 +00:00

545 lines
25 KiB
Rust

//! 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 solidcraft_doc::FeatureKind;
use solidcraft_doc::expr::{self, Kind};
use solidcraft_sketch::{Analysis, ConstraintKind, CurveKind, Hold, Sketch, solve_with};
use super::{CommandSpec, sketch_store};
use crate::params::{bad, bool_, str_};
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|\"\"|text (new parameters default to their value's unit; \
a text parameter's expression is its text, quotes round it optional: sketch texts' words are built from it), comment?, \
favorite?: bool, new_name?: rename (references follow; an expression `new = value` renames to `new` and sets value, \
or sets `new` when the expression is just `new`); 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), switched?: [{feature, name, suppressed}] \
(the configuration rules that switch a feature's suppression and read a parameter whose value changed run in their order, as on \
activation; driven parameters and restrictions wait for a configuration edit or activation)",
),
CommandSpec::new("parameters.list", "List Parameters", list).icon("list").noundo().doc_only().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)
.icon("new")
.params("name, expression, unit?: as parameters.change (text: a text parameter, its expression the text), comment?, favorite?: bool"),
CommandSpec::new("parameters.rename", "Rename Parameter", rename)
.icon("rename")
.params("name, new_name (expressions, feature inputs and dimensions that use it follow)"),
CommandSpec::new("parameters.delete", "Delete Parameter", delete)
.icon("delete")
.params("name (refused while something uses it; the error lists the users)"),
CommandSpec::new("parameters.favorite", "Favourite Parameter", favorite).icon("star").params("name, favorite?: bool (default true)"),
CommandSpec::new("parameters.move", "Move Parameter", move_param)
.icon("reorder")
.params("name, before | after: another user parameter; the user parameter is listed just before or after it"),
CommandSpec::new("parameters.comment", "Comment Parameter", comment).icon("text").params("name, comment"),
CommandSpec::new("parameters.users", "Parameter Users", users)
.icon("graph")
.noundo()
.params("name → users (parameters, feature inputs, dimensions) and the features it drives"),
CommandSpec::new("parameters.graph", "Parameter Graph", graph)
.icon("graph")
.noundo()
.params("→ nodes, edges [user, used] (users include Feature:<name>), cycles, errors"),
CommandSpec::new("parameters.export", "Export Parameters", export)
.icon("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)
.icon("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)
.icon("params")
.noundo()
.doc_only()
.params("expression, kind?: length|angle|unitless (or unit?: mm|in|deg…; text: the text a text parameter would hold, as `text`) → ok, value (mm/rad), display_value, references, error"),
CommandSpec::new("parameters.complete", "Complete Expression", complete)
.icon("params")
.noundo()
.doc_only()
.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()
}
pub(super) fn known(s: &Session, name: &str) -> bool {
s.doc.param(name).is_some() || s.doc.text_param(name).is_some() || s.doc.features.iter().any(|f| f.param_names.iter().any(|n| n == name))
}
/// Whether `name` is (or, with this unit, becomes) a text parameter, whose expression is text.
fn is_text(s: &Session, name: &str, unit: Option<&str>) -> bool {
s.doc.text_param(name).is_some() || unit.is_some_and(solidcraft_doc::text_params::is_text_unit)
}
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)?;
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 mut 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"));
};
// `name = expression` names the value being changed (#4071): the parameter (a dimension's
// `d7`, a feature input's) is renamed, references following, and takes the expression. A
// text parameter's text is only text.
if let Some((new, rhs)) = e.as_deref().filter(|_| !is_text(s, &name, str_(p, "unit"))).and_then(expr::definition) {
if out.get("renamed").is_some() {
return Err(bad(cmd, format!("`{new} = …` renames `{name}` already: give `new_name` or `name = expression`, not both")));
}
if rhs.is_empty() {
return Err(bad(cmd, format!("`{new} =` needs a value after the `=`")));
}
let (new, rhs) = (new.to_string(), rhs.to_string());
// A value that is just a parameter's name changes that parameter: a dimension made as
// `w = 20` shows `w`, and `w = 30` typed over it sets `w`.
let refers_to = s.doc.all_param_exprs().into_iter().find(|(n, _, _)| *n == name).map(|(_, e, _)| e);
if refers_to.as_deref().map(str::trim) == Some(new.as_str()) && s.doc.param(&new).is_some() {
out["changed_through"] = json!(name);
name = new.clone();
}
if new != name {
if known(s, &new) {
return Err(bad(cmd, format!("there is already a parameter `{new}`: type `{new}` to use it, or change it in Parameters")));
}
let n = s.doc_mut().rename_param(&name, &new)?;
out["renamed"] = json!({"from": name, "to": new, "references_updated": n});
name = new;
}
e = Some(rhs);
}
let (unit, comment) = (str_(p, "unit"), str_(p, "comment"));
let before = s.doc.param_values().0;
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)?;
}
let switched = switch_by_rules(s, &before);
if e.is_some() {
keep_dimension_start(s, &name);
}
s.settle_value_edit(&solved)?;
let (vals, _) = s.doc.param_values();
if !switched.is_empty() {
out["switched"] = json!(switched);
}
out["name"] = json!(name);
out["expression"] = json!(e);
if let Some(t) = s.doc.text_param(&name) {
out["text"] = json!(t.text);
}
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["restored"] = json!(s.model.last_restored);
out["errors"] = json!(failing(s));
Ok(out)
}
/// The point a length dimension keeps when its value changes: the first it measures from (a
/// line's start). None for other dimensions.
fn dimension_start(sk: &Sketch, kind: &ConstraintKind) -> Option<usize> {
match kind {
ConstraintKind::Distance { p, .. } | ConstraintKind::DistanceX { p, .. } | ConstraintKind::DistanceY { p, .. } => Some(*p),
ConstraintKind::Length { l, .. } => match sk.curves.get(*l)?.kind {
CurveKind::Line { a, .. } => Some(a),
_ => None,
},
_ => None,
}
}
/// A length dimension driven by `name` keeps its first point where it is when the value
/// changes, so a rectangle's side grows from its first corner, not from both ends (#6070). The
/// sketch is solved here with that point held, before the design evaluates from its stored
/// positions. Where holding it can't solve (a symmetry moves both ends), evaluation solves as
/// before.
fn keep_dimension_start(s: &mut Session, name: &str) {
let targets: Vec<(u64, usize)> = s
.doc
.features
.iter()
.filter_map(|f| match &f.kind {
FeatureKind::Sketch { sketch, .. } => sketch
.constraints
.iter()
.find(|c| !c.driven && c.param.as_deref() == Some(name))
.and_then(|c| dimension_start(sketch, &c.kind))
.map(|p| (f.id, p)),
_ => None,
})
.collect();
if targets.is_empty() {
return;
}
let vals = s.doc.evaluation_values();
for (id, start) in targets {
let Ok(stored) = sketch_store::read(&s.doc, id) else { continue };
let mut trial = stored.clone();
if s.doc.apply_dimension_values(&vals, &mut trial).is_err() {
continue;
}
let reference: Vec<_> = stored.points.iter().map(|p| p.pos).collect();
let hold = Hold { points: vec![start], radii: Vec::new() };
if !solve_with(&mut trial, &hold, Some(&reference), Analysis::StatusOnly, None).keeps_orientation() {
continue;
}
if stored.points.len() == trial.points.len() {
// Only the points move: the stored dimensions keep their own values.
let mut kept = stored.clone();
for (p, q) in kept.points.iter_mut().zip(&trial.points) {
p.pos = q.pos;
}
let _ = sketch_store::write(s.doc_mut(), id, kept);
}
}
}
/// `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")))?;
// Renaming is one parameter at a time (#4071).
if let Some((new, _)) = expr::definition(&e).filter(|_| !is_text(s, name.trim(), None)) {
return Err(bad(cmd, format!("`changes.{name}`: `{new} = …` would rename `{name}`; change it on its own to rename it")));
}
list.push((name.trim().to_string(), e));
}
let before = s.doc.param_values().0;
s.doc_mut().change_params_atomic(&list)?;
let switched = switch_by_rules(s, &before);
for (name, _) in &list {
keep_dimension_start(s, name);
}
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();
let mut out = json!({"changed": values, "recomputed": s.model.last_recomputed, "restored": s.model.last_restored, "errors": failing(s)});
if !switched.is_empty() {
out["switched"] = json!(switched);
}
Ok(out)
}
/// The configuration rules that switch a feature's suppression and read a parameter this edit
/// changed (`Document::apply_suppression_rules`), applied before the design is rebuilt, so that
/// one rebuild has them: `[{feature, name, suppressed}]` for each feature they switched.
fn switch_by_rules(s: &mut Session, before: &std::collections::BTreeMap<String, expr::Value>) -> Vec<Value> {
if s.doc.configs.rules.is_empty() {
return Vec::new();
}
let switched = s.doc_mut().apply_suppression_rules(before);
switched
.into_iter()
.map(|(id, suppressed)| {
let name = s.doc.features.iter().find(|f| f.id == id).map(|f| f.name.clone());
json!({"feature": id, "name": name, "suppressed": suppressed})
})
.collect()
}
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<solidcraft_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 = solidcraft_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"))?;
let solved = s.solved_sketches();
s.doc_mut().add_user_param(&name, &e, str_(p, "unit"), str_(p, "comment"))?;
s.settle_value_edit(&solved)?;
if let Some(f) = bool_(p, "favorite") {
s.doc_mut().set_favorite(&name, f)?;
}
let (vals, _) = s.doc.param_values();
if let Some(t) = s.doc.text_param(&name) {
return Ok(json!({"name": name, "unit": solidcraft_doc::text_params::TEXT_UNIT, "text": t.text, "value": null}));
}
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();
let solved = s.solved_sketches();
s.doc_mut().remove_param(&name)?;
s.settle_value_edit(&solved)?;
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 move_param(s: &mut Session, p: &Value) -> Result<Value> {
let cmd = "parameters.move";
let name = param_name(cmd, p)?.to_string();
let (target, after) = match (str_(p, "before"), str_(p, "after")) {
(Some(t), None) => (t.to_string(), false),
(None, Some(t)) => (t.to_string(), true),
_ => return Err(bad(cmd, "give one of `before` or `after`: another user parameter")),
};
s.doc_mut().move_user_param(&name, &target, after)?;
let order: Vec<&str> = s.doc.params.iter().filter(|q| !q.model).map(|q| q.name.as_str()).collect();
Ok(json!({"name": name, "order": order}))
}
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 = solidcraft_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 {
solidcraft_io::vfs::write(path, text.as_bytes()).map_err(|e| EngineError::Other(format!("{path}: {e}")))?;
}
Ok(json!({"format": format, "path": path, "text": text}))
}
/// Largest parameter table we read from a file.
const MAX_PARAMETER_BYTES: usize = 16 << 20;
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)) => {
solidcraft_io::vfs::read_to_string(path, MAX_PARAMETER_BYTES).map_err(|e| EngineError::Other(format!("{path}: {e}")))?
}
_ => return Err(bad(cmd, "give `text` or `path`")),
};
let solved = s.solved_sketches();
let names = s.doc_mut().import_params(&text)?;
s.settle_value_edit(&solved)?;
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");
// A text parameter's expression is its text.
if unit.is_some_and(solidcraft_doc::text_params::is_text_unit) {
return Ok(json!({"ok": true, "kind": "text", "text": solidcraft_doc::text_params::unquote(&e), "references": []}));
}
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(|| solidcraft_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(|| solidcraft_doc::DocError::Expr(format!("the result is {}", v.describe()))),
});
// `name = expression` is worth its expression, and names what it would define (#4071).
let defines = expr::definition(&e).map(|(n, _)| n);
let mut out = 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}),
};
if let Some(name) = defines {
out["defines"] = json!(name);
}
Ok(out)
}
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 lower = word.to_ascii_lowercase();
let starts = |n: &str| word.is_empty() || n.to_ascii_lowercase().starts_with(&lower);
// A parameter matches wherever the word appears in its name (`side` finds
// `cab_side_thickness`, #2757); functions, constants and units match from the start.
let within = |n: &str| word.is_empty() || n.to_ascii_lowercase().contains(&lower);
let mut out: Vec<Value> = Vec::new();
let mut rows: Vec<solidcraft_doc::ParamRow> = s.doc.param_rows().into_iter().filter(|r| within(&r.name)).collect();
// Names that start with the word, then the rest; within each, favourites, then user
// parameters, then the others.
rows.sort_by_key(|r| (!starts(&r.name), !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;