* claim: #10813 * fix: place reused linked designs from parent origin (#10813)
1376 lines
76 KiB
Rust
1376 lines
76 KiB
Rust
//! 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::hash::{Hash, Hasher};
|
||
use std::path::{Path, PathBuf};
|
||
use std::sync::Mutex;
|
||
|
||
use serde_json::{Value, json};
|
||
use solidcraft_doc::{DesignLink, Document, FeatureKind, LinkedBodyProperties, UserMaterial};
|
||
|
||
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 .sc 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] in mm from the destination parent's origin (default [0,0,0], also with reuse); \
|
||
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); components?: a list of ids or names, which goes on past a design it \
|
||
cannot read (that one keeps its bodies, is named in failed and gets a warning) — reads the linked designs again and replaces \
|
||
their bodies where they changed, as one undo step; → updated, unchanged, failed ([{component, name, error}]), 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 design (.sc or .json) — 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 .sc 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 .sc 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), changed (whether the file is no longer what this design last read: Update Links \
|
||
reads it again; null when not found or the link is older than this record), 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, Vec<SourceProperties>);
|
||
|
||
#[derive(Clone)]
|
||
struct SourceProperties {
|
||
material: String,
|
||
definition: Option<UserMaterial>,
|
||
appearance: Option<solidcraft_doc::appearance::Look>,
|
||
/// Resolved authored overrides, by the face index in this imported body.
|
||
faces: Vec<(usize, solidcraft_doc::appearance::Look)>,
|
||
}
|
||
|
||
/// What a linked file last gave, by the file: digests of its bytes, of the STEP text it gave and
|
||
/// of its face names, and that read's warnings and source properties. Update Links evaluates
|
||
/// a file again only when its bytes or the linked bodies changed since (#5606). Bounded, oldest first out.
|
||
static READS: Mutex<Vec<LinkRead>> = Mutex::new(Vec::new());
|
||
const READS_SIZE: usize = 256;
|
||
|
||
struct LinkRead {
|
||
file: PathBuf,
|
||
bytes: u64,
|
||
step: u64,
|
||
faces: u64,
|
||
warnings: Vec<String>,
|
||
properties: Vec<SourceProperties>,
|
||
}
|
||
|
||
#[cfg(test)]
|
||
thread_local! {
|
||
/// Linked designs read and evaluated on this thread, for tests.
|
||
static EVALUATED: std::cell::Cell<usize> = const { std::cell::Cell::new(0) };
|
||
}
|
||
|
||
fn digest<T: Hash + ?Sized>(value: &T) -> u64 {
|
||
let mut h = std::collections::hash_map::DefaultHasher::new();
|
||
value.hash(&mut h);
|
||
h.finish()
|
||
}
|
||
|
||
/// Warnings and source properties of the last read of `file`, when it had these bytes and gave the STEP text
|
||
/// `step` and the face names `faces`: the bodies it gives are the ones the link holds.
|
||
fn unchanged_read(file: &Path, bytes: u64, step: u64, faces: u64) -> Option<(Vec<String>, Vec<SourceProperties>)> {
|
||
let file = absolute(file);
|
||
let reads = READS.lock().ok()?;
|
||
reads
|
||
.iter()
|
||
.find(|r| r.file == file && r.bytes == bytes && r.step == step && r.faces == faces)
|
||
.map(|r| (r.warnings.clone(), r.properties.clone()))
|
||
}
|
||
|
||
fn remember_read(file: &Path, bytes: u64, feature: &solidcraft_io::StepFeature, faces: &[Vec<String>], properties: &[SourceProperties]) {
|
||
let FeatureKind::Import { step, .. } = &feature.kind else { return };
|
||
let file = absolute(file);
|
||
let Ok(mut reads) = READS.lock() else { return };
|
||
reads.retain(|r| r.file != file);
|
||
if reads.len() >= READS_SIZE {
|
||
reads.remove(0);
|
||
}
|
||
reads.push(LinkRead {
|
||
file,
|
||
bytes,
|
||
step: digest(step.as_bytes()),
|
||
faces: digest(faces),
|
||
warnings: feature.warnings.clone(),
|
||
properties: properties.to_vec(),
|
||
});
|
||
}
|
||
|
||
/// The bytes of the design at `file`, which must not be the design saved at `own`.
|
||
fn read_link(file: &Path, own: Option<&str>) -> Result<Vec<u8>> {
|
||
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 design = solidcraft_io::limits::Kind::Design;
|
||
solidcraft_io::vfs::read_design_path(&shown, own, solidcraft_io::limits::max_design_bytes()).map_err(|e| {
|
||
let e = solidcraft_io::limits::explain(design, e).to_string();
|
||
EngineError::Other(if e.starts_with(&shown) { e } else { format!("{shown}: {e}") })
|
||
})
|
||
}
|
||
|
||
/// The solid bodies of the design at `file`, evaluated, as an Import feature, with the digest of
|
||
/// the bytes read, which the link keeps ([`DesignLink::file_sha256`], #9739).
|
||
fn linked_bodies_read(file: &Path, own: Option<&str>) -> Result<(Linked, String)> {
|
||
let bytes = read_link(file, own)?;
|
||
Ok((design_bodies(file, &bytes)?, DesignLink::file_digest(&bytes)))
|
||
}
|
||
|
||
/// Linked files' digests as [`file_sha256`] last worked them out, by file, with the time and
|
||
/// size the file had then. Bounded, oldest first out.
|
||
static DIGESTS: Mutex<Vec<(PathBuf, (std::time::SystemTime, u64), String)>> = Mutex::new(Vec::new());
|
||
const DIGESTS_SIZE: usize = 256;
|
||
|
||
/// The digest of the design file at `file` now ([`DesignLink::file_digest`]), `None` when it
|
||
/// can't be read. `component.links` asks each time a tab is shown, so a file is read again only
|
||
/// when its time or size changed since; the browser build keeps no times and reads it each time.
|
||
pub(super) fn file_sha256(file: &Path, own: Option<&str>) -> Option<String> {
|
||
let file = absolute(file);
|
||
let stamp = solidcraft_io::vfs::design_path_stamp(&file.to_string_lossy(), own);
|
||
if let Some(stamp) = stamp
|
||
&& let Some(known) = DIGESTS.lock().ok()?.iter().find(|(f, s, _)| *f == file && *s == stamp).map(|(_, _, d)| d.clone())
|
||
{
|
||
return Some(known);
|
||
}
|
||
let digest = DesignLink::file_digest(&read_link(&file, own).ok()?);
|
||
if let (Some(stamp), Ok(mut digests)) = (stamp, DIGESTS.lock()) {
|
||
digests.retain(|(f, _, _)| *f != file);
|
||
if digests.len() >= DIGESTS_SIZE {
|
||
digests.remove(0);
|
||
}
|
||
digests.push((file, stamp, digest.clone()));
|
||
}
|
||
Some(digest)
|
||
}
|
||
|
||
/// The solid bodies of `bytes`, the design at `file`, as an Import feature. The model the file
|
||
/// keeps is its evaluation when this build saved it for exactly that design, as when it is opened.
|
||
fn design_bodies(file: &Path, bytes: &[u8]) -> Result<Linked> {
|
||
#[cfg(test)]
|
||
EVALUATED.with(|n| n.set(n.get() + 1));
|
||
let shown = file.display().to_string();
|
||
let fail = |e: solidcraft_io::IoError| EngineError::Other(format!("{shown}: {e}"));
|
||
let (doc, saved) = if solidcraft_io::is_design_container(bytes) {
|
||
let mut reader = solidcraft_io::DesignContainerReader::new(std::io::Cursor::new(bytes)).map_err(fail)?;
|
||
let saved = reader.geometry();
|
||
(reader.read_document().map_err(fail)?, saved)
|
||
} else {
|
||
(solidcraft_io::read_design(bytes).map_err(fail)?, None)
|
||
};
|
||
let (name, feature, faces, metadata, properties) = session_bodies(&Session::opened_at(doc, saved.as_ref(), Some(&shown)), &shown)?;
|
||
remember_read(file, digest(bytes), &feature, &faces, &properties);
|
||
Ok((name, feature, faces, metadata, properties))
|
||
}
|
||
|
||
/// 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_for_link(&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);
|
||
let properties = feature
|
||
.import
|
||
.bodies
|
||
.iter()
|
||
.zip(&faces)
|
||
.map(|(read, carried)| {
|
||
// STEP can split a source body into several lumps. Match its carried source
|
||
// face names rather than assuming source and imported body orders agree.
|
||
let source = world
|
||
.bodies
|
||
.iter()
|
||
.find(|b| b.name == read.name)
|
||
.or_else(|| {
|
||
world
|
||
.bodies
|
||
.iter()
|
||
.filter(|b| !b.body.is_mesh())
|
||
.filter_map(|b| {
|
||
let names = solidcraft_doc::naming::face_names(b);
|
||
let count = carried.iter().filter(|n| !n.is_empty() && names.contains(n)).count();
|
||
(count > 0).then_some((count, b))
|
||
})
|
||
.max_by_key(|(count, _)| *count)
|
||
.map(|(_, b)| b)
|
||
})
|
||
.ok_or_else(|| EngineError::Other(format!("{shown}: cannot match linked body {} to its source properties", read.name)))?;
|
||
let key = source.definition_name();
|
||
let material = part.doc.body_material(key);
|
||
let definition = if solidcraft_doc::material_density(&material).is_none() { part.doc.user_material(&material).cloned() } else { None };
|
||
let appearance = part
|
||
.doc
|
||
.appearances
|
||
.bodies
|
||
.get(key)
|
||
.cloned()
|
||
.or_else(|| part.doc.appearances.components.get(&part.doc.model_body_component(source)).cloned());
|
||
let names = solidcraft_doc::naming::face_names(source);
|
||
let authored: std::collections::BTreeMap<_, _> = part
|
||
.doc
|
||
.authored_face_colors(source)
|
||
.into_iter()
|
||
.filter_map(|(index, look)| names.get(index).map(|name| (name.clone(), look)))
|
||
.collect();
|
||
let faces = carried.iter().enumerate().filter_map(|(index, name)| authored.get(name).map(|look| (index, look.clone()))).collect();
|
||
Ok(SourceProperties { material, definition, appearance, faces })
|
||
})
|
||
.collect::<Result<Vec<_>>>()?;
|
||
Ok((name, feature, faces, part.doc.metadata.clone(), properties))
|
||
}
|
||
|
||
fn material_fingerprint(doc: &Document, material: &str) -> Result<Option<String>> {
|
||
if solidcraft_doc::material_density(material).is_some() {
|
||
return Ok(None);
|
||
}
|
||
doc.user_material(material).map(LinkedBodyProperties::fingerprint).transpose().map_err(|e| EngineError::Other(e.to_string()))
|
||
}
|
||
|
||
/// Copy a design-owned definition without changing a same-named assembly material.
|
||
fn inherit_material(doc: &mut Document, source: &SourceProperties, previous: Option<&str>) -> Result<String> {
|
||
let Some(definition) = &source.definition else { return Ok(source.material.clone()) };
|
||
for existing in &doc.user_materials {
|
||
// Equal density/optics do not make differently named materials interchangeable.
|
||
// A previous disambiguated copy can be reused on subsequent source updates.
|
||
if !existing.name.eq_ignore_ascii_case(&definition.name) && previous != Some(existing.name.as_str()) {
|
||
continue;
|
||
}
|
||
let mut candidate = definition.clone();
|
||
candidate.name.clone_from(&existing.name);
|
||
if &candidate == existing {
|
||
return Ok(existing.name.clone());
|
||
}
|
||
}
|
||
if doc.user_materials.len() >= solidcraft_doc::MAX_USER_MATERIALS {
|
||
return Err(EngineError::Other("cannot inherit linked material: this design already has 1000 custom materials".into()));
|
||
}
|
||
let mut copy = definition.clone();
|
||
if doc.material_name(©.name).is_some() {
|
||
let base: String = copy.name.chars().take(64).collect();
|
||
let name = (1..=solidcraft_doc::MAX_USER_MATERIALS + 1)
|
||
.map(|i| format!("{base} (linked {i})"))
|
||
.find(|name| doc.material_name(name).is_none())
|
||
.ok_or_else(|| EngineError::Other("cannot name the linked material".into()))?;
|
||
copy.name = name;
|
||
}
|
||
let name = copy.name.clone();
|
||
doc.user_materials.push(copy);
|
||
Ok(name)
|
||
}
|
||
|
||
/// Replace only unchanged inherited face assignments. A locally edited, added or removed
|
||
/// override remains local, independently for each face. Resolve names on the evaluated Import,
|
||
/// not source feature IDs or face order from the source's model.
|
||
fn inherit_faces(
|
||
s: &mut Session,
|
||
name: &str,
|
||
source: &SourceProperties,
|
||
previous: Option<&LinkedBodyProperties>,
|
||
) -> (Vec<solidcraft_doc::appearance::FaceLook>, bool) {
|
||
use solidcraft_doc::appearance::FaceLook;
|
||
let previous = previous.and_then(|p| p.faces.as_deref()).unwrap_or_default();
|
||
if source.faces.is_empty() && previous.is_empty() {
|
||
return (Vec::new(), false);
|
||
}
|
||
let state = s.model.state();
|
||
let Some(body) = state.body(name) else { return (Vec::new(), false) };
|
||
let names = solidcraft_doc::naming::face_names(body);
|
||
// A stable named assignment needs no new geometric point. Keep its position in
|
||
// the appearance list and avoid tessellating on unchanged cached reads.
|
||
if previous.len() == source.faces.len()
|
||
&& previous.iter().all(|old| old.body == name && s.doc.appearances.faces.contains(old))
|
||
&& source.faces.iter().all(|(index, look)| {
|
||
names.get(*index).is_some_and(|name| previous.iter().any(|old| old.name.as_ref() == Some(name) && old.look == *look))
|
||
})
|
||
{
|
||
return (previous.to_vec(), false);
|
||
}
|
||
let before = s.doc.appearances.faces.clone();
|
||
let mut local = before.clone();
|
||
let mut inherited = Vec::new();
|
||
let mut replaced = Vec::new();
|
||
let mut blocked = std::collections::BTreeSet::new();
|
||
for old in previous {
|
||
let mut old = old.clone();
|
||
old.body = name.into();
|
||
if let Some(index) = local.iter().position(|face| *face == old) {
|
||
local.remove(index);
|
||
replaced.push(old);
|
||
} else {
|
||
if let Some(name) = &old.name {
|
||
blocked.extend(solidcraft_doc::naming::faces_with_stem(body, name));
|
||
}
|
||
// Remember an explicit local removal too, including after save/reopen.
|
||
inherited.push(old);
|
||
}
|
||
}
|
||
s.doc_mut().appearances.faces = local;
|
||
blocked.extend(s.doc.authored_face_colors(body).into_iter().map(|(index, _)| index));
|
||
let spots = if source.faces.is_empty() { Vec::new() } else { solidcraft_doc::naming::face_spots(body) };
|
||
let mut assignments = Vec::new();
|
||
for (index, look) in &source.faces {
|
||
if blocked.contains(index) {
|
||
// An appended local override can coexist with the old inherited entry.
|
||
// Keep that baseline as a tombstone if the local override is later removed.
|
||
if let Some(old) = names.get(*index).and_then(|name| previous.iter().find(|old| old.name.as_ref() == Some(name))) {
|
||
let mut old = old.clone();
|
||
old.body = name.into();
|
||
if !inherited.contains(&old) {
|
||
inherited.push(old);
|
||
}
|
||
}
|
||
continue;
|
||
}
|
||
let Some(face_name) = names.get(*index).filter(|name| !name.is_empty()) else { continue };
|
||
let Some(spot) = spots.get(*index).and_then(|spot| *spot) else { continue };
|
||
let face = FaceLook {
|
||
body: name.into(),
|
||
point: spot.point,
|
||
look: look.clone(),
|
||
name: Some(face_name.clone()),
|
||
strict_name: false,
|
||
certificate: None,
|
||
};
|
||
assignments.push(face.clone());
|
||
inherited.push(face);
|
||
}
|
||
// Replace inherited entries in place; leave all local and other bodies' entries
|
||
// in their original order, including multiple overrides on the same face.
|
||
let mut after = Vec::new();
|
||
for old in &before {
|
||
if replaced.contains(old) {
|
||
if let Some(index) = assignments.iter().position(|face| face.body == old.body && face.name == old.name) {
|
||
after.push(assignments.remove(index));
|
||
}
|
||
} else {
|
||
after.push(old.clone());
|
||
}
|
||
}
|
||
after.extend(assignments);
|
||
let changed = after != before;
|
||
s.doc_mut().appearances.faces = after;
|
||
(inherited, changed)
|
||
}
|
||
|
||
/// Apply properties after evaluation has resolved body-name collisions. Last inherited
|
||
/// values are kept independently for material and appearance, so overriding one does not
|
||
/// stop updates of the other. Session::execute makes this part of the command's undo step.
|
||
fn inherit_properties(s: &mut Session, component: u64, sources: &[SourceProperties]) -> Result<bool> {
|
||
let Some(link) = s.doc.links.get(&component).cloned() else { return Ok(false) };
|
||
let state = s.model.state();
|
||
let names: Vec<String> = state.bodies.iter().filter(|b| b.feature == link.feature).map(|b| b.name.clone()).collect();
|
||
let slots = s.doc.feature(link.feature).map(|f| f.body_name_slots(names.len())).unwrap_or_default();
|
||
let mut inherited = link.inherited.clone();
|
||
inherited.resize(sources.len(), LinkedBodyProperties::default());
|
||
let mut changed = false;
|
||
for (name, slot) in names.iter().zip(slots) {
|
||
let Some(source) = sources.get(slot) else { continue };
|
||
let old = link.inherited.get(slot);
|
||
let current_definition = material_fingerprint(&s.doc, &s.doc.body_material(name))?;
|
||
let may_change_material = match old {
|
||
Some(old) => s.doc.materials.get(name) == Some(&old.material) && current_definition == old.material_fingerprint,
|
||
None => !s.doc.materials.contains_key(name),
|
||
};
|
||
let mut next = old.cloned().unwrap_or_default();
|
||
if may_change_material {
|
||
let material = inherit_material(s.doc_mut(), source, old.map(|old| old.material.as_str()))?;
|
||
changed |= s.doc.materials.get(name) != Some(&material);
|
||
s.doc_mut().materials.insert(name.clone(), material.clone());
|
||
next.material_fingerprint = material_fingerprint(&s.doc, &material)?;
|
||
next.material = material;
|
||
}
|
||
if s.doc.appearances.bodies.get(name) == old.and_then(|old| old.appearance.as_ref()) {
|
||
changed |= s.doc.appearances.bodies.get(name) != source.appearance.as_ref();
|
||
match &source.appearance {
|
||
Some(look) => {
|
||
s.doc_mut().appearances.bodies.insert(name.clone(), look.clone());
|
||
}
|
||
None => {
|
||
s.doc_mut().appearances.bodies.remove(name);
|
||
}
|
||
}
|
||
next.appearance.clone_from(&source.appearance);
|
||
}
|
||
let (faces, face_changed) = inherit_faces(s, name, source, old);
|
||
next.faces = Some(faces);
|
||
changed |= face_changed;
|
||
if let Some(snapshot) = inherited.get_mut(slot) {
|
||
*snapshot = next;
|
||
}
|
||
}
|
||
if let Some(link) = s.doc_mut().links.get_mut(&component) {
|
||
link.inherited = inherited;
|
||
}
|
||
Ok(changed)
|
||
}
|
||
|
||
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 = if p.get("parent").is_some() { component_key(s, p, "parent", cmd)? } else { s.active_component };
|
||
// Reuse the definition, not another placement's captured or pending move.
|
||
// Insert Design places from the parent origin whether the link is new or reused.
|
||
let mut transform = solidcraft_doc::IDENTITY;
|
||
transform[3] = [translate.x, translate.y, translate.z, 1.0];
|
||
let occurrence = s.doc_mut().add_occurrence(component, parent, transform)?;
|
||
return Ok(json!({"occurrence": occurrence, "component": component}));
|
||
}
|
||
}
|
||
let ((design_name, sf, faces, metadata, properties), read) = linked_bodies_read(&file, s.path.as_deref())?;
|
||
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, inherited: Vec::new(), file_sha256: Some(read) });
|
||
s.refresh();
|
||
if let Some(e) = s.model.result(id).and_then(|r| r.error.clone()) {
|
||
return Err(EngineError::Other(e));
|
||
}
|
||
inherit_properties(s, comp, &properties)?;
|
||
s.refresh();
|
||
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 = match (p.get("component"), p.get("components")) {
|
||
(Some(_), Some(_)) => return Err(bad(cmd, "give `component` or `components`, not both")),
|
||
(Some(_), None) => Some(vec![component_key(s, p, "component", cmd)?]),
|
||
(None, Some(Value::Array(list))) if !list.is_empty() && list.len() <= 10_000 => {
|
||
Some(list.iter().map(|c| component_key(s, &json!({"component": c}), "component", cmd)).collect::<Result<Vec<_>>>()?)
|
||
}
|
||
(None, Some(_)) => return Err(bad(cmd, "`components` must be a list of component ids or names")),
|
||
(None, None) => None,
|
||
};
|
||
if let Some(c) = only.iter().flatten().find(|c| !s.doc.links.contains_key(c)) {
|
||
let name = s.doc.components.iter().find(|x| x.id == *c).map_or_else(|| c.to_string(), |x| x.name.clone());
|
||
return Err(bad(cmd, format!("{name}: that component is not linked to a design")));
|
||
}
|
||
// A list goes on past a design it cannot read: that link keeps its bodies and is named in
|
||
// `failed`, so the others still come in as one step (#9743).
|
||
let go_on = p.get("components").is_some();
|
||
let links: Vec<(u64, DesignLink)> =
|
||
s.doc.links.iter().filter(|(c, _)| only.as_ref().is_none_or(|o| o.contains(c))).map(|(c, l)| (*c, l.clone())).collect();
|
||
let (mut updated, mut unchanged, mut warnings, mut failed) = (Vec::new(), 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 (old, file, bytes) = match read_linked(s, comp, &link) {
|
||
Ok(read) => read,
|
||
Err(e) if go_on => {
|
||
failed.push(json!({"component": comp, "name": cname, "error": e}));
|
||
warnings.push(format!("{cname} keeps its bodies: {e}"));
|
||
continue;
|
||
}
|
||
Err(e) => return Err(bad(cmd, format!("{cname}: {e}"))),
|
||
};
|
||
// The link keeps what it read, so opening this design again knows whether the file
|
||
// changed while it was closed (#9739).
|
||
let read = DesignLink::file_digest(&bytes);
|
||
if link.file_sha256.as_deref() != Some(read.as_str())
|
||
&& let Some(kept) = s.doc_mut().links.get_mut(&comp)
|
||
{
|
||
kept.file_sha256 = Some(read);
|
||
}
|
||
// A link that has not recorded the properties it inherited (made before they were) is read again.
|
||
let kept_faces = s
|
||
.doc
|
||
.feature(link.feature)
|
||
.filter(|_| !link.inherited.is_empty() && link.inherited.iter().all(|p| p.faces.is_some()))
|
||
.map(|f| digest(f.link_faces.as_slice()));
|
||
if let Some((known, properties)) = kept_faces.and_then(|faces| unchanged_read(&file, digest(bytes.as_slice()), digest(old.as_bytes()), faces))
|
||
{
|
||
warnings.extend(known);
|
||
// Another component or session may have evaluated this source first. Its
|
||
// cached geometry says nothing about this link's inherited properties.
|
||
if inherit_properties(s, comp, &properties)? {
|
||
updated.push(cname)
|
||
} else {
|
||
unchanged.push(cname)
|
||
}
|
||
continue;
|
||
}
|
||
let (_, sf, faces, _, properties) = match design_bodies(&file, &bytes) {
|
||
Ok(read) => read,
|
||
Err(e) if go_on => {
|
||
// It keeps its bodies, so it has not taken this file in yet.
|
||
if let Some(kept) = s.doc_mut().links.get_mut(&comp) {
|
||
kept.file_sha256.clone_from(&link.file_sha256);
|
||
}
|
||
failed.push(json!({"component": comp, "name": cname, "error": e.to_string()}));
|
||
warnings.push(format!("{cname} keeps its bodies: {e}"));
|
||
continue;
|
||
}
|
||
Err(e) => return Err(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) {
|
||
if inherit_properties(s, comp, &properties)? {
|
||
updated.push(cname)
|
||
} else {
|
||
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;
|
||
}
|
||
s.refresh();
|
||
let changed = inherit_properties(s, comp, &properties)? || changed;
|
||
if changed { updated.push(cname) } else { unchanged.push(cname) }
|
||
}
|
||
solidcraft_doc::progress::item(None);
|
||
// None could be read: nothing to take back either.
|
||
if updated.is_empty() && unchanged.is_empty() && !failed.is_empty() {
|
||
let (name, why) = (failed[0]["name"].as_str().unwrap_or_default(), failed[0]["error"].as_str().unwrap_or_default());
|
||
return Err(bad(cmd, format!("{name}: {why}")));
|
||
}
|
||
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, "failed": failed}))
|
||
}
|
||
|
||
/// `comp`'s linked design as it was last read (its bodies) and as its file is now, read before
|
||
/// anything in the design changes.
|
||
fn read_linked(s: &Session, comp: u64, link: &DesignLink) -> std::result::Result<(std::sync::Arc<str>, PathBuf, Vec<u8>), String> {
|
||
let Some(FeatureKind::Import { step: old, .. }) = s.doc.feature(link.feature).filter(|f| f.component == comp).map(|f| &f.kind) else {
|
||
return Err(format!("its linked bodies (feature {}) are gone; break the link or insert the design again", link.feature));
|
||
};
|
||
link_refused(s.path.as_deref(), &link.path).map_err(|e| e.to_string())?;
|
||
let file = resolve(s.path.as_deref(), &link.path);
|
||
let bytes = read_link(&file, s.path.as_deref()).map_err(|e| e.to_string())?;
|
||
Ok((old.clone(), file, bytes))
|
||
}
|
||
|
||
/// 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));
|
||
// Any design Insert Design takes: a .sc container (or a legacy one) or a plain JSON design.
|
||
if !solidcraft_io::is_design_path(given) {
|
||
return Err(bad(cmd, "choose a saved design (.sc or .json)"));
|
||
}
|
||
// 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, _, properties), read) = linked_bodies_read(&file, s.path.as_deref()).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(), file_sha256: Some(read), ..link.clone() });
|
||
s.refresh();
|
||
if let Some(error) = s.model.result(link.feature).and_then(|r| r.error.clone()) {
|
||
return Err(bad(cmd, error));
|
||
}
|
||
inherit_properties(s, comp, &properties)?;
|
||
s.refresh();
|
||
// 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 => {
|
||
let found = solidcraft_io::vfs::design_path_is_file(&file, s.path.as_deref());
|
||
// Whether the file is no longer what this design last read (#9739): `null`
|
||
// when it isn't found, or the link keeps no digest (made before they were).
|
||
let changed = l
|
||
.file_sha256
|
||
.as_ref()
|
||
.filter(|_| found == Some(true))
|
||
.and_then(|kept| file_sha256(Path::new(file.as_ref()), s.path.as_deref()).map(|now| now != *kept));
|
||
json!({"component": c, "name": name, "path": path, "file": file, "found": found, "changed": changed})
|
||
}
|
||
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(©);
|
||
} 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 update_links_reads_again_only_the_designs_that_changed() {
|
||
let dir = std::env::temp_dir().join(format!("solidcraft-link-reads-{}", std::process::id()));
|
||
std::fs::create_dir_all(&dir).unwrap();
|
||
let (plate, block) = (dir.join("plate.solidcraft"), dir.join("block.solidcraft"));
|
||
save_box(&plate, 30.0);
|
||
save_box(&block, 10.0);
|
||
let mut a = Session::default();
|
||
run(&mut a, "component.insert_design", json!({"path": plate}));
|
||
run(&mut a, "component.insert_design", json!({"path": block, "translate": [50, 0, 0]}));
|
||
let evaluated = || EVALUATED.with(std::cell::Cell::get);
|
||
// Unchanged files are not evaluated again.
|
||
let before = evaluated();
|
||
let r = run(&mut a, "component.update_links", json!({}));
|
||
assert_eq!((r["updated"].clone(), r["unchanged"].clone()), (json!([]), json!(["plate", "block"])), "{r}");
|
||
assert_eq!(evaluated(), before);
|
||
// An edited file is, and only that one.
|
||
save_box(&plate, 45.0);
|
||
let r = run(&mut a, "component.update_links", json!({}));
|
||
assert_eq!((r["updated"].clone(), r["unchanged"].clone()), (json!(["plate"]), json!(["block"])), "{r}");
|
||
assert_eq!(evaluated(), before + 1);
|
||
assert!((volume(&mut a) - 11000.0).abs() < 1e-6, "{}", volume(&mut a));
|
||
// Undone, the link holds the old bodies again: the same file brings the new ones back.
|
||
run(&mut a, "edit.undo", json!({}));
|
||
assert!((volume(&mut a) - 8000.0).abs() < 1e-6, "{}", volume(&mut a));
|
||
assert_eq!(run(&mut a, "component.update_links", json!({}))["updated"], json!(["plate"]));
|
||
assert!((volume(&mut a) - 11000.0).abs() < 1e-6, "{}", volume(&mut a));
|
||
// A file saved again without its model is evaluated, and gives the same bodies.
|
||
let mut part = Session::default();
|
||
run(&mut part, "doc.open", json!({"path": block}));
|
||
run(&mut part, "file.save", json!({"cache": false}));
|
||
let before = evaluated();
|
||
assert_eq!(run(&mut a, "component.update_links", json!({}))["unchanged"], json!(["plate", "block"]));
|
||
assert_eq!(evaluated(), before + 1);
|
||
let _ = std::fs::remove_dir_all(&dir);
|
||
}
|
||
|
||
/// #9739: a link keeps what it read of its file, so an assembly opened again says which
|
||
/// linked designs changed while it was closed; Update Links takes the change and the record.
|
||
#[test]
|
||
fn a_link_says_its_file_changed_while_the_design_was_closed() {
|
||
let dir = std::env::temp_dir().join(format!("solidcraft-link-changed-{}", std::process::id()));
|
||
std::fs::create_dir_all(&dir).unwrap();
|
||
let (part, assembly) = (dir.join("p.sc"), dir.join("a.sc"));
|
||
save_box(&part, 10.0);
|
||
let mut a = Session::default();
|
||
run(&mut a, "component.insert_design", json!({"path": part}));
|
||
run(&mut a, "file.save", json!({"path": assembly}));
|
||
let changed = |s: &mut Session| run(s, "component.links", json!({}))["links"][0]["changed"].clone();
|
||
assert_eq!(changed(&mut a), json!(false));
|
||
// The part is edited while the assembly is closed.
|
||
save_box(&part, 30.0);
|
||
let mut opened = Session::default();
|
||
run(&mut opened, "doc.open", json!({"path": assembly}));
|
||
assert_eq!(changed(&mut opened), json!(true));
|
||
assert!((volume(&mut opened) - 2000.0).abs() < 1e-6, "{}", volume(&mut opened));
|
||
assert_eq!(run(&mut opened, "component.update_links", json!({}))["updated"], json!(["p"]));
|
||
assert_eq!(changed(&mut opened), json!(false));
|
||
assert!((volume(&mut opened) - 6000.0).abs() < 1e-6, "{}", volume(&mut opened));
|
||
// Saved, it opens up to date.
|
||
run(&mut opened, "file.save", json!({}));
|
||
let mut again = Session::default();
|
||
run(&mut again, "doc.open", json!({"path": assembly}));
|
||
assert_eq!(changed(&mut again), json!(false));
|
||
// A link made before the record says nothing; Update Links gives it one.
|
||
again.doc_mut().links.values_mut().for_each(|l| l.file_sha256 = None);
|
||
assert_eq!(changed(&mut again), Value::Null);
|
||
assert_eq!(run(&mut again, "component.update_links", json!({}))["unchanged"], json!(["p"]));
|
||
assert_eq!(changed(&mut again), json!(false));
|
||
let _ = std::fs::remove_dir_all(&dir);
|
||
}
|
||
|
||
/// #9743: a list of links is read in one step that goes on past a design it can't read.
|
||
#[test]
|
||
fn update_links_given_a_list_reads_them_in_one_step_past_a_design_it_cannot_read() {
|
||
let dir = std::env::temp_dir().join(format!("solidcraft-link-list-{}", std::process::id()));
|
||
std::fs::create_dir_all(&dir).unwrap();
|
||
let (plate, block) = (dir.join("plate.solidcraft"), dir.join("block.solidcraft"));
|
||
save_box(&plate, 30.0);
|
||
save_box(&block, 10.0);
|
||
let mut a = Session::default();
|
||
let first = run(&mut a, "component.insert_design", json!({"path": plate}))["component"].clone();
|
||
let second = run(&mut a, "component.insert_design", json!({"path": plate, "translate": [50, 0, 0]}))["component"].clone();
|
||
let third = run(&mut a, "component.insert_design", json!({"path": block, "translate": [100, 0, 0]}))["component"].clone();
|
||
assert!((volume(&mut a) - 14000.0).abs() < 1e-6, "{}", volume(&mut a));
|
||
// Two links to the same changed file come in together, and one Undo takes both back.
|
||
save_box(&plate, 45.0);
|
||
let r = run(&mut a, "component.update_links", json!({"components": [first, second]}));
|
||
assert_eq!((r["updated"].as_array().map(Vec::len), r["failed"].clone()), (Some(2), json!([])), "{r}");
|
||
assert!((volume(&mut a) - 20000.0).abs() < 1e-6, "{}", volume(&mut a));
|
||
run(&mut a, "edit.undo", json!({}));
|
||
assert!((volume(&mut a) - 14000.0).abs() < 1e-6, "{}", volume(&mut a));
|
||
// A design it can't read keeps its bodies and is named; the others still come in.
|
||
std::fs::write(&block, b"not a design").unwrap();
|
||
let r = run(&mut a, "component.update_links", json!({"components": [first, third]}));
|
||
assert_eq!(r["updated"].as_array().map(Vec::len), Some(1), "{r}");
|
||
assert_eq!((r["failed"][0]["component"].clone(), r["failed"][0]["name"].clone()), (third.clone(), json!("block")), "{r}");
|
||
assert!(r["warnings"].as_array().is_some_and(|w| w.iter().any(|w| w.as_str().is_some_and(|w| w.starts_with("block")))), "{r}");
|
||
assert!((volume(&mut a) - 17000.0).abs() < 1e-6, "{}", volume(&mut a));
|
||
// Not taken in, it still says its file changed (#9739).
|
||
let links = run(&mut a, "component.links", json!({}));
|
||
let block_link = links["links"].as_array().and_then(|l| l.iter().find(|l| l["component"] == third)).cloned();
|
||
assert_eq!(block_link.map(|l| l["changed"].clone()), Some(json!(true)), "{links}");
|
||
// None it can read: an error, and nothing to undo.
|
||
let err = a.execute("component.update_links", &json!({"components": [third]})).unwrap_err().to_string();
|
||
assert!(err.contains("block"), "{err}");
|
||
// Malformed lists are refused.
|
||
for bad in
|
||
[json!({"components": []}), json!({"components": 3}), json!({"components": [first], "component": first}), json!({"components": ["nope"]})]
|
||
{
|
||
assert!(a.execute("component.update_links", &bad).is_err(), "{bad}");
|
||
}
|
||
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, ..Default::default() });
|
||
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, ..Default::default() });
|
||
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, ..Default::default() });
|
||
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| {
|
||
// Windows Git checkouts can use CRLF. Locate the test module in either
|
||
// representation, rather than mistaking its fixture file calls for product code.
|
||
let text = std::fs::read_to_string(root.join(file)).unwrap().replace("\r\n", "\n");
|
||
// 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");
|
||
}
|
||
}
|