Files
solidcraft/crates/engine/src/cmd/component_link.rs
T
jyviko 5d80fc5711 Engine: diagnostics.validation reads and sets the mode
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

With input and output schemas. The mode is the session's user setting:
kept when another design is opened, started, recovered or imported (each
evaluated under it), and by timeline.compute_all. Linked and extracted
designs are evaluated under it too.
2026-10-30 13:52:54 -04:00

811 lines
47 KiB
Rust
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
//! Linked designs: a component whose bodies come from another design file (Insert Design).
//!
//! The linked design is opened and evaluated on its own, and its solid bodies, as placed in it,
//! join a new component through an Import feature (exact B-rep, kept in this design so it opens
//! without the part file). The link remembers the absolute file in a session and a path relative
//! to the design's folder on disk; Update Links reads it again and replaces the Import feature's
//! bodies, and Break Link keeps the bodies and forgets the file. The bodies' faces are named after the names
//! the design gives them (`Feature::link_faces`), so a joint on a linked face stays on that face
//! when the design changes, as it would inside the design, and reports it when the face is gone.
use std::path::Path;
use serde_json::{Value, json};
use solidcraft_doc::{DesignLink, Document, FeatureKind};
use super::CommandSpec;
use super::design_link::{absolute, resolve, stored};
use crate::params::{bad, str_, vec3};
use crate::{EngineError, Result, Session};
#[path = "component_extract.rs"]
mod extract;
#[cfg(test)]
#[path = "component_relink_tests.rs"]
#[allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
mod relink_tests;
pub static COMMANDS: &[CommandSpec] = &[
CommandSpec::new("component.insert_design", "Insert Design", insert_design).at("SOLID", "ASSEMBLE").icon("component").params(
"path: a .solidcraft design → a new component linked to it, holding its solid bodies as placed in that design and a copy of its design properties; \
name? (default: the design's name); parent?: component id or name (default: the active one); translate?: [x,y,z]; \
reuse?: bool (default false): insert a free occurrence, reusing an existing link to the same file when available",
),
CommandSpec::new("component.update_links", "Update Links", update_links).icon("update").params(
"component?: id or name (default: every linked component) — reads the linked designs again and replaces their bodies where they changed; \
→ updated, unchanged, warnings (also joints whose faces are gone or that no longer solve)",
),
CommandSpec::new("component.relink", "Relink Source", relink).icon("update").params(
"component: id or name of a linked component; path: a saved .solidcraft design — replaces the source and linked bodies for all its occurrences, preserving identities and placements; returns path, previous_path, warnings, joint_errors and joint_conflicts",
),
CommandSpec::new("component.break_link", "Break Link", break_link)
.icon("break")
.params("component: id or name of a linked component — keeps its bodies as they are and forgets the design file"),
CommandSpec::new("component.extract", "Extract to File", extract::extract).icon("export").params(
"component: id or name of a component that is not linked; path: the .solidcraft design to write → its history, subcomponents and their joints \
move to that design, and the component becomes linked to it (as component.insert_design makes it); returns path, file, feature, bodies, \
notices (what stays behind), warnings and copies (components that build the same bodies: see component.replace_with_link)",
),
CommandSpec::new("component.copies", "Find Identical Copies", extract::copies).icon("inspect").noundo().params(
"component: id or name of a linked component → copies: [{component, name}], the components not linked whose own history builds the same bodies",
),
CommandSpec::new("component.replace_with_link", "Replace with Link", extract::replace_with_link).icon("chain").params(
"component or components: [ids or names] of components that are not linked; with: a linked component, or path: a .solidcraft design \
(its link here, else a new linked component) → each component's history goes and its placements become placements of the linked \
component; refused when its bodies are not the same as the link's; returns component, name, replaced and warnings",
),
CommandSpec::new("component.links", "List Links", list_links).icon("chain").noundo().params(
"→ linked components: component, name, path, file (resolved), found (null when the file is on a network location not allowed, \
or names a device: it is not looked for), and then host (the network location) and reason",
),
];
/// Why the file a stored link names may not be reached, from its text alone (`None`: it may): a
/// device, or a network location not allowed (`vfs::design_path_refusal`). Both the link as
/// stored and the file it resolves to are judged, before anything asks the disk or the network.
fn link_refusal(design: Option<&str>, link: &str) -> Option<solidcraft_io::vfs::Remote> {
let file = resolve(design, link);
solidcraft_io::vfs::design_path_refusal(link, design).or_else(|| solidcraft_io::vfs::design_path_refusal(&file.to_string_lossy(), design))
}
/// The error for a link [`link_refusal`] refuses.
fn link_refused(design: Option<&str>, link: &str) -> Result<()> {
solidcraft_io::vfs::check_design_path(link, design).map_err(|e| EngineError::Other(e.to_string()))?;
let file = resolve(design, link);
solidcraft_io::vfs::check_design_path(&file.to_string_lossy(), design).map_err(|e| EngineError::Other(e.to_string()))
}
/// Resolve a design's component links against its original file, before opening it from a
/// different location (for example a recovery file) or keeping it in session history.
pub fn resolve_design_links(doc: &mut Document, from: Option<&str>) {
for link in doc.links.values_mut() {
link.path = absolute(&resolve(from, &link.path)).to_string_lossy().into_owned();
}
}
/// The bodies of a linked design: its name, the Import feature that holds them and the names
/// the design gives their faces (`Feature::link_faces`), with the source's design properties.
type Linked = (String, solidcraft_io::StepFeature, Vec<Vec<String>>, solidcraft_doc::Metadata);
/// The solid bodies of the design at `file`, evaluated under `validation`, as an Import feature.
fn linked_bodies(file: &Path, own: Option<&str>, validation: solidcraft_kernel::Validation) -> Result<Linked> {
let shown = file.display().to_string();
if own.is_some_and(|o| absolute(Path::new(o)) == absolute(file)) {
return Err(EngineError::Other(format!("{shown}: a design can't be linked into itself")));
}
// A network location only when its server is allowed, a device never: judged from the text
// before anything is read (on Windows, reading `\\host\share\x` connects to the host).
let bytes = solidcraft_io::vfs::read_design_path(&shown, own, solidcraft_io::MAX_DESIGN_BYTES).map_err(|e| {
let e = e.to_string();
EngineError::Other(if e.starts_with(&shown) { e } else { format!("{shown}: {e}") })
})?;
let doc = solidcraft_io::read_design(&bytes).map_err(|e| EngineError::Other(format!("{shown}: {e}")))?;
session_bodies(&Session::opened_at_validating(doc, None, Some(&shown), validation), &shown)
}
/// The solid bodies of `part`, the design saved as `shown`, as an Import feature.
fn session_bodies(part: &Session, shown: &str) -> Result<Linked> {
let name = part.doc.name.clone();
if let Some(e) = part.model.results.iter().find_map(|r| r.error.clone()) {
return Err(EngineError::Other(format!("{shown}: the design has a feature that fails ({e}); fix it before linking it")));
}
let world = part.world_state()?;
let solids: Vec<String> = world.bodies.iter().filter(|b| !b.body.is_mesh()).map(|b| b.name.clone()).collect();
if solids.is_empty() {
return Err(EngineError::Other(format!("{shown}: the design has no solid bodies to link")));
}
let step = solidcraft_io::export(&part.doc.painted(&world), &solids, solidcraft_io::Format::Step, &name)
.map_err(|e| EngineError::Other(format!("{shown}: {e}")))?;
let mut feature = solidcraft_io::step_import_feature(&step, shown).map_err(|e| EngineError::Other(format!("{shown}: {e}")))?;
if world.bodies.len() > solids.len() {
feature.warnings.push(format!("{} mesh bodies of {shown} are not linked", world.bodies.len() - solids.len()));
}
// The STEP text keeps no face names: carry the design's own, so references into the linked
// bodies follow them as they do inside the design (#3330).
let faces = solidcraft_doc::naming::carried_face_names(&world, &feature.import.bodies);
Ok((name, feature, faces, part.doc.metadata.clone()))
}
fn component_key(s: &Session, p: &Value, key: &str, cmd: &str) -> Result<u64> {
let k = match p.get(key) {
Some(Value::Number(n)) => n.to_string(),
Some(Value::String(x)) => x.clone(),
_ => return Err(bad(cmd, format!("`{key}` must be a component id or name"))),
};
s.doc.find_component(&k).ok_or_else(|| bad(cmd, format!("no component `{k}`")))
}
fn insert_design(s: &mut Session, p: &Value) -> Result<Value> {
let cmd = "component.insert_design";
let given = str_(p, "path").filter(|x| !x.trim().is_empty() && x.len() < 4096).ok_or_else(|| bad(cmd, "`path` is required"))?;
let translate = match p.get("translate") {
None => solidcraft_geom::Vec3::ZERO,
Some(v) => vec3(v).filter(|t| t.is_finite() && t.len() < 1e9).ok_or_else(|| bad(cmd, "`translate` must be [x, y, z] in mm"))?,
};
// A network or device path is judged from its text, as given, before anything reads it.
link_refused(s.path.as_deref(), given).map_err(|e| bad(cmd, e.to_string()))?;
let file = absolute(Path::new(given));
if s.path.as_deref().is_some_and(|own| absolute(Path::new(own)) == file) {
return Err(bad(cmd, "a design can't be linked into itself"));
}
if p.get("reuse").and_then(Value::as_bool).unwrap_or(false) {
let existing = s.doc.links.iter().find(|(_, link)| absolute(&resolve(s.path.as_deref(), &link.path)) == file).map(|(id, _)| *id);
if let Some(component) = existing {
let parent = p.get("parent").cloned().unwrap_or_else(|| json!(s.active_component));
return super::component::copy_occurrence(s, &json!({"component": component, "parent": parent, "translate": translate}));
}
}
let (design_name, sf, faces, metadata) = linked_bodies(&file, s.path.as_deref(), s.validation())?;
let name = str_(p, "name").filter(|n| !n.trim().is_empty()).map(str::to_string).unwrap_or(design_name);
let mut create = json!({"name": name, "activate": false});
// Clipboard insertion uses reuse even for the first paste, which must stay movable.
if p.get("reuse").and_then(Value::as_bool).unwrap_or(false) {
create["grounded"] = json!(false);
}
if let Some(parent) = p.get("parent") {
create["parent"] = parent.clone();
}
let made = super::component::new_component(s, &create)?;
let comp = made["component"].as_u64().ok_or_else(|| bad(cmd, "the component was not created"))?;
let occ = made["occurrence"].as_u64();
// Seed only a new definition: reused links keep any locally edited part properties.
if let Some(c) = s.doc_mut().components.iter_mut().find(|c| c.id == comp) {
c.metadata = metadata;
}
let id = s.doc_mut().add_feature(sf.kind, Some(&name))?;
if let Some(f) = s.doc_mut().feature_mut(id) {
f.component = comp;
f.body_names = sf.body_names;
f.link_faces = faces;
}
if let Some(o) = s.doc_mut().occurrences.iter_mut().find(|o| Some(o.id) == occ) {
o.transform[3] = [translate.x, translate.y, translate.z, 1.0];
}
let path = stored(s.path.as_deref(), &file);
s.doc_mut().links.insert(comp, DesignLink { path: file.to_string_lossy().into_owned(), feature: id });
s.refresh();
if let Some(e) = s.model.result(id).and_then(|r| r.error.clone()) {
return Err(EngineError::Other(e));
}
let st = s.model.state();
let bodies: Vec<&str> = st.bodies.iter().filter(|b| b.feature == id).map(|b| b.name.as_str()).collect();
Ok(
json!({"component": comp, "occurrence": occ, "name": name, "feature": id, "path": path, "bodies": bodies, "created_bodies": bodies, "warnings": sf.warnings}),
)
}
fn update_links(s: &mut Session, p: &Value) -> Result<Value> {
let cmd = "component.update_links";
let only = if p.get("component").is_some() { Some(component_key(s, p, "component", cmd)?) } else { None };
if let Some(c) = only
&& !s.doc.links.contains_key(&c)
{
return Err(bad(cmd, "that component is not linked to a design"));
}
let links: Vec<(u64, DesignLink)> = s.doc.links.iter().filter(|(c, _)| only.is_none_or(|o| o == **c)).map(|(c, l)| (*c, l.clone())).collect();
let (mut updated, mut unchanged, mut warnings) = (Vec::new(), Vec::new(), Vec::new());
let count = links.len();
for (index, (comp, link)) in links.into_iter().enumerate() {
let cname = s.doc.components.iter().find(|c| c.id == comp).map(|c| c.name.clone());
let Some(cname) = cname else {
// The component was deleted: the link goes with it.
s.doc_mut().links.remove(&comp);
continue;
};
// A window running this off its thread names the design being read again (#5329).
solidcraft_doc::progress::item(Some((&cname, index, count)));
let Some(FeatureKind::Import { step: old, .. }) = s.doc.feature(link.feature).filter(|f| f.component == comp).map(|f| &f.kind) else {
return Err(bad(
cmd,
format!("{cname}: its linked bodies (feature {}) are gone; break the link or insert the design again", link.feature),
));
};
let old = old.clone();
link_refused(s.path.as_deref(), &link.path).map_err(|e| bad(cmd, format!("{cname}: {e}")))?;
let file = resolve(s.path.as_deref(), &link.path);
let (_, sf, faces, _) = linked_bodies(&file, s.path.as_deref(), s.validation()).map_err(|e| bad(cmd, format!("{cname}: {e}")))?;
warnings.extend(sf.warnings.iter().cloned());
let same = matches!(&sf.kind, FeatureKind::Import { step, .. } if *step == old);
let kept = s.doc.feature(link.feature).map(|f| &f.link_faces);
if same && kept == Some(&faces) {
unchanged.push(cname);
continue;
}
// The same bodies, their faces named for the first time (a link made before names were
// kept): nothing a reference finds changes. Names the design gave other faces since do.
let changed = !same || kept.is_some_and(|k| !k.is_empty());
if !same {
for name in numbered_references(s, comp, link.feature) {
warnings.push(format!(
"{name} refers to faces of {cname} by their place in the linked file, which this update can change: check it, and pick its faces again so it follows them by name"
));
}
}
if let Some(f) = s.doc_mut().feature_mut(link.feature) {
if !same {
// Bodies keep their names where the design still has as many.
if f.body_names.len() != sf.body_names.len() {
f.body_names = sf.body_names;
}
f.kind = sf.kind;
}
// A link made before the design's face names were kept gets them here.
f.link_faces = faces;
}
if changed { updated.push(cname) } else { unchanged.push(cname) }
}
solidcraft_doc::progress::item(None);
s.refresh();
if let Some(e) = s.doc.links.values().find_map(|l| s.model.result(l.feature).and_then(|r| r.error.clone())) {
return Err(EngineError::Other(e));
}
// A reference whose face the design no longer has says so here, not only in the joint list.
if !updated.is_empty() {
let sol = solidcraft_doc::joints::solve(&s.doc, &s.model.state());
warnings.extend(sol.errors.iter().chain(&sol.conflicts).map(|(_, name, why)| format!("joint {name}: {why}")));
}
Ok(json!({"updated": updated, "unchanged": unchanged, "warnings": warnings}))
}
/// The joints and joint origins on occurrences of `comp` that name its linked faces by their
/// place in the file (`F<feature>:face:<k>`, made before the design's own names were kept), which
/// an update can give to another face.
fn numbered_references(s: &Session, comp: u64, feature: u64) -> Vec<String> {
let numbered = format!("F{feature}:face:");
let on = |o: &solidcraft_doc::joints::JointOrigin| {
s.doc.occurrences.iter().any(|x| x.id == o.occurrence && x.component == comp)
&& o.snap.face_names().iter().any(|n| n.trim_start_matches(solidcraft_doc::naming::LEGACY_MARK).starts_with(&numbered))
};
let joints = s.doc.assembly.joints.iter().filter(|j| on(&j.a) || on(&j.b)).map(|j| format!("joint {}", j.name));
let origins = s.doc.assembly.origins.iter().filter(|o| on(&o.origin)).map(|o| format!("joint origin {}", o.name));
joints.chain(origins).collect()
}
fn relink(s: &mut Session, p: &Value) -> Result<Value> {
let cmd = "component.relink";
let comp = component_key(s, p, "component", cmd)?;
let link = s.doc.links.get(&comp).cloned().ok_or_else(|| bad(cmd, "that component is not linked to a design"))?;
if !matches!(s.doc.feature(link.feature), Some(f) if f.component == comp && matches!(f.kind, FeatureKind::Import { .. })) {
return Err(bad(cmd, "the linked bodies are gone; break the link or insert the design again"));
}
let given = str_(p, "path").filter(|x| !x.trim().is_empty() && x.len() < 4096).ok_or_else(|| bad(cmd, "`path` is required"))?;
let file = absolute(Path::new(given));
if !file.extension().and_then(|e| e.to_str()).is_some_and(|e| e.eq_ignore_ascii_case("solidcraft")) {
return Err(bad(cmd, "choose a saved .solidcraft design"));
}
// A network or device path is judged from its text before the disk is asked anything.
link_refused(s.path.as_deref(), given).map_err(|e| bad(cmd, e.to_string()))?;
// The ordinary lexical check in linked_bodies also works in the browser VFS. On native
// hosts, reject an alias of this assembly too (a symlink or a path with different case).
if let (Ok(candidate), Some(Ok(own))) = (file.canonicalize(), s.path.as_deref().map(std::fs::canonicalize))
&& candidate == own
{
return Err(bad(cmd, "a design can't be linked into itself"));
}
// Read/evaluate the candidate before changing anything. Session::execute owns the single
// undo step and restores both the document and evaluated state on any later failure.
let (_, sf, faces, _) = linked_bodies(&file, s.path.as_deref(), s.validation()).map_err(|e| bad(cmd, e.to_string()))?;
let geometry_changed = match (s.doc.feature(link.feature).map(|f| &f.kind), &sf.kind) {
(Some(FeatureKind::Import { step: old, .. }), FeatureKind::Import { step, .. }) => old != step,
_ => true,
};
let path = stored(s.path.as_deref(), &file);
let mut warnings = sf.warnings;
if geometry_changed
&& s.doc
.assembly
.joints
.iter()
.any(|j| s.doc.occurrences.iter().any(|o| o.component == comp && (j.a.occurrence == o.id || j.b.occurrence == o.id)))
{
warnings.push("the linked geometry changed; check this component's joints, even when the solver reports no error".to_string());
}
if let Some(f) = s.doc_mut().feature_mut(link.feature) {
if f.body_names.len() != sf.body_names.len() {
f.body_names = sf.body_names;
}
f.kind = sf.kind;
f.link_faces = faces;
}
s.doc_mut().links.insert(comp, DesignLink { path: file.to_string_lossy().into_owned(), feature: link.feature });
s.refresh();
if let Some(error) = s.model.result(link.feature).and_then(|r| r.error.clone()) {
return Err(bad(cmd, error));
}
// Report the solver's diagnostics. A resolved joint can still describe the wrong
// connection after a source edit; the reminder above does not depend on solve errors.
let sol = solidcraft_doc::joints::solve(&s.doc, &s.model.state());
let diagnostics =
|rows: &[(u64, String, String)]| rows.iter().map(|(id, name, why)| json!({"joint": id, "name": name, "why": why})).collect::<Vec<_>>();
for (_, name, why) in sol.errors.iter().chain(&sol.conflicts) {
warnings.push(format!("joint {name}: {why}"));
}
let previous_path = stored(s.path.as_deref(), &resolve(s.path.as_deref(), &link.path));
Ok(json!({"component": comp, "feature": link.feature, "path": path, "previous_path": previous_path, "geometry_changed": geometry_changed,
"warnings": warnings, "joint_errors": diagnostics(&sol.errors), "joint_conflicts": diagnostics(&sol.conflicts)}))
}
fn break_link(s: &mut Session, p: &Value) -> Result<Value> {
let cmd = "component.break_link";
let comp = component_key(s, p, "component", cmd)?;
let link = s.doc_mut().links.remove(&comp).ok_or_else(|| bad(cmd, "that component is not linked to a design"))?;
Ok(json!({"component": comp, "path": stored(s.path.as_deref(), &resolve(s.path.as_deref(), &link.path))}))
}
fn list_links(s: &mut Session, _p: &Value) -> Result<Value> {
let links: Vec<Value> = s
.doc
.links
.iter()
.map(|(c, l)| {
let file = resolve(s.path.as_deref(), &l.path);
let name = s.doc.components.iter().find(|x| x.id == *c).map(|x| x.name.clone());
let path = stored(s.path.as_deref(), &file);
let file = file.to_string_lossy();
// A refused path is not looked for at all: on Windows asking whether a file on
// `\\host\share` exists already connects to the host.
match link_refusal(s.path.as_deref(), &l.path) {
None => json!({"component": c, "name": name, "path": path, "file": file,
"found": solidcraft_io::vfs::design_path_is_file(&file, s.path.as_deref())}),
Some(solidcraft_io::vfs::Remote::Network(host)) => json!({"component": c, "name": name, "path": path, "file": file,
"found": null, "host": host, "reason": format!("on the network location \\\\{host}, which is not allowed")}),
Some(solidcraft_io::vfs::Remote::Device) => json!({"component": c, "name": name, "path": path, "file": file,
"found": null, "reason": "names a device, not a file"}),
}
})
.collect();
Ok(json!({"links": links}))
}
#[cfg(test)]
#[allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
mod tests {
use super::*;
fn run(s: &mut Session, id: &str, p: Value) -> Value {
s.execute(id, &p).unwrap_or_else(|e| panic!("{id} {p}: {e}"))
}
fn save_box(path: &Path, height: f64) {
let mut part = Session::default();
run(&mut part, "solid.box", json!({"length": 10, "width": 20, "height": height, "body_name": "Plate"}));
run(&mut part, "file.save", json!({"path": path}));
}
fn volume(s: &mut Session) -> f64 {
run(s, "inspect.measure", json!({}))["total"]["volume_mm3"].as_f64().unwrap_or(f64::NAN)
}
/// #6860: Save As changes the file's folder, not the targets kept in the edit history.
#[test]
fn save_as_keeps_link_targets_through_undo_redo_and_checkpoints() {
for on_copy in [false, true] {
let dir = std::env::temp_dir().join(format!("solidcraft-link-save-as-{}-{on_copy}", std::process::id()));
std::fs::create_dir_all(dir.join("parts")).unwrap();
std::fs::create_dir_all(dir.join("asm/sub/deeper")).unwrap();
let part = dir.join("parts/plate.solidcraft");
let case = dir.join("asm/case.solidcraft");
save_box(&part, 30.0);
let mut s = Session::default();
run(&mut s, "component.insert_design", json!({"path": part}));
run(&mut s, "file.save", json!({"path": case}));
// Opening starts from the relative paths actually written to disk.
run(&mut s, "doc.open", json!({"path": case}));
run(&mut s, "solid.box", json!({"length": 5, "width": 5, "height": 5, "corner": [60, 0, 0]}));
let checkpoint = s.checkpoint();
run(&mut s, "solid.box", json!({"length": 5, "width": 5, "height": 5, "corner": [80, 0, 0]}));
run(&mut s, "edit.undo", json!({}));
let before = s.doc.clone();
let undo_before = s.undo.last().unwrap().doc.clone();
let missing = dir.join("missing/case.solidcraft");
assert!(s.execute("file.save_as", &json!({"path": missing})).is_err());
assert_eq!(s.path.as_deref(), case.to_str());
for folder in ["asm/sub", "asm/sub/deeper"] {
let path = dir.join(folder).join("case.solidcraft");
if on_copy {
let mut copy = s.scratch();
run(&mut copy, "file.save_as", json!({"path": path}));
s.adopt_save(&copy);
} else {
run(&mut s, "file.save_as", json!({"path": path}));
}
assert!(!s.is_dirty());
for command in ["edit.redo", "edit.undo", "edit.undo", "edit.redo"] {
run(&mut s, command, json!({}));
let links = run(&mut s, "component.links", json!({}));
assert_eq!(links["links"][0]["found"], true, "{on_copy}, {folder}, {command}: {links}");
assert_eq!(absolute(Path::new(links["links"][0]["file"].as_str().unwrap())), absolute(&part));
}
}
assert!(std::sync::Arc::ptr_eq(&s.doc, &before), "saving does not rewrite the live document");
assert!(std::sync::Arc::ptr_eq(&s.undo.last().unwrap().doc, &undo_before), "saving does not copy the edit history");
s.restore_checkpoint(checkpoint).unwrap();
assert_eq!(run(&mut s, "component.links", json!({}))["links"][0]["found"], true);
let path = s.path.clone().unwrap();
for format in ["json", "container"] {
run(&mut s, "file.save", json!({"format": format}));
let disk = solidcraft_io::read_design(&std::fs::read(&path).unwrap()).unwrap();
assert_eq!(disk.links.values().next().unwrap().path, "../../../parts/plate.solidcraft");
run(&mut s, "doc.open", json!({"path": path}));
assert!(!s.is_dirty());
assert_eq!(run(&mut s, "component.links", json!({}))["links"][0]["found"], true);
}
save_box(&part, 45.0);
assert_eq!(run(&mut s, "component.update_links", json!({}))["updated"], json!(["plate"]));
assert!((volume(&mut s) - 9125.0).abs() < 1e-6);
let _ = std::fs::remove_dir_all(&dir);
}
}
#[test]
fn recovered_relative_links_keep_their_targets_after_save_as() {
let dir = std::env::temp_dir().join(format!("solidcraft-link-recovery-{}", std::process::id()));
std::fs::create_dir_all(dir.join("parts")).unwrap();
std::fs::create_dir_all(dir.join("asm/sub")).unwrap();
let part = dir.join("parts/plate.solidcraft");
save_box(&part, 30.0);
let mut s = Session::default();
run(&mut s, "component.insert_design", json!({"path": part}));
run(&mut s, "file.save", json!({"path": dir.join("asm/case.solidcraft")}));
run(&mut s, "solid.box", json!({"length": 5, "width": 5, "height": 5, "corner": [60, 0, 0]}));
let recovery = dir.join("recovery");
let mut autosaver = crate::recovery::Autosaver::new(&recovery, std::time::Duration::ZERO).unwrap();
assert!(autosaver.save(&s).unwrap());
drop(autosaver);
let entry = crate::recovery::orphans(&recovery).pop().unwrap();
// Older autosaves hold paths relative to the design, not the recovery folder.
std::fs::write(recovery.join(format!("{}.solidcraft", entry.id)), solidcraft_io::write_design(&s.design())).unwrap();
let mut recovered = Session::default();
run(&mut recovered, "doc.recover", json!({"dir": recovery, "id": entry.id}));
assert_eq!(run(&mut recovered, "component.links", json!({}))["links"][0]["found"], true);
run(&mut recovered, "solid.box", json!({"length": 5, "width": 5, "height": 5, "corner": [80, 0, 0]}));
run(&mut recovered, "file.save_as", json!({"path": dir.join("asm/sub/case.solidcraft")}));
run(&mut recovered, "edit.undo", json!({}));
assert_eq!(run(&mut recovered, "component.links", json!({}))["links"][0]["found"], true);
let _ = std::fs::remove_dir_all(&dir);
}
#[test]
fn a_saved_assembly_reopens_with_its_link_updates_it_and_breaks_it() {
let dir = std::env::temp_dir().join(format!("solidcraft-link-reopen-{}", std::process::id()));
std::fs::create_dir_all(dir.join("parts")).unwrap();
std::fs::create_dir_all(dir.join("asm")).unwrap();
let part = dir.join("parts").join("plate.solidcraft");
let case = dir.join("asm").join("case.solidcraft");
save_box(&part, 30.0);
// Given an assembly holding the part, saved in a folder beside the part's.
let mut a = Session::default();
let inserted = run(&mut a, "component.insert_design", json!({"path": part}));
assert_eq!(inserted["name"], "plate");
run(&mut a, "file.save", json!({"path": case}));
assert!((volume(&mut a) - 6000.0).abs() < 1e-6);
// When it is opened again, the link is kept relative to it and finds the part.
let mut b = Session::default();
run(&mut b, "doc.open", json!({"path": case}));
let links = run(&mut b, "component.links", json!({}));
assert_eq!(links["links"][0]["path"], "../parts/plate.solidcraft", "{links}");
assert_eq!(links["links"][0]["found"], true, "{links}");
assert!((volume(&mut b) - 6000.0).abs() < 1e-6);
// An unchanged part leaves the assembly as it is; an edited one comes in on update.
assert_eq!(run(&mut b, "component.update_links", json!({}))["unchanged"], json!(["plate"]));
save_box(&part, 45.0);
assert_eq!(run(&mut b, "component.update_links", json!({}))["updated"], json!(["plate"]));
assert!((volume(&mut b) - 9000.0).abs() < 1e-6, "{}", volume(&mut b));
// A part file that has gone is reported, and the assembly keeps the bodies it had.
std::fs::remove_file(&part).unwrap();
let err = b.execute("component.update_links", &json!({})).unwrap_err().to_string();
assert!(err.contains("plate"), "{err}");
assert!((volume(&mut b) - 9000.0).abs() < 1e-6);
// Break Link keeps the bodies and forgets the file.
run(&mut b, "component.break_link", json!({"component": "plate"}));
assert_eq!(run(&mut b, "component.links", json!({}))["links"], json!([]));
assert!((volume(&mut b) - 9000.0).abs() < 1e-6);
assert!(b.execute("component.update_links", &json!({"component": "plate"})).is_err());
let _ = std::fs::remove_dir_all(&dir);
}
#[test]
fn inserting_a_missing_file_or_bad_parameters_changes_nothing() {
let mut s = Session::default();
let missing = std::env::temp_dir().join(format!("solidcraft-no-such-part-{}.solidcraft", std::process::id()));
assert!(s.execute("component.insert_design", &json!({"path": missing})).is_err());
assert!(s.execute("component.insert_design", &json!({})).is_err());
assert!(s.execute("component.insert_design", &json!({"path": "x.solidcraft", "translate": [1, "a", 2]})).is_err());
assert!(s.doc.components.is_empty() && s.doc.links.is_empty() && s.doc.features.is_empty());
}
/// #3330's part: a plate 60 × 40 × 5 with a Ø 6 hole at x = `hx` (10 mm), saved at `path`. The
/// session stays open to edit the part as a user would.
fn plate(path: &Path) -> Session {
let mut part = Session::default();
run(&mut part, "parameters.add", json!({"name": "hx", "expression": "10 mm"}));
run(&mut part, "solid.box", json!({"length": 60, "width": 40, "height": 5, "corner": [-30, -20, 0], "body_name": "Plate"}));
run(&mut part, "solid.cylinder", json!({"diameter": 6, "height": 7, "base": ["hx", 0, -1], "operation": "cut", "name": "Hole"}));
run(&mut part, "file.save", json!({"path": path}));
part
}
/// Another Ø 6 hole through the plate at `x`.
fn hole(part: &mut Session, x: f64, name: &str) {
run(part, "solid.cylinder", json!({"diameter": 6, "height": 7, "base": [x, 0, -1], "operation": "cut", "name": name}));
}
/// #3330's assembly: the plate linked in and grounded, and a pin rigidly jointed to the top edge
/// of its hole. `older`: the link keeps no face names, as one made before them.
fn pinned(path: &Path, older: bool) -> Session {
let mut s = Session::default();
let feature = run(&mut s, "component.insert_design", json!({"path": path, "name": "Plate"}))["feature"].as_u64().unwrap();
if older {
s.doc_mut().feature_mut(feature).unwrap().link_faces.clear();
s.refresh();
}
run(&mut s, "occurrence.ground", json!({"occurrence": "Plate:1", "grounded": true}));
run(&mut s, "solid.cylinder", json!({"diameter": 6, "height": 20, "base": [0, 50, 0], "operation": "new", "body_name": "PinBody"}));
run(&mut s, "component.create", json!({"name": "Pin", "parent": "root", "activate": false}));
run(&mut s, "component.move_bodies", json!({"bodies": ["PinBody"], "component": "Pin"}));
let joint = json!({"type": "rigid", "name": "PinInHole", "flip": true,
"a": {"occurrence": "Plate:1", "circle": [13, 0, 5]}, "b": {"occurrence": "Pin:1", "circle": [3, 50, 0]}});
run(&mut s, "joint.create", joint);
s
}
/// Asserts the pin's joint sits on the plate's top at x (world) and solves without errors.
fn assert_joint_at(s: &mut Session, x: f64, case: &str) {
let list = run(s, "joint.list", json!({}));
assert_eq!(list["errors"], json!([]), "{case}: {list}");
let o = &list["joints"][0]["frame_a"]["origin"];
let at = [0, 1, 2].map(|i| o[i].as_f64().unwrap_or(f64::NAN));
assert!((at[0] - x).abs() < 1e-6 && at[1].abs() < 1e-6 && (at[2] - 5.0).abs() < 1e-6, "{case}: the joint is at {at:?}, not x = {x}");
}
/// #3330: a joint on a linked part's hole stays on that hole when Update Links brings in an
/// edit of the part, as it does inside one design, also when the edit adds a hole of the same
/// size that takes the first one's place in the file.
#[test]
fn joints_on_a_linked_part_follow_its_faces_through_update_links() {
let dir = std::env::temp_dir().join(format!("solidcraft-link-names-{}", std::process::id()));
std::fs::create_dir_all(&dir).unwrap();
let path = dir.join("plate.solidcraft");
let hx = |part: &mut Session, x: &str| {
run(part, "parameters.change", json!({"name": "hx", "expression": x}));
};
let edits: [(&str, &dyn Fn(&mut Session), f64); 3] = [
("the hole moved to x = 20", &|p: &mut Session| hx(p, "20 mm"), 20.0),
(
"a hole at x = -10 added before it in the timeline, and the hole moved to x = 20",
&|p: &mut Session| {
run(p, "timeline.rollback", json!({"position": 1}));
hole(p, -10.0, "Hole0");
run(p, "timeline.rollback", json!({}));
hx(p, "20 mm");
},
20.0,
),
(
"the hole moved to x = 5, and a hole added at x = 15",
&|p: &mut Session| {
hx(p, "5 mm");
hole(p, 15.0, "Hole2");
},
5.0,
),
];
for (case, edit, x) in edits {
let mut part = plate(&path);
let mut s = pinned(&path, false);
assert_joint_at(&mut s, 10.0, case);
edit(&mut part);
run(&mut part, "file.save", json!({}));
let update = run(&mut s, "component.update_links", json!({}));
assert_eq!(update["updated"], json!(["Plate"]), "{case}: {update}");
assert_eq!(update["warnings"], json!([]), "{case}: {update}");
assert_joint_at(&mut s, x, case);
}
let _ = std::fs::remove_dir_all(&dir);
}
/// #3330: when the part no longer has the face a joint is on, Update Links and the joint list
/// say so instead of moving the joint to another hole of the same size.
#[test]
fn a_joint_whose_linked_face_is_gone_is_reported_not_moved() {
let dir = std::env::temp_dir().join(format!("solidcraft-link-gone-{}", std::process::id()));
std::fs::create_dir_all(&dir).unwrap();
let path = dir.join("plate.solidcraft");
let mut part = plate(&path);
let mut s = pinned(&path, false);
hole(&mut part, -10.0, "Hole0");
run(&mut part, "timeline.delete", json!({"feature": "Hole"}));
run(&mut part, "file.save", json!({}));
let update = run(&mut s, "component.update_links", json!({}));
let warnings = update["warnings"].to_string();
assert!(warnings.contains("joint PinInHole") && warnings.contains("no longer exists"), "{update}");
let list = run(&mut s, "joint.list", json!({}));
assert_eq!(list["errors"][0]["name"], "PinInHole", "{list}");
assert!(list["joints"][0]["frame_a"].is_null(), "{list}");
let _ = std::fs::remove_dir_all(&dir);
}
/// Two arms jointed top face to bottom face, both occurrences of one linked arm design: when
/// the arm is made thicker, its holes moved or it is made longer, Update Links brings the
/// change in and every joint type re-solves onto the moved faces, edges and corners, as it
/// does inside one design (`jointed_arms_stay_together_as_the_arm_changes`).
#[test]
fn jointed_linked_arms_stay_together_through_update_links() {
use crate::cmd::joints::face_tests::{ARM_EDITS, ARM_FORMS, arm_pairs, arm_part, arm_size, arms_apart, joint_arms};
let dir = std::env::temp_dir().join(format!("solidcraft-link-arms-{}", std::process::id()));
std::fs::create_dir_all(&dir).unwrap();
let path = dir.join("arm.solidcraft");
let mut apart = Vec::new();
for form in ARM_FORMS {
let mut part = Session::default();
arm_part(&mut part);
run(&mut part, "file.save", json!({"path": path}));
let mut s = Session::default();
let first = run(&mut s, "component.insert_design", json!({"path": path, "name": "Arm"}))["occurrence"].as_u64().unwrap();
let pairs = arm_pairs(&mut s, first);
joint_arms(&mut s, form, &pairs);
apart.extend(arms_apart(&mut s, "as made", form, &pairs, arm_size(&[])));
for (i, (name, value)) in ARM_EDITS.into_iter().enumerate() {
run(&mut part, "parameters.change", json!({"name": name, "expression": format!("{value} mm")}));
run(&mut part, "file.save", json!({}));
let update = run(&mut s, "component.update_links", json!({}));
assert_eq!(update["updated"], json!(["Arm"]), "{form} {name}: {update}");
assert_eq!(update["warnings"], json!([]), "{form} {name}: {update}");
apart.extend(arms_apart(&mut s, &format!("{name} = {value}"), form, &pairs, arm_size(&ARM_EDITS[..=i])));
}
}
let _ = std::fs::remove_dir_all(&dir);
assert!(apart.is_empty(), "{} joints apart:\n{}", apart.len(), apart.join("\n"));
}
/// A joint made on a link that kept no face names (an older design) names the faces by their
/// place in the file: Update Links says it can't vouch for it, and keeps the names from then on.
#[test]
fn update_links_warns_about_joints_on_faces_named_by_their_place() {
let dir = std::env::temp_dir().join(format!("solidcraft-link-numbered-{}", std::process::id()));
std::fs::create_dir_all(&dir).unwrap();
let path = dir.join("plate.solidcraft");
let mut part = plate(&path);
let mut s = pinned(&path, true);
let feature = s.doc.links.values().next().unwrap().feature;
assert!(s.doc.feature(feature).unwrap().link_faces.is_empty());
// An unchanged part keeps the bodies; the names come in quietly.
assert_eq!(run(&mut s, "component.update_links", json!({}))["unchanged"], json!(["Plate"]));
assert!(!s.doc.feature(feature).unwrap().link_faces.is_empty());
run(&mut part, "parameters.change", json!({"name": "hx", "expression": "20 mm"}));
run(&mut part, "file.save", json!({}));
let update = run(&mut s, "component.update_links", json!({}));
assert!(update["warnings"].to_string().contains("joint PinInHole refers to faces of Plate by their place"), "{update}");
let _ = std::fs::remove_dir_all(&dir);
}
/// A design someone sends may name a linked file on another computer (`\\host\share\…`) or a
/// device. On Windows, reading it or only asking whether it exists connects to that computer
/// and may send it the user's sign-in. Update Links and List Links judge the stored path from
/// its text and touch nothing: List Links reports it unknown with a reason, Update Links
/// refuses with the server's name, and nothing in the design changes.
#[test]
fn links_to_network_locations_or_devices_touch_nothing_until_allowed() {
let dir = std::env::temp_dir().join(format!("solidcraft-link-network-{}", std::process::id()));
let _ = std::fs::remove_dir_all(&dir);
std::fs::create_dir_all(dir.join("parts")).unwrap();
let part = dir.join("parts").join("plate.solidcraft");
save_box(&part, 30.0);
let case = dir.join("case.solidcraft");
let mut a = Session::default();
let comp = run(&mut a, "component.insert_design", json!({"path": part}))["component"].as_u64().unwrap();
run(&mut a, "file.save", json!({"path": case}));
let feature = a.doc.links[&comp].feature;
// On Unix these names are plain files beside the design, so a check that was skipped would
// find them: the refusal below comes from the text alone.
let crafted = [r"\\evil.example\share\plate.solidcraft", "//evil.example/share/plate.solidcraft", r"\\?\UNC\evil.example\share\p.solidcraft"];
if cfg!(unix) {
std::fs::copy(&part, dir.join(crafted[0])).unwrap();
}
let devices = [r"\\.\pipe\plate.solidcraft", r"\\.\COM1", "parts/NUL.solidcraft", "parts/com1.solidcraft", r"parts\CON.part.solidcraft"];
std::fs::copy(&part, dir.join("parts").join("NUL.solidcraft")).unwrap();
let before = volume(&mut a);
for link in crafted.iter().chain(&devices) {
a.doc_mut().links.insert(comp, DesignLink { path: link.to_string(), feature });
let calls = solidcraft_io::vfs::file_calls();
let listed = run(&mut a, "component.links", json!({}));
let entry = &listed["links"][0];
assert!(entry["found"].is_null() && entry["reason"].is_string(), "{link}: {listed}");
let err = a.execute("component.update_links", &json!({})).unwrap_err().to_string();
assert_eq!(solidcraft_io::vfs::file_calls(), calls, "{link}: a file call was made");
if devices.contains(link) {
assert!(entry["host"].is_null() && err.contains("names a device"), "{link}: {listed} {err}");
} else {
assert_eq!(entry["host"], "evil.example", "{link}: {listed}");
assert!(err.contains(r"network location \\evil.example"), "{link}: {err}");
}
assert_eq!(volume(&mut a), before, "{link}: the design changed");
}
// Allowed (Allow once, a preference, …), the same link is read as any other.
#[cfg(unix)]
{
a.doc_mut().links.insert(comp, DesignLink { path: crafted[0].to_string(), feature });
solidcraft_io::vfs::allowing_hosts(&["EVIL.example".to_string()], || {
let listed = run(&mut a, "component.links", json!({}));
assert_eq!(listed["links"][0]["found"], true, "{listed}");
assert_eq!(run(&mut a, "component.update_links", json!({}))["unchanged"], json!(["plate"]));
});
assert!(run(&mut a, "component.links", json!({}))["links"][0]["found"].is_null(), "allowed for that action only");
}
// A local link, relative or absolute, is found and read as before.
for local in ["parts/plate.solidcraft".to_string(), part.to_string_lossy().to_string()] {
a.doc_mut().links.insert(comp, DesignLink { path: local.clone(), feature });
assert_eq!(run(&mut a, "component.links", json!({}))["links"][0]["found"], true, "{local}");
assert_eq!(run(&mut a, "component.update_links", json!({}))["unchanged"], json!(["plate"]), "{local}");
}
// Relink to a network path (programmatic: no prompt) is refused before the disk is asked.
let calls = solidcraft_io::vfs::file_calls();
let err = a.execute("component.relink", &json!({"component": comp, "path": r"\\evil.example\share\x.solidcraft"})).unwrap_err().to_string();
assert!(err.contains("network location"), "{err}");
assert_eq!(solidcraft_io::vfs::file_calls(), calls);
let _ = std::fs::remove_dir_all(&dir);
}
/// Every place that reaches a file through a link path goes through the design-path rule
/// (`vfs::check_design_path` / `read_design_path` / `design_path_is_file` / `link_refusal`):
/// no plain file call on a link's path in the link commands, and the font file a design's text
/// names is checked before it is read.
#[test]
fn every_link_path_goes_through_the_design_path_rule() {
let root = Path::new(env!("CARGO_MANIFEST_DIR"));
let code = |file: &str| {
let text = std::fs::read_to_string(root.join(file)).unwrap();
// The code before its test module.
text.split("\n#[cfg(test)]\n#[allow(clippy::unwrap_used").next().unwrap_or("").to_string()
};
for file in ["src/cmd/component_link.rs", "src/cmd/component_extract.rs"] {
let text = code(file);
for raw in [
"vfs::read(",
"vfs::read_to_string(",
"vfs::is_file(",
"vfs::exists(",
"vfs::len(",
"std::fs::read",
"std::fs::metadata",
".is_file()",
".exists()",
".metadata()",
] {
assert!(!text.contains(raw), "{file}: `{raw}` on a link's path must go through vfs::check_design_path");
}
// Relink canonicalises the path it is given, after the rule.
if let Some(at) = text.find("canonicalize") {
let rule = text[..at].rfind("link_refused(s.path.as_deref(), given)").unwrap_or(usize::MAX);
assert!(rule < at, "{file}: canonicalize before check_design_path");
}
}
let fonts = std::fs::read_to_string(root.join("../sketch/src/fonts.rs")).unwrap();
let (check, read) = (fonts.find("FILE_CHECK.get()").unwrap(), fonts.find("read_font(&path)").unwrap());
assert!(check < read, "a font file named by a design is checked before it is read");
let io = std::fs::read_to_string(root.join("../io/src/vfs.rs")).unwrap();
assert!(io.contains("set_font_file_check(|p| check_design_path("), "the font check is the design-path rule");
}
}