A body rename changes names only, but committing it went through the general "design changed" path: the whole timeline was evaluated again. On an imported assembly that means reading the STEP file again and meshing every body (about 100 s on the Prusa Core One, and the same again for undo). When the only change from the previous design is one body rename (the features' stored body names and the body-keyed maps the rename updates), the model now renames the body in its results instead: every body keeps its geometry and meshes, and the fingerprints are set to the renamed design's so the next evaluation reuses everything. Undo and redo of the rename take the same path. A rename the model can't follow that way (the body is changed or named by a later feature, sheet metal, threads) still evaluates the design as before. `bench-open --ops script.json` times commands and their undo on an opened design, with the view work each leaves. Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
@@ -4,7 +4,7 @@
|
||||
//! solidcraft-cli run <script.json|design.solidcraft|part.step|mesh.3mf> [--in design|part.step|mesh.3mf] [--out FILE]... [--save FILE] [--quiet] [--results] [--timings] [--profile] [--json-out FILE] [--allow-errors]
|
||||
//! solidcraft-cli eval <script.json|design.solidcraft|part.step> [--json-out FILE] (alias: inspect) measurements as JSON
|
||||
//! solidcraft-cli script <design.solidcraft> [--out script.json] the design's history as a command script
|
||||
//! solidcraft-cli bench-open <design.solidcraft | part.step> [--parse-only] [--save OUT.solidcraft] [--display LEVEL [--edit NAME EXPR]] loading timings as JSON lines
|
||||
//! solidcraft-cli bench-open <design.solidcraft | part.step> [--parse-only] [--save OUT.solidcraft] [--display LEVEL [--edit NAME EXPR]] [--ops script.json] loading timings as JSON lines
|
||||
//! solidcraft-cli bench-agent [--scale F] [--save F] [--script-out F] a ~1,300-body design built command by command, timed
|
||||
//! solidcraft-cli snapshot <script|design> [--in design|part.step] --out shot.png [--width W] [--height H] [--view iso|front|top|…|NAME | --camera JSON] [--no-grid] [--no-axes]
|
||||
//! [--body NAME:opacity=0.3,color=#rrggbb]... [--tool NAME]... [--section z=27]
|
||||
@@ -50,7 +50,9 @@ const USAGE: &str = "usage:
|
||||
as plain UTF-8: a shell's > can re-encode it, e.g. Windows PowerShell adds a byte-order mark)
|
||||
solidcraft-cli script <design.solidcraft|script.json> [--out script.json]
|
||||
(the design's history as a command script that eval and run replay)
|
||||
solidcraft-cli bench-open <design.solidcraft | part.step> [--parse-only] [--save OUT.solidcraft] [--display LEVEL [--edit NAME EXPR]]
|
||||
solidcraft-cli bench-open <design.solidcraft | part.step> [--parse-only] [--save OUT.solidcraft] [--display LEVEL [--edit NAME EXPR]] [--ops script.json]
|
||||
(--ops: after opening, run each command of the script and undo it, timing the command, the
|
||||
evaluations it caused and the view it leaves: placing and meshing what changed)
|
||||
solidcraft-cli bench-agent [--scale F] [--save design.solidcraft] [--script-out script.json]
|
||||
solidcraft-cli snapshot <script|design> [--in design.solidcraft|part.step] --out shot.png [--width W] [--height H] [--view NAME | --camera JSON] [--no-grid] [--no-axes]
|
||||
[--body NAME:opacity=0.3,color=#rrggbb]... [--tool NAME]... [--section z=27]
|
||||
@@ -642,6 +644,36 @@ fn cmd_bench_edit(args: &[String]) -> Result<(), String> {
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// `bench-open --ops`: each command of `script` (a JSON array of `{command, params}`), then its
|
||||
/// undo, each timed as the command and the view it leaves (the placed model, its meshes warmed
|
||||
/// as the desktop does after a change).
|
||||
fn bench_ops(mut s: Session, script: &str) -> Result<Session, String> {
|
||||
let text = std::fs::read_to_string(script).map_err(|e| format!("{script}: {e}"))?;
|
||||
let ops: Value = serde_json::from_str(&text).map_err(|e| format!("{script}: {e}"))?;
|
||||
let ops = ops.as_array().ok_or("--ops: a JSON array of {command, params}")?;
|
||||
let time = |s: &mut Session, id: &str, p: &Value| -> Result<Value, String> {
|
||||
let t = std::time::Instant::now();
|
||||
let r = s.execute(id, p).map_err(|e| format!("{id}: {e}"))?;
|
||||
let ms = t.elapsed().as_secs_f64() * 1000.0;
|
||||
let t = std::time::Instant::now();
|
||||
s.world_state().warm_meshes(|| true);
|
||||
let view_ms = t.elapsed().as_secs_f64() * 1000.0;
|
||||
println!("{}", json!({"step": "op", "command": id, "ms": ms, "view_ms": view_ms}));
|
||||
Ok(r)
|
||||
};
|
||||
for op in ops {
|
||||
let id = op.get("command").and_then(Value::as_str).ok_or("--ops: each step needs a `command`")?;
|
||||
let p = op.get("params").cloned().unwrap_or(Value::Null);
|
||||
let steps = s.undo.len();
|
||||
time(&mut s, id, &p)?;
|
||||
// Commands that are no undo step (showing and hiding) have nothing to undo.
|
||||
if op.get("undo").and_then(Value::as_bool) != Some(false) && s.undo.len() > steps {
|
||||
time(&mut s, "edit.undo", &json!({}))?;
|
||||
}
|
||||
}
|
||||
Ok(s)
|
||||
}
|
||||
|
||||
/// Separate file reading, JSON decoding/repair, timeline evaluation and display meshing.
|
||||
pub(crate) fn cmd_bench_open(args: &[String]) -> Result<(), String> {
|
||||
let path = args.first().ok_or("usage: solidcraft-cli bench-open <design.solidcraft | part.step> [--parse-only]")?;
|
||||
@@ -727,6 +759,10 @@ pub(crate) fn cmd_bench_open(args: &[String]) -> Result<(), String> {
|
||||
// `--display LEVEL`: the display plans the viewport draws at that display quality, made as
|
||||
// the GPU viewport makes them; `--edit NAME EXPR` then changes a parameter and times the
|
||||
// evaluation and the plans of the bodies it changed.
|
||||
let s = match flag("--ops").and_then(|i| args.get(i + 1)) {
|
||||
Some(ops) => bench_ops(s, ops)?,
|
||||
None => s,
|
||||
};
|
||||
let Some(level) = flag("--display").and_then(|i| args.get(i + 1)) else { return Ok(()) };
|
||||
let q = solidcraft_engine::doc::display_quality::DisplayQuality::parse(level).ok_or("--display: coarse, normal, fine or ultra")?;
|
||||
let plans = |st: &solidcraft_engine::doc::ModelState| {
|
||||
|
||||
@@ -2637,6 +2637,87 @@ impl Document {
|
||||
}
|
||||
}
|
||||
|
||||
/// Rename body `old` to `new` where the design keeps things by body name outside its
|
||||
/// features: materials, appearances, configuration columns, offsets, components and the
|
||||
/// browser's groups and order. (The features are the rename command's to change.)
|
||||
pub fn rename_body_keys(&mut self, old: &str, new: &str) {
|
||||
if let Some(m) = self.materials.remove(old) {
|
||||
self.materials.insert(new.to_string(), m);
|
||||
}
|
||||
if let Some(c) = self.appearances.bodies.remove(old) {
|
||||
self.appearances.bodies.insert(new.to_string(), c);
|
||||
}
|
||||
for f in self.appearances.faces.iter_mut().filter(|f| f.body == old) {
|
||||
f.body = new.to_string();
|
||||
}
|
||||
for column in &mut self.configs.columns {
|
||||
match column {
|
||||
crate::config::Column::Material(body) | crate::config::Column::Appearance(body) if *body == old => {
|
||||
*body = new.to_string();
|
||||
}
|
||||
crate::config::Column::FaceAppearance(target) if target.body == old => {
|
||||
target.body = new.to_string();
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
if let Some(o) = self.body_offsets.remove(old) {
|
||||
self.body_offsets.insert(new.to_string(), o);
|
||||
}
|
||||
if let Some(c) = self.body_components.remove(old) {
|
||||
self.body_components.insert(new.to_string(), c);
|
||||
}
|
||||
for g in self.browser_groups.iter_mut().filter(|g| g.folder == "bodies") {
|
||||
for k in g.items.iter_mut().filter(|k| *k == old) {
|
||||
*k = new.to_string();
|
||||
}
|
||||
}
|
||||
for (_, v) in self.browser_order.iter_mut().filter(|(k, _)| k.ends_with("/bodies")) {
|
||||
for k in v.iter_mut().filter(|k| *k == old) {
|
||||
*k = new.to_string();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// The single body rename (old name, new name) that turns `previous` into this design,
|
||||
/// when that is all that changed: the features' stored body names (`made` gives the names
|
||||
/// each feature's bodies have now, by feature id) and what [`Document::rename_body_keys`]
|
||||
/// renames. `None` for any other change.
|
||||
pub fn body_rename_from(&self, previous: &Document, made: impl Fn(u64) -> Vec<String>) -> Option<(String, String)> {
|
||||
if self.features.len() != previous.features.len() {
|
||||
return None;
|
||||
}
|
||||
let mut rename: Option<(String, String)> = None;
|
||||
for (a, b) in previous.features.iter().zip(&self.features) {
|
||||
if a.id != b.id {
|
||||
return None;
|
||||
}
|
||||
if a.body_names == b.body_names {
|
||||
continue;
|
||||
}
|
||||
let now = made(a.id);
|
||||
for (k, name) in b.body_names.iter().enumerate() {
|
||||
let current = now.get(k);
|
||||
// Slots the rename left alone, and the ones it set to the names they have now.
|
||||
if a.body_names.get(k) == Some(name) || name.trim().is_empty() || current == Some(name) {
|
||||
continue;
|
||||
}
|
||||
let pair = (current?.clone(), name.clone());
|
||||
match &rename {
|
||||
Some(r) if *r != pair => return None,
|
||||
_ => rename = Some(pair),
|
||||
}
|
||||
}
|
||||
}
|
||||
let (old, new) = rename?;
|
||||
let mut expected = previous.clone();
|
||||
for (f, g) in expected.features.iter_mut().zip(&self.features) {
|
||||
f.body_names.clone_from(&g.body_names);
|
||||
}
|
||||
expected.rename_body_keys(&old, &new);
|
||||
(expected == *self).then_some((old, new))
|
||||
}
|
||||
|
||||
/// A complete structural proof: no non-render field is allowed to differ. Keeping this
|
||||
/// comparison based on the whole Document also includes fields added in future versions.
|
||||
/// The clone/comparison is only needed when render intent actually differs.
|
||||
|
||||
@@ -1494,6 +1494,58 @@ impl Model {
|
||||
}
|
||||
}
|
||||
|
||||
impl Model {
|
||||
/// Follow a rename of body `old` to `new` without evaluating anything (#3044): `doc` is the
|
||||
/// design after the rename, which changed nothing but names, so every result keeps its
|
||||
/// geometry and meshes and only the body's name (and the names worked out from it) changes.
|
||||
/// False, leaving the model as it was, when the rename can't be followed that way and the
|
||||
/// design must be evaluated: the model isn't the design's, the body is changed by a later
|
||||
/// feature, or is sheet metal, threaded, or named in a later feature's face references.
|
||||
pub fn rename_body(&mut self, doc: &Document, old: &str, new: &str) -> bool {
|
||||
if self.results.len() != doc.features.len() || self.results.iter().zip(&doc.features).any(|(r, f)| r.id != f.id || r.stale) {
|
||||
return false;
|
||||
}
|
||||
let Some(at) = self.results.iter().position(|r| r.state.body(old).is_some()) else { return false };
|
||||
let Some(made) = self.results.get(at).and_then(|r| r.state.body(old)).map(|b| Arc::as_ptr(&b.mesh)) else { return false };
|
||||
// Untouched from the feature that made it to the end, and nothing else holds its name.
|
||||
let untouched = self.results.iter().skip(at).all(|r| r.state.body(old).is_some_and(|b| Arc::as_ptr(&b.mesh) == made));
|
||||
let named_elsewhere = self
|
||||
.results
|
||||
.iter()
|
||||
.any(|r| r.state.body(new).is_some() || r.state.sheets.iter().any(|x| x.body == old) || r.state.threads.iter().any(|t| t.body == old));
|
||||
let faces_named = doc.features.iter().skip(at + 1).any(|f| f.face_names.iter().any(|n| n.contains(old)));
|
||||
if !untouched || named_elsewhere || faces_named {
|
||||
return false;
|
||||
}
|
||||
// States shared between results stay shared.
|
||||
let mut renamed: std::collections::HashMap<*const ModelState, Arc<ModelState>> = std::collections::HashMap::new();
|
||||
for r in self.results.iter_mut().skip(at) {
|
||||
let state = renamed
|
||||
.entry(Arc::as_ptr(&r.state))
|
||||
.or_insert_with(|| {
|
||||
let mut st = (*r.state).clone();
|
||||
for b in st.bodies.iter_mut().filter(|b| b.name == old) {
|
||||
b.name = new.to_string();
|
||||
b.names = b.names.renamed();
|
||||
}
|
||||
Arc::new(st)
|
||||
})
|
||||
.clone();
|
||||
r.state = state;
|
||||
}
|
||||
// The fingerprints of the renamed design, so the next evaluation reuses every result.
|
||||
let (vals, _) = evaluation_values(doc);
|
||||
let marker = doc.marker.unwrap_or(usize::MAX);
|
||||
self.step_digests = StepDigests::of(doc, &self.step_digests);
|
||||
let mut prev = 0;
|
||||
for (i, (r, f)) in self.results.iter_mut().zip(&doc.features).enumerate() {
|
||||
prev = chain_fingerprint(doc, &vals, f, prev, i >= marker, &self.step_digests);
|
||||
r.fingerprint = prev;
|
||||
}
|
||||
true
|
||||
}
|
||||
}
|
||||
|
||||
/// Key of the design's length unit (mm per unit) among the values (no parameter can be named
|
||||
/// so).
|
||||
pub(crate) const DESIGN_LEN: &str = "\u{1}design_len";
|
||||
|
||||
@@ -85,6 +85,17 @@ impl NameCell {
|
||||
pub(crate) fn id(&self) -> usize {
|
||||
Arc::as_ptr(&self.names) as usize
|
||||
}
|
||||
/// The same origin, lineage and depth with nothing worked out yet: for a body given a new
|
||||
/// name, whose faces' names may be made from it.
|
||||
pub(crate) fn renamed(&self) -> Self {
|
||||
NameCell {
|
||||
origin: self.origin.clone(),
|
||||
lineage: self.lineage.clone(),
|
||||
copy_of: self.copy_of.clone(),
|
||||
saved_depth: self.saved_depth,
|
||||
..NameCell::default()
|
||||
}
|
||||
}
|
||||
fn shared(names: Arc<Names>) -> Self {
|
||||
let cell = OnceLock::new();
|
||||
let _ = cell.set(names);
|
||||
|
||||
@@ -508,20 +508,6 @@ fn view_list(s: &mut Session, _p: &Value) -> Result<Value> {
|
||||
Ok(json!({ "views": s.doc.named_views }))
|
||||
}
|
||||
|
||||
/// Rename an item key in the browser's groups and orders of a folder.
|
||||
fn rename_key(d: &mut solidcraft_doc::Document, folder: &str, old: &str, new: &str) {
|
||||
for g in d.browser_groups.iter_mut().filter(|g| g.folder == folder) {
|
||||
for k in g.items.iter_mut().filter(|k| *k == old) {
|
||||
*k = new.to_string();
|
||||
}
|
||||
}
|
||||
for (_, v) in d.browser_order.iter_mut().filter(|(k, _)| k.ends_with(&format!("/{folder}"))) {
|
||||
for k in v.iter_mut().filter(|k| *k == old) {
|
||||
*k = new.to_string();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// The keys whose strings name bodies, alone or in a list (`body`, `targets`…), at any depth of a
|
||||
/// feature: its own fields and the face, edge and link references inside it.
|
||||
const BODY_KEYS: [&str; 5] = ["body", "bodies", "target", "targets", "tools"];
|
||||
@@ -638,33 +624,7 @@ fn rename_body(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
if let Some(e) = failed {
|
||||
return Err(bad(cmd, e));
|
||||
}
|
||||
if let Some(m) = d.materials.remove(&old) {
|
||||
d.materials.insert(name.to_string(), m);
|
||||
}
|
||||
if let Some(c) = d.appearances.bodies.remove(&old) {
|
||||
d.appearances.bodies.insert(name.to_string(), c);
|
||||
}
|
||||
for f in d.appearances.faces.iter_mut().filter(|f| f.body == old) {
|
||||
f.body = name.to_string();
|
||||
}
|
||||
for column in &mut d.configs.columns {
|
||||
match column {
|
||||
solidcraft_doc::config::Column::Material(body) | solidcraft_doc::config::Column::Appearance(body) if *body == old => {
|
||||
*body = name.to_string();
|
||||
}
|
||||
solidcraft_doc::config::Column::FaceAppearance(target) if target.body == old => {
|
||||
target.body = name.to_string();
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
if let Some(o) = d.body_offsets.remove(&old) {
|
||||
d.body_offsets.insert(name.to_string(), o);
|
||||
}
|
||||
if let Some(c) = d.body_components.remove(&old) {
|
||||
d.body_components.insert(name.to_string(), c);
|
||||
}
|
||||
rename_key(d, "bodies", &old, name);
|
||||
d.rename_body_keys(&old, name);
|
||||
for b in s.visibility.hidden_bodies.iter_mut().filter(|b| **b == old) {
|
||||
*b = name.to_string();
|
||||
}
|
||||
@@ -864,6 +824,44 @@ mod tests {
|
||||
assert!(names(&s).contains(&"Body2".to_string()) && names(&s).contains(&"Body4".to_string()), "{:?}", names(&s));
|
||||
}
|
||||
|
||||
/// #3044: a rename changes names only, so it, its undo and its redo evaluate nothing: every
|
||||
/// body keeps its geometry and display mesh, and the model is the one evaluating the renamed
|
||||
/// design gives.
|
||||
#[test]
|
||||
fn renaming_a_body_evaluates_nothing() {
|
||||
let mut s = Session::default();
|
||||
run(&mut s, "solid.box", json!({"length": 10, "width": 10, "height": 10, "body_name": "A"}));
|
||||
run(&mut s, "solid.box", json!({"length": 5, "width": 5, "height": 5, "center": [20, 0, 2.5], "operation": "new", "body_name": "B"}));
|
||||
run(&mut s, "appearance.assign", json!({"bodies": ["A"], "appearance": "Aluminum - Satin"}));
|
||||
let meshes = |s: &Session| s.model.state().bodies.iter().map(|b| std::sync::Arc::as_ptr(&b.mesh())).collect::<Vec<_>>();
|
||||
let shown = meshes(&s);
|
||||
s.evaluations = 0;
|
||||
run(&mut s, "body.rename", json!({"body": "A", "name": "Plate"}));
|
||||
assert_eq!(s.evaluations, 0, "a rename evaluates nothing");
|
||||
assert_eq!(names(&s), vec!["Plate".to_string(), "B".to_string()]);
|
||||
assert_eq!(meshes(&s), shown, "the bodies keep their meshes");
|
||||
assert!(s.doc.appearances.bodies.contains_key("Plate"));
|
||||
// The same model as evaluating the renamed design.
|
||||
let mut fresh = Session::new((*s.doc).clone());
|
||||
fresh.refresh();
|
||||
assert_eq!(names(&fresh), names(&s));
|
||||
s.refresh();
|
||||
assert_eq!(s.model.last_recomputed, 0, "the next evaluation reuses every result");
|
||||
s.evaluations = 0;
|
||||
run(&mut s, "edit.undo", json!({}));
|
||||
assert_eq!(names(&s), vec!["A".to_string(), "B".to_string()]);
|
||||
run(&mut s, "edit.redo", json!({}));
|
||||
assert_eq!(names(&s), vec!["Plate".to_string(), "B".to_string()]);
|
||||
assert_eq!(s.evaluations, 0, "undo and redo of a rename evaluate nothing");
|
||||
assert_eq!(meshes(&s), shown);
|
||||
// A body a later feature uses is renamed in that feature too: that is evaluated.
|
||||
run(&mut s, "solid.combine", json!({"target": "Plate", "tools": ["B"], "operation": "join", "keep_tools": true}));
|
||||
s.evaluations = 0;
|
||||
run(&mut s, "body.rename", json!({"body": "B", "name": "Tool"}));
|
||||
assert!(s.evaluations > 0);
|
||||
assert!(names(&s).contains(&"Tool".to_string()));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn renaming_a_body_leaves_other_text_with_its_name_alone() {
|
||||
let mut s = Session::default();
|
||||
|
||||
@@ -149,6 +149,14 @@ pub enum Sel {
|
||||
},
|
||||
}
|
||||
|
||||
/// A body rename between two designs (see `Session::body_renames`).
|
||||
struct BodyRename {
|
||||
before: std::sync::Weak<Document>,
|
||||
after: std::sync::Weak<Document>,
|
||||
old: String,
|
||||
new: String,
|
||||
}
|
||||
|
||||
/// One undo step.
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct Snapshot {
|
||||
@@ -246,6 +254,9 @@ pub struct Session {
|
||||
/// Pairs `inspect.clearance` measured, by the bodies' geometry where they stood (shared with
|
||||
/// scratch copies): a body that did not change or move is not measured again.
|
||||
clearance_cache: std::sync::Arc<std::sync::Mutex<cmd::clearance::PairCache>>,
|
||||
/// Recent body renames: the design before and after each, and the names, so undo and redo
|
||||
/// follow them without evaluating either.
|
||||
body_renames: Vec<BodyRename>,
|
||||
/// Features copied with `timeline.copy` (pasted by `timeline.paste`).
|
||||
pub clipboard: Vec<solidcraft_doc::Feature>,
|
||||
/// Sketch geometry copied with `sketch.copy` (pasted by `sketch.paste`).
|
||||
@@ -399,6 +410,7 @@ impl Session {
|
||||
occurrence_visibility_cache: Default::default(),
|
||||
removed_later_cache: Default::default(),
|
||||
clearance_cache: Default::default(),
|
||||
body_renames: Vec::new(),
|
||||
clipboard: Vec::new(),
|
||||
sketch_clipboard: None,
|
||||
section: None,
|
||||
@@ -620,6 +632,47 @@ impl Session {
|
||||
}
|
||||
}
|
||||
|
||||
/// [`Session::refresh`] after the design changed from `previous`; a change that only renamed
|
||||
/// a body (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>) {
|
||||
if let Some((old, new)) = self.body_rename(previous)
|
||||
&& self.model.rename_body(&self.doc, &old, &new)
|
||||
{
|
||||
self.revision += 1;
|
||||
if !self.doc.assembly.joints.is_empty() {
|
||||
cmd::joints::resolve(self);
|
||||
}
|
||||
return;
|
||||
}
|
||||
self.refresh();
|
||||
}
|
||||
|
||||
/// The body rename that turned `previous` into the design (old name, new name), if that is
|
||||
/// the whole change: one this session made (either way round), else one the designs show.
|
||||
fn body_rename(&mut self, previous: &Arc<Document>) -> Option<(String, String)> {
|
||||
let holds = |w: &std::sync::Weak<Document>, d: &Arc<Document>| w.upgrade().is_some_and(|x| Arc::ptr_eq(&x, d));
|
||||
self.body_renames.retain(|r| r.before.strong_count() > 0 && r.after.strong_count() > 0);
|
||||
for r in &self.body_renames {
|
||||
if holds(&r.before, previous) && holds(&r.after, &self.doc) {
|
||||
return Some((r.old.clone(), r.new.clone()));
|
||||
}
|
||||
if holds(&r.after, previous) && holds(&r.before, &self.doc) {
|
||||
return Some((r.new.clone(), r.old.clone()));
|
||||
}
|
||||
}
|
||||
let model = &self.model;
|
||||
let made = |id: u64| -> Vec<String> {
|
||||
model.result(id).map(|r| r.state.bodies.iter().filter(|b| b.feature == id).map(|b| b.name.clone()).collect()).unwrap_or_default()
|
||||
};
|
||||
let (old, new) = self.doc.body_rename_from(previous, made)?;
|
||||
self.body_renames.push(BodyRename { before: Arc::downgrade(previous), after: Arc::downgrade(&self.doc), old: old.clone(), new: new.clone() });
|
||||
if self.body_renames.len() > MAX_UNDO {
|
||||
self.body_renames.remove(0);
|
||||
}
|
||||
Some((old, new))
|
||||
}
|
||||
|
||||
/// Only persistent render intent, or only part properties, changed. Never evaluate or clear
|
||||
/// a stale model here.
|
||||
fn render_only_change(&self, before: &Snapshot) -> bool {
|
||||
@@ -766,7 +819,7 @@ impl Session {
|
||||
match live_edit {
|
||||
Some(edit) => self.refresh_live(edit),
|
||||
None if render_only => self.refresh_render(&previous_doc),
|
||||
None => self.refresh(),
|
||||
None => self.refresh_from(&previous_doc),
|
||||
}
|
||||
}
|
||||
Ok(v)
|
||||
@@ -874,6 +927,7 @@ impl Session {
|
||||
occurrence_visibility_cache: Default::default(),
|
||||
removed_later_cache: Default::default(),
|
||||
clearance_cache: self.clearance_cache.clone(),
|
||||
body_renames: Vec::new(),
|
||||
clipboard: self.clipboard.clone(),
|
||||
sketch_clipboard: self.sketch_clipboard.clone(),
|
||||
section: None,
|
||||
|
||||
@@ -3791,3 +3791,37 @@ fn a_tapered_side_drawn_in_two_collinear_pieces_is_one_face() {
|
||||
let m = run(&mut s, "inspect.measure", json!({}));
|
||||
assert_eq!(m["bodies"][0]["kernel"]["faces"], 6, "{m}");
|
||||
}
|
||||
|
||||
/// #3044: renaming a body of an imported assembly (a part placed twice, so the file has more
|
||||
/// solids than the part has bodies) evaluates nothing, not even the file again, and leaves the
|
||||
/// model evaluating the renamed design gives; undo does the same.
|
||||
#[test]
|
||||
fn renaming_an_imported_assembly_body_reads_nothing_again() {
|
||||
let dir = std::env::temp_dir().join(format!("solidcraft-step-rename-{}", std::process::id()));
|
||||
std::fs::create_dir_all(&dir).unwrap();
|
||||
let mut a = Session::default();
|
||||
run(&mut a, "solid.box", json!({"length": 10, "width": 10, "height": 10, "body_name": "Cube"}));
|
||||
run(&mut a, "solid.box", json!({"length": 4, "width": 4, "height": 4, "center": [30, 0, 2], "operation": "new", "body_name": "Pin"}));
|
||||
run(&mut a, "component.from_bodies", json!({"bodies": ["Cube"]}));
|
||||
run(&mut a, "occurrence.copy", json!({"component": "Cube", "translate": [0, 40, 0]}));
|
||||
let p = dir.join("Assembly.step");
|
||||
run(&mut a, "file.export", json!({"path": p.to_string_lossy()}));
|
||||
let mut s = Session::default();
|
||||
run(&mut s, "doc.open", json!({"path": p.to_string_lossy()}));
|
||||
let names = |s: &Session| s.model.state().bodies.iter().map(|b| b.name.clone()).collect::<Vec<_>>();
|
||||
let before = names(&s);
|
||||
let body = before.first().cloned().unwrap();
|
||||
s.evaluations = 0;
|
||||
run(&mut s, "body.rename", json!({"body": body, "name": "Renamed"}));
|
||||
assert_eq!(s.evaluations, 0, "a rename evaluates nothing");
|
||||
let after = names(&s);
|
||||
assert_eq!(after.first().map(String::as_str), Some("Renamed"));
|
||||
assert_eq!(after.len(), before.len());
|
||||
let mut fresh = Session::new((*s.doc).clone());
|
||||
fresh.refresh();
|
||||
assert_eq!(names(&fresh), after, "the same names as evaluating the renamed design");
|
||||
run(&mut s, "edit.undo", json!({}));
|
||||
assert_eq!(names(&s), before);
|
||||
assert_eq!(s.evaluations, 0, "nor does its undo");
|
||||
let _ = std::fs::remove_dir_all(&dir);
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user