feat: preserve adaptive sketch profiles and curved modeling workflows

crates/engine/src/cmd/offset_edit_guard_tests.rs

@@ -0,0 +1,183 @@
+#![allow(clippy::unwrap_used, clippy::panic)]
+use serde_json::{Value, json};
+use solvecraft_doc::{Document, FeatureKind, ProfileSel};
+use solvecraft_geom::Vec2;
+use solvecraft_sketch::{CurveKind, Sketch};
+
+use crate::{Session, Snapshot};
+
+fn run(s: &mut Session, command: &str, params: Value) -> Value {
+    s.execute(command, &params).unwrap_or_else(|error| panic!("{command}: {error}"))
+}
+fn rounded() -> (Session, u64, String) {
+    let mut s = Session::default();
+    run(&mut s, "sketch.create", json!({"plane":"XY","name":"Rounded"}));
+    let sketch = s.active_sketch.unwrap();
+    run(&mut s, "sketch.rectangle.two_point", json!({"p0":[-38,-33],"p1":[38,33]}));
+    let fillet = run(&mut s, "sketch.fillet", json!({"points":["l1.start","l1.end","l2.end","l3.end"],"radius":"1 mm"}));
+    (s, sketch, fillet["param"].as_str().unwrap().into())
+}
+fn offset(s: &mut Session, curve: &str, distance: f64) -> (String, Vec<String>) {
+    let result = run(s, "sketch.offset", json!({"curves":[curve],"distance":distance,"side":[0,0]}));
+    (result["association"].as_str().unwrap().into(), result["curves"].as_array().unwrap().iter().map(|v| v.as_str().unwrap().into()).collect())
+}
+fn solved(s: &Session, id: u64) -> Sketch {
+    s.model.state().sketch(id).unwrap().sketch.clone()
+}
+fn arc_centres(sk: &Sketch, curves: &[String]) -> Vec<(String, usize, Vec2)> {
+    curves
+        .iter()
+        .filter_map(|id| {
+            let CurveKind::Arc { c, .. } = sk.curves.get(sk.curve_index(id)?)?.kind else { return None };
+            Some((id.clone(), c, sk.point(c)?))
+        })
+        .collect()
+}
+fn history(stack: &[Snapshot]) -> Vec<(String, String, Option<u64>, String)> {
+    stack.iter().map(|entry| (entry.label.clone(), entry.doc.to_json(), entry.active_sketch, format!("{:?}", entry.pending_moves))).collect()
+}
+fn refuses_atomically(s: &mut Session, command: &str, params: Value) -> String {
+    let document = s.doc.to_json();
+    let undo = history(&s.undo);
+    let redo = history(&s.redo);
+    let active = s.active_sketch;
+    let error = s.execute(command, &params).unwrap_err().to_string();
+    assert_eq!(s.doc.to_json(), document);
+    assert_eq!(history(&s.undo), undo);
+    assert_eq!(history(&s.redo), redo);
+    assert_eq!(s.active_sketch, active);
+    error
+}
+
+#[test]
+fn offset_guard_retired_parent_refuses_new_child_without_destroying_redo() {
+    let (mut s, sketch, _) = rounded();
+    let (_, outputs) = offset(&mut s, "l1", 1.4);
+    assert_eq!(outputs.len(), 4);
+    assert_eq!(solved(&s, sketch).offsets[0].topology.as_ref().unwrap().roles.iter().filter(|r| r.retired).count(), 4);
+    run(&mut s, "sketch.point", json!({"point":[100,100]}));
+    run(&mut s, "edit.undo", json!({}));
+    assert!(!s.redo.is_empty());
+    let error = refuses_atomically(&mut s, "sketch.offset", json!({"curves":[outputs[0]],"distance":0.2,"side":[0,0]}));
+    assert!(error.contains("retired corner") && error.contains("break its offset association"), "{error}");
+}
+
+#[test]
+fn offset_guard_live_child_follows_radius_then_retirement_is_honest() {
+    let (mut s, sketch, radius) = rounded();
+    let (_, parent) = offset(&mut s, "l1", 0.2);
+    let (child_association, child) = offset(&mut s, &parent[0], 0.2);
+    let arc_radius = |s: &Session| {
+        let sk = solved(s, sketch);
+        child
+            .iter()
+            .filter_map(|id| {
+                let CurveKind::Arc { c, a, .. } = sk.curves.get(sk.curve_index(id)?)?.kind else { return None };
+                Some(sk.point(c)?.dist(sk.point(a)?))
+            })
+            .collect::<Vec<_>>()
+    };
+    assert_eq!(arc_radius(&s).len(), 4);
+    assert!(arc_radius(&s).iter().all(|r| (*r - 0.6).abs() < 1e-6));
+    run(&mut s, "parameters.change", json!({"name":radius,"expression":"2 mm"}));
+    assert!(s.model.results.iter().all(|r| r.error.is_none()));
+    assert!(arc_radius(&s).iter().all(|r| (*r - 1.6).abs() < 1e-6));
+    run(&mut s, "sketch.finish", json!({}));
+    run(
+        &mut s,
+        "solid.extrude",
+        json!({"sketch":sketch,"profiles":{"offset_boundaries":[child_association]},"distance":2,"operation":"new","body_name":"Child"}),
+    );
+    let before = s.doc.to_json();
+    let undo = history(&s.undo);
+    let redo = history(&s.redo);
+    match s.execute("parameters.change", &json!({"name":radius,"expression":"0.1 mm"})) {
+        Err(error) => {
+            assert!(error.to_string().contains("offset"), "{error}");
+            assert_eq!(s.doc.to_json(), before);
+            assert_eq!(history(&s.undo), undo);
+            assert_eq!(history(&s.redo), redo);
+        }
+        Ok(_) => {
+            assert!(s.model.results.iter().any(|r| r.error.is_some()), "retired parent must not keep a stale successful child");
+            assert!(s.world_state().body("Child").is_none());
+            let reopened = Session::new(Document::from_json(&s.doc.to_json()).unwrap());
+            assert!(reopened.model.results.iter().any(|r| r.error.is_some()));
+            assert!(reopened.world_state().body("Child").is_none());
+        }
+    }
+}
+
+#[test]
+fn offset_guard_partial_delete_requires_break_and_surviving_arc_centres_detach() {
+    let (mut s, sketch, _) = rounded();
+    let (association, outputs) = offset(&mut s, "l1", 0.2);
+    let error = refuses_atomically(&mut s, "sketch.delete", json!({"entities":[outputs[0]]}));
+    assert!(error.contains("break the offset association"), "{error}");
+    let source = solved(&s, sketch);
+    let source_ids: Vec<_> = source.curves.iter().filter(|c| !outputs.contains(&c.id)).map(|c| c.id.clone()).collect();
+    let source_centres = arc_centres(&source, &source_ids);
+    assert_eq!(source_centres.len(), 4);
+    run(&mut s, "sketch.offset.break", json!({"curve":association}));
+    let released = solved(&s, sketch);
+    let independent = arc_centres(&released, &outputs);
+    assert_eq!(independent.len(), 4);
+    assert!(independent.iter().all(|(_, centre, _)| source_centres.iter().all(|(_, source, _)| centre != source)));
+    // Released geometry is editable: anchor its new centres independently, then
+    // move a source centre. Shared source nodes would block that actual move.
+    let released_centres: Vec<_> = independent.iter().map(|(id, _, _)| format!("{id}.center")).collect();
+    run(&mut s, "sketch.constraint.fix", json!({"entities":released_centres,"fixed":true}));
+    run(&mut s, "sketch.delete", json!({"entities":[outputs[0]]}));
+    let deleted = solved(&s, sketch);
+    assert!(deleted.curve_index(&outputs[0]).is_none());
+    let survivors = arc_centres(&deleted, &outputs);
+    let (source_id, _, position) = source_centres.first().unwrap();
+    let target = *position + Vec2::new(5.0, 5.0);
+    run(&mut s, "sketch.move_point", json!({"point":format!("{source_id}.center"),"to":[target.x,target.y]}));
+    assert!(s.model.results.iter().all(|r| r.error.is_none()));
+    let changed = solved(&s, sketch);
+    for (id, _, position) in independent {
+        let after = arc_centres(&changed, std::slice::from_ref(&id));
+        assert_eq!(after.len(), 1);
+        assert!(
+            after[0].2.dist(position) < 1e-8,
+            "{id}: released {position:?}, after deletion {:?}, after source move {:?}; deleted curve {}",
+            survivors.iter().find(|(curve, _, _)| curve == &id),
+            after[0],
+            outputs[0]
+        );
+    }
+    let moved = arc_centres(&changed, std::slice::from_ref(source_id));
+    assert_eq!(moved.len(), 1);
+    assert!(moved[0].2.dist(target) < 1e-8);
+    assert!(moved[0].2.dist(*position) > 5.0);
+}
+
+#[test]
+fn offset_guard_complete_delete_keeps_dangling_profile_loadable_without_circle_retarget() {
+    let (mut s, sketch, _) = rounded();
+    let (association, outputs) = offset(&mut s, "l1", 0.2);
+    run(&mut s, "sketch.circle.center", json!({"center":[100,0],"radius":3,"id":"Unrelated"}));
+    run(&mut s, "sketch.finish", json!({}));
+    run(
+        &mut s,
+        "solid.extrude",
+        json!({"sketch":sketch,"profiles":{"offset_boundaries":[association]},"distance":2,"operation":"new","name":"OffsetBody","body_name":"Selected"}),
+    );
+    run(&mut s, "sketch.edit", json!({"sketch":sketch}));
+    run(&mut s, "sketch.delete", json!({"entities":outputs}));
+    let saved = s.doc.to_json();
+    let FeatureKind::Extrude { profiles: ProfileSel::OffsetBoundaries { associations }, .. } = &s.doc.find_feature("OffsetBody").unwrap().kind else {
+        panic!("explicit offset identity lost")
+    };
+    assert_eq!(associations, &vec![association]);
+    let check = |s: &Session| {
+        assert!(solved(s, sketch).curve_index("Unrelated").is_some());
+        assert!(s.model.results.iter().find(|r| r.id == s.doc.find_feature("OffsetBody").unwrap().id).unwrap().error.is_some());
+        assert!(s.world_state().body("Selected").is_none(), "dangling selection must never adopt the unrelated circle");
+    };
+    check(&s);
+    let reopened = Session::new(Document::from_json(&saved).unwrap());
+    check(&reopened);
+    assert_eq!(reopened.doc.to_json(), saved);
+}