Skip to content

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

Keep renamed bodies visible when reusing hidden names (#10163) (#10175)

Colin Faulkinghamed66adac5caa
diff --git a/crates/engine/src/cmd/browser.rs b/crates/engine/src/cmd/browser.rs
index af725ccf05..62f35bf281 100644
--- a/crates/engine/src/cmd/browser.rs
+++ b/crates/engine/src/cmd/browser.rs
@@ -1456,6 +1456,51 @@ mod tests {
assert!(!s.body_visible("Stud"));
}
+ #[test]
+ fn body_rename_reusing_a_hidden_name_preserves_visibility_and_history() {
+ for computed in [false, true] {
+ for hidden in [false, true] {
+ let mut s = Session::default();
+ two_boxes(&mut s);
+ let retired = s.doc.features[0].id;
+ run(&mut s, "browser.visibility", json!({"items": ["A"], "visible": false}));
+ run(&mut s, "timeline.delete", json!({"feature": retired}));
+ if hidden {
+ run(&mut s, "browser.visibility", json!({"items": ["B"], "visible": false}));
+ }
+ let before = s.visibility.clone();
+ assert_eq!(s.body_visible("B"), !hidden);
+ if computed {
+ let mut scratch = s.scratch();
+ run(&mut scratch, "body.rename", json!({"body": "B", "name": "A"}));
+ s.accept_computed(scratch);
+ } else {
+ run(&mut s, "body.rename", json!({"body": "B", "name": "A"}));
+ }
+ assert_eq!(names(&s), ["A"]);
+ assert_eq!(s.body_visible("A"), !hidden, "computed={computed}, hidden={hidden}: rename preserves visibility");
+ assert_eq!(s.visibility.hidden_bodies, if hidden { vec!["A"] } else { vec![] });
+ run(&mut s, "edit.undo", json!({}));
+ assert_eq!(names(&s), ["B"]);
+ assert_eq!(s.visibility, before, "undo restores the original hidden names, including the deleted body's");
+ assert_eq!(s.body_visible("B"), !hidden, "undo must not transfer the stale hide to B");
+ if !hidden {
+ run(&mut s, "edit.undo", json!({}));
+ assert_eq!(names(&s), ["A", "B"]);
+ assert!(!s.body_visible("A") && s.body_visible("B"), "restoring the deleted body restores its own visibility");
+ run(&mut s, "edit.redo", json!({}));
+ }
+ run(&mut s, "edit.redo", json!({}));
+ assert_eq!(s.body_visible("A"), !hidden, "redo preserves visibility");
+ let mut saved = (*s.doc).clone();
+ saved.visibility = s.visibility.clone();
+ let reopened = Session::new(serde_json::from_str(&serde_json::to_string(&saved).unwrap()).unwrap());
+ assert_eq!(names(&reopened), ["A"]);
+ assert_eq!(reopened.body_visible("A"), !hidden, "reopening preserves visibility");
+ }
+ }
+ }
+
#[test]
fn renamed_body_keeps_its_users() {
let mut s = Session::default();
diff --git a/crates/engine/src/cmd/occurrence_tests.rs b/crates/engine/src/cmd/occurrence_tests.rs
index e259e017b9..18dc2bff43 100644
--- a/crates/engine/src/cmd/occurrence_tests.rs
+++ b/crates/engine/src/cmd/occurrence_tests.rs
@@ -101,6 +101,38 @@ fn renaming_a_parent_preserves_hidden_nested_copies_with_ambiguous_labels() {
}
}
+#[test]
+fn body_rename_reusing_hidden_names_preserves_each_copy() {
+ let mut s = Session::default();
+ let (component, first) = created(&mut s, "Part");
+ let retired = run(&mut s, "solid.box", json!({"length": 5, "width": 5, "height": 5, "body_name": "Retired"}))["feature"].as_u64().unwrap();
+ run(&mut s, "solid.box", json!({"length": 5, "width": 5, "height": 5, "corner": [10, 0, 0], "body_name": "Visible"}));
+ let second = run(&mut s, "occurrence.copy", json!({"component": component, "translate": [20, 0, 0]}))["occurrence"].as_u64().unwrap();
+ let name = |s: &Session, source: &str, path: &[u64]| {
+ s.occurrence_placement(path).unwrap().bodies.iter().find(|b| b.source == source).unwrap().world.clone()
+ };
+ let retired_names = [name(&s, "Retired", &[first]), name(&s, "Retired", &[second])];
+ run(&mut s, "browser.visibility", json!({"items": retired_names, "visible": false}));
+ run(&mut s, "timeline.delete", json!({"feature": retired}));
+ let hidden = name(&s, "Visible", &[second]);
+ run(&mut s, "browser.visibility", json!({"items": [hidden], "visible": false}));
+ let before = s.visibility.clone();
+ for (command, params, source) in [
+ ("body.rename", json!({"body": "Visible", "name": "Retired"}), "Retired"),
+ ("edit.undo", json!({}), "Visible"),
+ ("edit.redo", json!({}), "Retired"),
+ ] {
+ run(&mut s, command, params);
+ assert!(s.body_visible(&name(&s, source, &[first])), "{command}: the first copy stays visible");
+ assert!(!s.body_visible(&name(&s, source, &[second])), "{command}: the second copy stays hidden");
+ if command == "edit.undo" {
+ assert_eq!(s.visibility, before);
+ } else {
+ assert_eq!(s.visibility.hidden_bodies, [name(&s, source, &[second])]);
+ }
+ }
+}
+
/// The world name of a placed body as `Document::world_body_name` worked it out before
/// `WorldNames` (each name scanning the whole design), kept to prove the two agree.
fn world_name_by_scanning(doc: &crate::doc::Document, st: &crate::doc::ModelState, source: &str, component: u64, path: &[u64]) -> String {
diff --git a/crates/engine/src/lib.rs b/crates/engine/src/lib.rs
index a906460bc5..591677e215 100644
--- a/crates/engine/src/lib.rs
+++ b/crates/engine/src/lib.rs
@@ -1097,16 +1097,19 @@ impl Session {
/// [`Session::refresh`] after the design changed from `previous`; a change that only renamed
/// a body or a feature (or undid or redid such a rename) renames it in the model instead,
/// which keeps every result and mesh (#3044).
- fn refresh_from(&mut self, previous: &Arc<Document>) {
- self.follow_plane_renames(previous);
- self.follow_axis_point_renames(previous);
+ fn refresh_from(&mut self, previous: &Arc<Document>, visibility_restored: bool) {
let rename = self.body_rename(previous);
- self.remap_hidden_bodies(previous, &self.model.state(), rename.as_ref().map(|(old, new, _)| (old.as_str(), new.as_str())));
- // Locked bodies follow the rename here rather than in `body.rename`, so a rename that
- // reaches the design any other way (undo, an outside edit) is covered too (#9737).
- if let Some((old, new, _)) = &rename {
- for b in self.visibility.locked_bodies.iter_mut().filter(|b| **b == *old) {
- *b = new.clone();
+ // Undo/redo restored visibility in the target document's names already. Remapping
+ // those names again can transfer a deleted body's stale hide to the restored body.
+ if !visibility_restored {
+ self.follow_plane_renames(previous);
+ self.follow_axis_point_renames(previous);
+ self.remap_hidden_bodies(previous, &self.model.state(), rename.as_ref().map(|(old, new, _)| (old.as_str(), new.as_str())));
+ // Locked bodies follow explicit renames and outside edits too (#9737).
+ if let Some((old, new, _)) = &rename {
+ for b in self.visibility.locked_bodies.iter_mut().filter(|b| **b == *old) {
+ *b = new.clone();
+ }
}
}
if let Some((old, new, names_only)) = rename
@@ -1515,7 +1518,7 @@ impl Session {
}
None if render_only => self.refresh_render(&previous_doc),
None if display_only => self.refresh_display(),
- None => self.refresh_from(&previous_doc),
+ None => self.refresh_from(&previous_doc, matches!(spec.id, "edit.undo" | "edit.redo")),
}
if pin {
self.pin_body_names();
diff --git a/crates/engine/src/occurrences.rs b/crates/engine/src/occurrences.rs
index a5cfae493e..816c567c40 100644
--- a/crates/engine/src/occurrences.rs
+++ b/crates/engine/src/occurrences.rs
@@ -297,21 +297,31 @@ impl Session {
}
let hidden: std::collections::BTreeSet<_> = self.visibility.hidden_bodies.iter().map(String::as_str).collect();
let mut names = std::collections::BTreeMap::new();
+ let mut destinations = std::collections::BTreeSet::new();
let (before, after) = (solidcraft_doc::WorldNames::new(previous, state), solidcraft_doc::WorldNames::new(&self.doc, &renamed));
for (component, path, _) in previous.placements() {
for body in state.bodies.iter().filter(|body| previous.model_body_component(body) == component) {
let old = before.name(&body.name, component, &path);
+ let source = rename.filter(|(old, _)| *old == body.name).map_or(body.name.as_str(), |(_, new)| new);
+ let new = after.name(source, component, &path);
+ if old != new {
+ destinations.insert(new.clone());
+ }
if hidden.contains(old.as_str()) || selected.contains(old.as_str()) {
- let source = rename.filter(|(old, _)| *old == body.name).map_or(body.name.as_str(), |(_, new)| new);
- names.insert(old, after.name(source, component, &path));
+ names.insert(old, new);
}
}
}
- for hidden in &mut self.visibility.hidden_bodies {
+ self.visibility.hidden_bodies.retain_mut(|hidden| {
if let Some(new) = names.get(hidden) {
hidden.clone_from(new);
+ true
+ } else {
+ // A deleted body's hidden name can be reused (#10163). Only a current
+ // body's hide follows into that name; a stale entry must not hide it.
+ !destinations.contains(hidden)
}
- }
+ });
for sel in &mut self.selection {
let name = match sel {
Sel::Body { name } => name,