Skip to content

SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.

Keep linked components valid through Undo after Save As (#6860) (#6877)

Colin Faulkingham03bf992bc182
diff --git a/apps/solidcraft-cli/src/main.rs b/apps/solidcraft-cli/src/main.rs
index 95aae0b843..26314b661e 100644
--- a/apps/solidcraft-cli/src/main.rs
+++ b/apps/solidcraft-cli/src/main.rs
@@ -262,8 +262,7 @@ fn load_checked(path: &str, check: solidcraft_engine::schema::ParamCheck) -> Res
let bytes = solidcraft_engine::io::vfs::read(path, solidcraft_engine::io::MAX_DESIGN_BYTES).map_err(|e| format!("{path}: {e}"))?;
if solidcraft_engine::io::is_design_container(&bytes) {
let doc = solidcraft_engine::io::read_design(&bytes).map_err(|e| format!("{path}: {e}"))?;
- let mut session = Session::new(doc);
- session.path = Some(path.to_owned());
+ let mut session = Session::opened_at(doc, None, Some(path));
session.param_check = check;
return Ok(session);
}
@@ -845,7 +844,7 @@ pub(crate) fn cmd_bench_open(args: &[String]) -> Result<(), String> {
return Ok(());
}
let t = std::time::Instant::now();
- let s = Session::opened(doc, saved.as_ref());
+ let s = Session::opened_at(doc, saved.as_ref(), (!step).then_some(path.as_str()));
drop(read);
// Taken from the file: nothing evaluated (SOLIDCRAFT_NO_MODEL_CACHE evaluates anyway), or
// only the features whose state a thinned file left out.
diff --git a/apps/solidcraft-web/src/files.rs b/apps/solidcraft-web/src/files.rs
index a04aa543a1..228924dc13 100644
--- a/apps/solidcraft-web/src/files.rs
+++ b/apps/solidcraft-web/src/files.rs
@@ -448,6 +448,18 @@ pub fn recovery_path() -> String {
format!("{OPFS}{RECOVERY}")
}
+/// A recovery file lives in OPFS, but its relative links belong to the original design's
+/// folder (which can be on disk). Resolve them before Open sees the temporary file location.
+pub fn prepare_recovery(original_path: Option<&str>) -> Result<String, String> {
+ let path = recovery_path();
+ let bytes = vfs::read(&path, solidcraft_engine::io::MAX_DESIGN_BYTES).map_err(|e| e.to_string())?;
+ let mut doc = solidcraft_engine::io::read_design(&bytes).map_err(|e| e.to_string())?;
+ solidcraft_engine::resolve_design_links(&mut doc, original_path);
+ let bytes = solidcraft_engine::io::write_design_container(&doc).map_err(|e| e.to_string())?;
+ vfs::insert(&path, bytes);
+ Ok(path)
+}
+
/// Pick files on the computer: the File System Access picker where there is one, else an
/// `<input type=file>`. Read files arrive in `files.incoming`.
pub fn pick_from_disk(files: &Rc<Files>, intent: Intent) {
diff --git a/apps/solidcraft-web/src/main.rs b/apps/solidcraft-web/src/main.rs
index 05ce3cc65b..0e0f427e86 100644
--- a/apps/solidcraft-web/src/main.rs
+++ b/apps/solidcraft-web/src/main.rs
@@ -498,15 +498,25 @@ mod web {
});
});
let Some(recover) = answer else { return };
- *self.files.recovery.borrow_mut() = None;
if recover {
- self.app.open_path(&files::recovery_path());
+ let recovery = match files::prepare_recovery(path.as_deref()) {
+ Ok(recovery) => recovery,
+ Err(error) => {
+ self.app.set_status(error, true);
+ return;
+ }
+ };
+ self.app.open_path(&recovery);
+ if self.app.session.path.as_deref() != Some(recovery.as_str()) {
+ return;
+ }
// It belongs to its own file again (saving goes there); it is unsaved.
self.app.session.path = path;
self.app.session.doc_mut().name = name;
self.app.session.mark_unsaved();
self.app.home.open = false;
}
+ *self.files.recovery.borrow_mut() = None;
files::autosave(&self.files, None);
}
diff --git a/crates/engine/src/cmd/component_extract.rs b/crates/engine/src/cmd/component_extract.rs
index e20e38ed31..e813a47675 100644
--- a/crates/engine/src/cmd/component_extract.rs
+++ b/crates/engine/src/cmd/component_extract.rs
@@ -592,7 +592,7 @@ pub(super) fn extract(s: &mut Session, p: &Value) -> Result<Value> {
f.link_faces = faces;
}
let path = stored(s.path.as_deref(), &file);
- s.doc_mut().links.insert(comp, DesignLink { path: path.clone(), feature: id });
+ s.doc_mut().links.insert(comp, DesignLink { path: file.to_string_lossy().into_owned(), feature: id });
s.refresh();
rename_joint_faces(s, &state, id, &sc.own);
if let Some(e) = s.model.result(id).and_then(|r| r.error.clone()) {
diff --git a/crates/engine/src/cmd/component_link.rs b/crates/engine/src/cmd/component_link.rs
index 1cfbdff3c9..e84d37bf92 100644
--- a/crates/engine/src/cmd/component_link.rs
+++ b/crates/engine/src/cmd/component_link.rs
@@ -2,9 +2,9 @@
//!
//! 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 file, relative to this design's folder once it
-//! is saved; Update Links reads the file 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
+//! 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.
@@ -124,6 +124,14 @@ pub(super) fn rebased(doc: &Document, from: Option<&str>, to: &str) -> std::coll
doc.links.iter().map(|(c, l)| (*c, DesignLink { path: stored(Some(to), &resolve(from, &l.path)), feature: l.feature })).collect()
}
+/// 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`).
type Linked = (String, solidcraft_io::StepFeature, Vec<Vec<String>>);
@@ -136,7 +144,7 @@ fn linked_bodies(file: &Path, own: Option<&str>) -> Result<Linked> {
}
let bytes = solidcraft_io::vfs::read(&shown, solidcraft_io::MAX_DESIGN_BYTES).map_err(|e| EngineError::Other(format!("{shown}: {e}")))?;
let doc = solidcraft_io::read_design(&bytes).map_err(|e| EngineError::Other(format!("{shown}: {e}")))?;
- session_bodies(&Session::new(doc), &shown)
+ session_bodies(&Session::opened_at(doc, None, Some(&shown)), &shown)
}
/// The solid bodies of `part`, the design saved as `shown`, as an Import feature.
@@ -212,7 +220,7 @@ fn insert_design(s: &mut Session, p: &Value) -> Result<Value> {
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: path.clone(), feature: id });
+ 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));
@@ -354,7 +362,7 @@ fn relink(s: &mut Session, p: &Value) -> Result<Value> {
f.kind = sf.kind;
f.link_faces = faces;
}
- s.doc_mut().links.insert(comp, DesignLink { path: path.clone(), feature: link.feature });
+ 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));
@@ -367,7 +375,8 @@ fn relink(s: &mut Session, p: &Value) -> Result<Value> {
for (_, name, why) in sol.errors.iter().chain(&sol.conflicts) {
warnings.push(format!("joint {name}: {why}"));
}
- Ok(json!({"component": comp, "feature": link.feature, "path": path, "previous_path": link.path, "geometry_changed": geometry_changed,
+ 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)}))
}
@@ -375,7 +384,7 @@ 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": link.path}))
+ 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> {
@@ -386,8 +395,9 @@ fn list_links(s: &mut Session, _p: &Value) -> Result<Value> {
.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();
- json!({"component": c, "name": name, "path": l.path, "file": file, "found": solidcraft_io::vfs::is_file(&file)})
+ json!({"component": c, "name": name, "path": path, "file": file, "found": solidcraft_io::vfs::is_file(&file)})
})
.collect();
Ok(json!({"links": links}))
@@ -436,6 +446,95 @@ mod tests {
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()));
diff --git a/crates/engine/src/cmd/file.rs b/crates/engine/src/cmd/file.rs
index acd5ff444b..785ecdf03b 100644
--- a/crates/engine/src/cmd/file.rs
+++ b/crates/engine/src/cmd/file.rs
@@ -304,8 +304,7 @@ fn open(s: &mut Session, p: &Value) -> Result<Value> {
if let Some(stem) = default_name_for(&doc.name, path) {
doc.name = stem;
}
- s.replace_design(Session::opened(doc, saved.as_ref()));
- s.path = Some(path.to_string());
+ s.replace_design(Session::opened_at(doc, saved.as_ref(), Some(path)));
s.disk = disk;
s.read_only = read_only;
let errors = s.model.results.iter().filter(|r| r.error.is_some()).count();
@@ -402,16 +401,7 @@ fn write_file(s: &mut Session, path: &str, format: &str, compression: &str, prev
"compact" => solidcraft_io::DesignCompression::Compact,
_ => return Err(bad("file.save", "compression must be fast or compact")),
};
- // Linked designs are kept relative to the folder the design is saved in.
- let links = super::component_link::rebased(&s.doc, s.path.as_deref(), path);
- let old_links = (links != s.doc.links).then(|| std::mem::replace(&mut s.doc_mut().links, links));
- let r = write_bytes(s, path, format, compression, preview, cache);
- if r.is_err()
- && let Some(old) = old_links
- {
- s.doc_mut().links = old;
- }
- r
+ write_bytes(s, path, format, compression, preview, cache)
}
fn write_bytes(
@@ -423,8 +413,8 @@ fn write_bytes(
cache: bool,
) -> Result<Value> {
let bytes = match format {
- "container" => s.design_container(compression, preview, cache)?,
- "json" => solidcraft_io::write_design(&s.design()),
+ "container" => s.design_container_at(Some(path), compression, preview, cache)?,
+ "json" => solidcraft_io::write_design(&s.design_at(Some(path))),
_ => return Err(bad("file.save", "format must be container or json")),
};
// Atomic, keeping the version being replaced as `<file>.bak`.
@@ -437,18 +427,39 @@ fn write_bytes(
}
impl Session {
+ /// Open a design with its file location, resolving component links before history keeps
+ /// them. Absolute in-memory targets survive Save As, undo, redo and recovery unchanged.
+ pub fn opened_at(mut doc: Document, saved: Option<&solidcraft_doc::SavedModel>, path: Option<&str>) -> Self {
+ super::component_link::resolve_design_links(&mut doc, path);
+ let mut session = Self::opened(doc, saved);
+ session.path = path.map(str::to_owned);
+ session
+ }
+
+ /// Prepare only the file's copy with relative paths; saving never rewrites live history.
+ pub(crate) fn design_at(&self, path: Option<&str>) -> std::borrow::Cow<'_, Document> {
+ let mut design = std::borrow::Cow::Borrowed(&*self.doc);
+ if let Some(path) = path {
+ let links = super::component_link::rebased(&self.doc, self.path.as_deref(), path);
+ if links != self.doc.links {
+ design.to_mut().links = links;
+ }
+ }
+ if !self.visibility.is_empty() {
+ design.to_mut().visibility = self.visibility.clone();
+ }
+ design
+ }
+
/// Take up a save that ran on `done`, a [`Session::scratch`] copy of this session that
/// `file.save` or `file.save_as` ran on (on another thread, so the window keeps drawing)
- /// while this one did not change: the name and link paths the save gave the design, its
+ /// while this one did not change: the name the save gave the design, its
/// file, and its saved state, as running the command here would have left them.
pub fn adopt_save(&mut self, done: &Session) {
if done.doc.name != self.doc.name {
let (from, to) = (self.doc.name.clone(), done.doc.name.clone());
rename_design(self, &from, &to);
}
- if done.doc.links != self.doc.links {
- self.doc_mut().links.clone_from(&done.doc.links);
- }
self.path.clone_from(&done.path);
self.disk = done.disk;
self.read_only = done.read_only;
@@ -467,7 +478,17 @@ impl Session {
/// Container bytes for desktop and browser saves. Only already evaluated bodies
/// and warm meshes are eligible; saving never forces evaluation or tessellation.
pub fn design_container(&self, compression: solidcraft_io::DesignCompression, preview: bool, cache: bool) -> solidcraft_io::Result<Vec<u8>> {
- let design = self.design();
+ self.design_container_at(self.path.as_deref(), compression, preview, cache)
+ }
+
+ fn design_container_at(
+ &self,
+ path: Option<&str>,
+ compression: solidcraft_io::DesignCompression,
+ preview: bool,
+ cache: bool,
+ ) -> solidcraft_io::Result<Vec<u8>> {
+ let design = self.design_at(path);
let geometry = cache.then(|| saved_geometry(self, &design)).flatten();
let preview = preview.then(|| saved_preview(self)).flatten();
let thumbnail = cache.then(|| thumbnail::saved(self)).flatten();
@@ -708,8 +729,7 @@ fn recover(s: &mut Session, p: &Value) -> Result<Value> {
if let Some(stem) = entry.path.as_deref().and_then(|path| default_name_for(&doc.name, path)) {
doc.name = stem;
}
- s.replace_design(Session::new(doc));
- s.path = entry.path.clone();
+ s.replace_design(Session::opened_at(doc, None, entry.path.as_deref()));
s.mark_unsaved();
if bool_(p, "discard").unwrap_or(false) {
crate::recovery::remove(&dir, id)?;
diff --git a/crates/engine/src/cmd/mod.rs b/crates/engine/src/cmd/mod.rs
index aefd20d6e3..1293c9818d 100644
--- a/crates/engine/src/cmd/mod.rs
+++ b/crates/engine/src/cmd/mod.rs
@@ -44,6 +44,7 @@ pub use sketch_modify::{extend_arc_preview, extend_preview, trim_piece};
pub use view_dxf::sketch::exportable as view_dxf_exportable;
pub use view_navigation::standard_view;
mod component_link;
+pub use component_link::resolve_design_links;
mod config;
mod file;
mod frame;
diff --git a/crates/engine/src/lib.rs b/crates/engine/src/lib.rs
index 8f8e493441..405e0f6dd3 100644
--- a/crates/engine/src/lib.rs
+++ b/crates/engine/src/lib.rs
@@ -38,7 +38,7 @@ use serde_json::Value;
use solidcraft_doc::{Document, Model, ModelState};
use solidcraft_geom::Vec3;
-pub use cmd::{CommandInfo, CommandSpec, auto_operation, command_specs, extrude_reach, find_command, standard_view};
+pub use cmd::{CommandInfo, CommandSpec, auto_operation, command_specs, extrude_reach, find_command, resolve_design_links, standard_view};
pub use solidcraft_doc as doc;
pub use solidcraft_doc::Visibility;
pub use solidcraft_geom as geom;
@@ -444,12 +444,15 @@ impl Default for Session {
}
impl Session {
+ /// A session on an in-memory document. For a document read from a file, use
+ /// [`Self::opened_at`] so relative component links are resolved against that file.
pub fn new(doc: Document) -> Self {
Self::opened(doc, None)
}
/// A session on `doc` whose evaluation is the model its file kept (`saved`), when that is
/// `doc`'s evaluation ([`Model::adopt`]); otherwise the timeline is evaluated.
+ /// Use [`Self::opened_at`] when the document's file location is known.
/// `SOLIDCRAFT_NO_MODEL_CACHE` set always evaluates.
pub fn opened(mut doc: Document, saved: Option<&solidcraft_doc::SavedModel>) -> Self {
// The session keeps what is hidden (an undo step of its own); the design file carries it.
@@ -608,14 +611,9 @@ impl Session {
Ok(())
}
- /// The design as a file holds it: the document with what is hidden in it.
+ /// The design as its current file holds it, including visibility and relative link paths.
pub fn design(&self) -> std::borrow::Cow<'_, Document> {
- if self.visibility.is_empty() {
- return std::borrow::Cow::Borrowed(&*self.doc);
- }
- let mut doc = (*self.doc).clone();
- doc.visibility = self.visibility.clone();
- std::borrow::Cow::Owned(doc)
+ self.design_at(self.path.as_deref())
}
/// The design has changes not in its file (a recovered design).
pub fn mark_unsaved(&mut self) {