Refuse sketch values that collapse a curve in settle_value_edit (#9729) (#9837)

* claim: #9729

* Refuse value edits that collapse a sketch curve: settle_value_edit runs settle's shrunk/flung checks (#9729)

* rustfmt

---------

Co-authored-by: Dahak Builds <dahakbuilds@users.noreply.github.com>
This commit is contained in:
Dahak Builds
2026-10-31 04:08:20 +00:00
committed by GitHub
parent f1c2fc8804
commit 91aefd5abc
4 changed files with 82 additions and 1 deletions
+1
View File
@@ -92,6 +92,7 @@ pub(crate) use sheet::{
mod silhouette;
mod sketch;
pub(crate) use sketch::author_path_for_rebind;
pub(crate) use sketch::collapse_reason;
pub(crate) use sketch::created as sketch_created;
mod canvas_sketch;
mod sketch_3d;
+50
View File
@@ -1145,3 +1145,53 @@ fn a_feature_on_a_failed_sketch_names_the_sketch() {
assert_eq!(r["errors"], json!([]), "{r}");
assert!(rel(volume(&mut s), 40.0 * 20.0 * 5.0 + 500.0) < 1e-9);
}
/// A finished sketch with one line (0,0)-(30,0) whose length is dimensioned to parameter `L`.
fn line_dimensioned_by_a_parameter() -> (Session, u64) {
let mut s = Session::default();
run(&mut s, "parameters.add", json!({"name": "L", "expression": "30"}));
run(&mut s, "sketch.create", json!({"plane": "XY"}));
run(&mut s, "sketch.line", json!({"points": [[0, 0], [30, 0]]}));
run(&mut s, "sketch.dimension", json!({"entities": ["l1"], "value": "L"}));
run(&mut s, "sketch.finish", json!({}));
let feature = s.doc.find_feature("Sketch1").map(|f| f.id).unwrap_or_default();
(s, feature)
}
/// #9729: `sketch.dimension` refuses 0 ("that would shrink l1 to a point") but a value edit
/// let it through: the line collapsed to a point and every later value counted as a conflict,
/// so only Undo recovered — and after a save and reopen there is no Undo. A value edit now
/// runs the same shrink/fling checks `settle` runs, so the zero is refused where it happens.
#[test]
fn a_parameter_that_shrinks_a_dimensioned_line_to_a_point_is_refused() {
let (mut s, feature) = line_dimensioned_by_a_parameter();
let e = err(&mut s, "parameters.change", json!({"name": "L", "expression": "0"}));
assert!(e.contains("shrink l1 to a point") && e.contains("the values were not changed"), "{e}");
// The line is where it was and the sketch still solves.
assert!((far_x(&s, feature) - 30.0).abs() < 1e-6);
assert!(s.model.state().sketch(feature).unwrap().report.keeps_orientation());
// Other values still work, in both directions: the sketch was never stored collapsed.
run(&mut s, "parameters.change", json!({"name": "L", "expression": "20"}));
assert!((far_x(&s, feature) - 20.0).abs() < 1e-6);
run(&mut s, "parameters.change", json!({"name": "L", "expression": "30"}));
assert!((far_x(&s, feature) - 30.0).abs() < 1e-6);
}
/// The largest x among the stored sketch's points: the line's far end.
fn far_x(s: &Session, feature: u64) -> f64 {
stored_points(s, feature).iter().map(|p| p.x).fold(f64::MIN, f64::max)
}
/// The same through a configuration row: activating a row whose value collapses the line is
/// refused, and the Default row can still be activated afterwards.
#[test]
fn a_configuration_row_that_shrinks_a_dimensioned_line_to_a_point_is_refused() {
let (mut s, feature) = line_dimensioned_by_a_parameter();
run(&mut s, "config.configure", json!({"params": ["L"]}));
run(&mut s, "config.row", json!({"name": "Zero", "values": {"param:L": "0"}}));
let e = err(&mut s, "config.activate", json!({"row": "Zero"}));
assert!(e.contains("shrink l1 to a point"), "{e}");
// The Default row still activates and the line is untouched.
run(&mut s, "config.activate", json!({"row": "Default"}));
assert!((far_x(&s, feature) - 30.0).abs() < 1e-6);
}
+15
View File
@@ -373,6 +373,21 @@ fn shrunk(before: &Sketch, after: &Sketch) -> Option<String> {
/// dimension value) has thrown the geometry to a far solution.
const FLUNG: f64 = 1000.0;
/// Why a solve from `before` into `after` collapses the sketch, in the words `settle` uses to
/// refuse an edit's solve: a line or circle shrunk to a point, or points thrown far away.
/// `None` when the solved shape is one the edit can mean. Value edits (`Session::settle_value_edit`)
/// run the same checks, so a parameter, a configuration row or the dimension editor cannot
/// store a sketch whose curve has been squeezed away and which can never be solved back.
pub(crate) fn collapse_reason(before: &Sketch, after: &Sketch) -> Option<String> {
if let Some(curve) = shrunk(before, after) {
return Some(format!("that would shrink {curve} to a point: its constraints can only be met without it"));
}
if flung(before, after) {
return Some("that would throw points of the sketch far away: its constraints have no solution near the sketch as it is".into());
}
None
}
/// Did solving `before` into `after` throw some point further than [`FLUNG`] times the sketch's
/// size, or to no number at all?
fn flung(before: &Sketch, after: &Sketch) -> bool {
+16 -1
View File
@@ -1231,6 +1231,10 @@ impl Session {
/// as before. Otherwise store each sketch whose values changed as solved, so the next edit
/// continues from it (see `Model::adopt_solved_sketches`).
pub(crate) fn settle_value_edit(&mut self, solved_before: &SketchValues) -> Result<()> {
// The solved geometry each sketch had before the edit, for the shrink/fling checks
// after the refresh below (the same checks `settle` runs on an edit's own solve).
let solved_geometry: std::collections::BTreeMap<u64, solidcraft_sketch::Sketch> =
self.model.results.iter().filter_map(|r| r.state.sketch(r.id).map(|k| (r.id, k.sketch.clone()))).collect();
// Quantity changes alter topology, so store the regenerated instances in the same
// transaction as the parameter edit. Later picks and undo must see those same ids.
let mut updated: Vec<_> = self
@@ -1259,10 +1263,21 @@ impl Session {
self.refresh();
for r in &self.model.results {
let (Some(before), Some(k)) = (solved_before.get(&r.id), r.state.sketch(r.id)) else { continue };
if !k.report.keeps_orientation() && own_values(&k.sketch) != *before {
if own_values(&k.sketch) == *before {
continue;
}
if !k.report.keeps_orientation() {
let why = k.report.failure(|f| format!("its constraints would conflict ({f})"));
return Err(EngineError::Other(format!("sketch `{}`: {why}; the values were not changed", r.name)));
}
// The value changed this sketch and it still solves: refuse it the way `settle`
// refuses an edit's solve when the curve was squeezed away or points thrown far,
// so a zero (or wild) value is never stored as a sketch that can't be solved back.
if let Some(before_sketch) = solved_geometry.get(&r.id)
&& let Some(why) = cmd::collapse_reason(before_sketch, &k.sketch)
{
return Err(EngineError::Other(format!("sketch `{}`: {why}; the values were not changed", r.name)));
}
}
// Checked first: storing makes the document unique (a copy when the undo step shares it).
if self.model.edited_sketches(&self.doc).next().is_some() {