* claim: #10747 * Parameters: value is mm/degrees in every reply; round reported numbers (#10747) --------- Co-authored-by: Dahak Builds <dahakbuilds@users.noreply.github.com>
562 lines
27 KiB
Rust
562 lines
27 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 length the design's units; \
|
|
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 (mm/deg in every \
|
|
reply), display_value (in its own 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", "Favorite 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| expr::round_reported(expr::reported_value(*v))));
|
|
out["display_value"] = json!(s.doc.param_display_value(&vals, &name).map(expr::round_reported));
|
|
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() };
|
|
let solved = if trial.offsets.is_empty() && trial.freeform_offsets.is_empty() {
|
|
solve_with(&mut trial, &hold, Some(&reference), Analysis::StatusOnly, None).keeps_orientation()
|
|
} else {
|
|
// A solve against stale offset points can stretch an attached cap into a different
|
|
// tangency branch. Keep the start through the complete solve/refresh sequence.
|
|
let Some(p) = trial.points.get_mut(start) else { continue };
|
|
p.fixed = true;
|
|
s.doc
|
|
.solve_sketch_with_analysis(&vals, &mut trial, &stored.driving_values(), Some(stored), Analysis::StatusOnly)
|
|
.is_ok_and(|report| report.keeps_orientation())
|
|
};
|
|
if !solved {
|
|
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| expr::round_reported(expr::reported_value(*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| expr::round_reported(expr::reported_value(*v))), "display_value": s.doc.param_display_value(&vals, &name).map(expr::round_reported)}),
|
|
)
|
|
}
|
|
|
|
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")
|
|
// The `value` field keeps the number in the parameter's own unit, as the CSV
|
|
// column does, rounded for reading (#10747).
|
|
.map(|r| json!({"name": r.name, "expression": r.expression, "unit": r.unit, "value": r.display_value.or(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();
|
|
// Bare numbers follow the asked-for unit when given, else the design's length unit (#9015).
|
|
let doc_len = expr::unit_info(s.doc.units.trim()).filter(|(k, _)| *k == Kind::Length).map(|(_, s)| s).unwrap_or(1.0);
|
|
let defaults = expr::Defaults::for_unit(unit.unwrap_or(""), doc_len);
|
|
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": expr::round_reported(v), "kind": k, "display_value": expr::round_reported(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) {
|
|
// The completion shows the parameter's own unit, so it reads `display_value`.
|
|
let v = r.display_value.or(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;
|