* claim: #9625 Signed-off-by: Maurizio Monticelli <maurizio@whatwedo.ch> * Name the value at fault when a hole, sheet rule, joint or extrude is refused (#9625) Several refusals were right but named a check the input had passed, so the user changed the wrong field: - solid.hole: an unknown `fit` was reported as an unknown bolt size; it now says the fit must be close, normal or loose. A countersink angle out of range was reported as a countersink too narrow; the angle and the width are now checked apart. A `diameter` number out of range was reported as missing; it now gives the range, as other parameters do. - Sheet rules: a thickness of 10000 mm or more said "must be positive"; it now gives both limits. The K-factor and the bend radius are named on their own, and the message no longer implies a radius of 0 is refused. - joint.drive: a number out of range said "numbers or expressions"; it now gives the range. - Extrude: a distance past the kernel's limit said `end = 1000000000`; it now says the extrusion is too long and gives the limit. Fixes #9625 Signed-off-by: Maurizio Monticelli <maurizio@whatwedo.ch> * Refuse a too-long extrusion before the kernel and match the countersink floor (#9625) The kernel is paused, and its `finite()` check also guards a revolve's angle and a cylinder's and a torus's sizes, so its message must not say "extrusion". crates/kernel is back as it was; the doc evaluator now refuses an extrude (plain, tapered, or redefined from the Edit Extrude dialog) whose end lies 10000000 mm or more from the sketch plane, mirroring the kernel's limit, and says so. A cylinder of radius 2e7 keeps the kernel's own message. The countersink check refused 0.1° while the message said "more than 0°". The floor stays (the cone grows as 1 / tan of the half angle) and the message now names it: more than 0.115°. Signed-off-by: Maurizio Monticelli <maurizio@whatwedo.ch> --------- Signed-off-by: Maurizio Monticelli <maurizio@whatwedo.ch>
This commit is contained in:
+29
-1
@@ -4659,7 +4659,17 @@ fn hole_tools_and_prisms(
|
||||
}
|
||||
HoleKind::Countersink { cs_diameter, cs_angle, tip_angle } => {
|
||||
let (rc, half) = (val(vals, cs_diameter, Kind::Length)? / 2.0, val(vals, cs_angle, Kind::Angle)? / 2.0);
|
||||
if !(rc > r && half > 1e-3 && half < std::f64::consts::FRAC_PI_2) {
|
||||
// The angle and the width are told apart: an angle out of range is not a countersink
|
||||
// too narrow (#9625). The cone's length grows as 1 / tan(half), so a near-flat angle
|
||||
// is refused at a floor the message names, rather than built kilometres long.
|
||||
const MIN_ANGLE_DEG: f64 = 0.115;
|
||||
if !(2.0 * half > MIN_ANGLE_DEG.to_radians() && half < std::f64::consts::FRAC_PI_2) {
|
||||
return Err(DocError::Invalid(format!(
|
||||
"the countersink angle must be more than {MIN_ANGLE_DEG}° and less than 180°, not {}°",
|
||||
((2.0 * half).to_degrees() * 1e6).round() / 1e6
|
||||
)));
|
||||
}
|
||||
if !(rc > r) {
|
||||
return Err(DocError::Invalid("the countersink must be wider than the hole".into()));
|
||||
}
|
||||
// One revolved tool: the cone from its rim on the face to just inside the hole
|
||||
@@ -4864,6 +4874,22 @@ struct ExtrudeConstructor {
|
||||
interval: (f64, f64),
|
||||
}
|
||||
|
||||
/// How far from its sketch plane an extrude may reach, in mm. It mirrors the limit the kernel's
|
||||
/// `finite` check in `crates/kernel/src/build.rs` puts on an extrusion's start and end (a literal
|
||||
/// there, not exported), so a too-long extrusion is refused here, by name, before the kernel is
|
||||
/// called: the kernel's own message, `end = 1000000000`, names no field (#9625).
|
||||
const MAX_EXTRUDE_REACH: f64 = 1e7;
|
||||
|
||||
/// Refuse an extrusion whose ends lie past [`MAX_EXTRUDE_REACH`] from the sketch plane.
|
||||
fn extrude_within_reach(ends: [f64; 2]) -> Result<()> {
|
||||
match ends.into_iter().find(|x| x.abs() >= MAX_EXTRUDE_REACH) {
|
||||
Some(x) => Err(DocError::Invalid(format!(
|
||||
"the extrusion is too long: its end is {x} mm from the sketch plane, past the limit of {MAX_EXTRUDE_REACH} mm"
|
||||
))),
|
||||
None => Ok(()),
|
||||
}
|
||||
}
|
||||
|
||||
/// Construct planar caps locally before placing the completed tool.
|
||||
fn centered_extrude(
|
||||
plane: &Plane,
|
||||
@@ -5047,6 +5073,7 @@ fn feature_tools_with_constructor(
|
||||
Some(e) => val(vals, e, Kind::Length)?,
|
||||
None => 0.0,
|
||||
};
|
||||
extrude_within_reach([base, base + sign * len])?;
|
||||
let start_plane = ss.plane.offset(base);
|
||||
let caps = [
|
||||
Some(crate::lineage::extrude_cap_role(base)),
|
||||
@@ -5116,6 +5143,7 @@ fn feature_tools_with_constructor(
|
||||
lo = hs.iter().cloned().fold(lo, f64::min) - margin;
|
||||
}
|
||||
}
|
||||
extrude_within_reach([lo + off, hi + off])?;
|
||||
let untrimmed = extent.to.is_none() && extent.from.is_none() && !extent.through_all;
|
||||
let mut tools = Vec::new();
|
||||
for r in ®ions {
|
||||
|
||||
+11
-4
@@ -451,6 +451,9 @@ pub struct RuleValues {
|
||||
pub angle_display: AngleDisplay,
|
||||
}
|
||||
|
||||
/// A sheet rule's thickness is less than this (mm).
|
||||
const MAX_SHEET_THICKNESS: f64 = 1e4;
|
||||
|
||||
impl Document {
|
||||
/// A rule by name, the active one, or the default steel rule.
|
||||
pub fn sheet_rule(&self, name: Option<&str>) -> SheetRule {
|
||||
@@ -474,8 +477,8 @@ impl Document {
|
||||
Some(t) => t,
|
||||
None => expr::eval_with(&r.thickness, &look)?.to_kind(Kind::Length)?,
|
||||
};
|
||||
if !(t > 0.0 && t < 1e4) {
|
||||
return Err(DocError::Invalid("the sheet thickness must be positive".into()));
|
||||
if !(t > 0.0 && t < MAX_SHEET_THICKNESS) {
|
||||
return Err(DocError::Invalid("the sheet thickness must be more than 0 and less than 10000 mm".into()));
|
||||
}
|
||||
let with_t = |e: &str, k: Kind| -> Result<f64> {
|
||||
let f = |n: &str| if n == "Thickness" && !vals.contains_key("Thickness") { Ok(Value::length(t)) } else { look(n) };
|
||||
@@ -496,8 +499,12 @@ impl Document {
|
||||
angle_display: AngleDisplay::parse(&r.angle_display)
|
||||
.ok_or_else(|| DocError::Invalid(format!("unknown bend angle display `{}` (bend or included)", r.angle_display)))?,
|
||||
};
|
||||
if !(0.0..=1.0).contains(&v.k_factor) || v.bend_radius < 0.0 {
|
||||
return Err(DocError::Invalid("the K-factor must be 0…1 and the bend radius positive".into()));
|
||||
// Each value named on its own: a sharp bend (radius 0) is allowed (#9625).
|
||||
if !(0.0..=1.0).contains(&v.k_factor) {
|
||||
return Err(DocError::Invalid("the K-factor must be between 0 and 1".into()));
|
||||
}
|
||||
if !(v.bend_radius >= 0.0) {
|
||||
return Err(DocError::Invalid("the bend radius must not be negative".into()));
|
||||
}
|
||||
Ok(v)
|
||||
}
|
||||
|
||||
@@ -2600,6 +2600,18 @@ fn split_body(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
add_feature(s, p, FeatureKind::Split { body: BodyName(body), plane, tool: None, sketch: None, line: None })
|
||||
}
|
||||
|
||||
/// The fits [`clearance_diameter`] knows (close, normal, loose, and their older names).
|
||||
const CLEARANCE_FITS: [&str; 6] = ["close", "fine", "normal", "medium", "loose", "coarse"];
|
||||
|
||||
/// A value typed by the user, cut short for a message.
|
||||
fn brief(text: &str) -> String {
|
||||
const MAX: usize = 32;
|
||||
match text.char_indices().nth(MAX) {
|
||||
Some((end, _)) => format!("{}…", &text[..end]),
|
||||
None => text.to_string(),
|
||||
}
|
||||
}
|
||||
|
||||
/// ISO 273 clearance hole diameters (close, normal, loose fit) for metric bolts.
|
||||
fn clearance_diameter(size: &str, fit: &str) -> Option<f64> {
|
||||
const TABLE: [(f64, f64, f64, f64); 21] = [
|
||||
@@ -2808,10 +2820,18 @@ fn hole(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
let position = if references.is_empty() { position } else { referenced_centre(s, cmd, &references, position, direction)? };
|
||||
// The diameter: given, or a metric-estimate/Unified-table tap drill, or an ISO 273
|
||||
// clearance hole for a bolt size (close, normal or loose fit).
|
||||
// A diameter number out of range says so, rather than that none was given (#9625).
|
||||
if matches!(p.get("diameter"), Some(Value::Number(_))) && expr(p, "diameter").is_none() {
|
||||
return Err(bad(cmd, format!("`diameter` {}", expr_problem(p.get("diameter")))));
|
||||
}
|
||||
let diameter = match (expr(p, "diameter"), &thread, str_(p, "clearance")) {
|
||||
(Some(d), _, _) => d,
|
||||
(None, _, Some(c)) => {
|
||||
let fit = str_(p, "fit").unwrap_or("normal").to_ascii_lowercase();
|
||||
// An unknown fit is not an unknown bolt size (#9625).
|
||||
if !CLEARANCE_FITS.contains(&fit.as_str()) {
|
||||
return Err(bad(cmd, format!("`fit` must be close, normal or loose, not `{}`", brief(&fit))));
|
||||
}
|
||||
let d = clearance_diameter(c, &fit).ok_or_else(|| bad(cmd, format!("no clearance hole for `{c}` ({fit} fit): M1.6 to M64")))?;
|
||||
Expr::new(format!("{d} mm"))
|
||||
}
|
||||
@@ -2858,7 +2878,12 @@ fn hole(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
},
|
||||
"countersink" => solidcraft_doc::HoleKind::Countersink {
|
||||
cs_diameter: get("cs_diameter")?,
|
||||
cs_angle: expr(p, "cs_angle").unwrap_or_else(|| "90 deg".into()),
|
||||
// The default only when no angle is given: a supplied one out of range is refused (#9625).
|
||||
cs_angle: match p.get("cs_angle") {
|
||||
None | Some(Value::Null) => "90 deg".into(),
|
||||
Some(Value::String(t)) if t.trim().is_empty() => "90 deg".into(),
|
||||
Some(_) => req_expr(cmd, p, "cs_angle")?,
|
||||
},
|
||||
tip_angle: expr(p, "tip_angle"),
|
||||
},
|
||||
other => return Err(bad(cmd, format!("unknown hole type `{other}`"))),
|
||||
|
||||
@@ -620,12 +620,13 @@ pub(crate) fn joint_id(s: &Session, v: Option<&Value>, cmd: &str) -> Result<u64>
|
||||
/// A joint value: numbers are degrees for angles and mm for distances; text is an expression.
|
||||
pub(crate) fn value(s: &Session, v: &Value, angle: bool, cmd: &str) -> Result<f64> {
|
||||
let kind = if angle { Kind::Angle } else { Kind::Length };
|
||||
// A number out of range says so, rather than that it is not a number (#9625).
|
||||
let e = match v {
|
||||
Value::Number(n) => n.as_f64().filter(|x| x.is_finite() && x.abs() < 1e9).map(|x| x.to_string()),
|
||||
Value::String(t) => Some(t.clone()),
|
||||
_ => None,
|
||||
}
|
||||
.ok_or_else(|| bad(cmd, "values must be numbers or expressions"))?;
|
||||
.ok_or_else(|| bad(cmd, format!("a joint value {}", crate::params::expr_problem(Some(v)))))?;
|
||||
s.doc.eval(&e, kind).map_err(|e| bad(cmd, e.to_string()))
|
||||
}
|
||||
|
||||
|
||||
@@ -124,6 +124,27 @@ fn revolute_hinge_turns_about_the_knuckle() {
|
||||
assert!(near(place(&s, "LeafB", p), Vec3::new(20.0, 29.0, 37.0)));
|
||||
}
|
||||
|
||||
/// A joint value too large says so, rather than that it is not a number (#9625).
|
||||
#[test]
|
||||
fn a_joint_value_out_of_range_says_so() {
|
||||
let mut s = Session::default();
|
||||
leaf(&mut s, "LeafA");
|
||||
leaf(&mut s, "LeafB");
|
||||
let o = occ(&s, "LeafA");
|
||||
run(&mut s, "occurrence.ground", json!({"occurrence": o, "grounded": true}));
|
||||
let hinge = json!({"type": "revolute", "a": {"occurrence": "LeafA", "circle": [1, 37, 4]}, "b": {"occurrence": "LeafB", "circle": [1, 37, 4]}, "flip": true, "name": "Hinge"});
|
||||
run(&mut s, "joint.create", hinge);
|
||||
for value in [json!(1e9), json!(-5e15)] {
|
||||
let e = s.execute("joint.drive", &json!({"joint": "Hinge", "value": value})).err().map(|e| e.to_string()).unwrap_or_default();
|
||||
assert!(
|
||||
e.contains("a joint value must be a number between -1e9 and 1e9") && !e.contains("a joint value must be a number or"),
|
||||
"{value}: {e}"
|
||||
);
|
||||
}
|
||||
let e = s.execute("joint.drive", &json!({"joint": "Hinge", "value": true})).err().map(|e| e.to_string()).unwrap_or_default();
|
||||
assert!(e.contains("a joint value must be a number or an expression") && !e.contains("between"), "{e}");
|
||||
}
|
||||
|
||||
/// Two 10 mm cubes in components A (grounded) and B.
|
||||
fn two_cubes() -> Session {
|
||||
let mut s = Session::default();
|
||||
|
||||
@@ -527,6 +527,25 @@ fn rules_are_parameters() {
|
||||
assert!(s.execute("sheet.manage_rules", &json!({"name": "Bad", "k_factor": 3})).is_err());
|
||||
}
|
||||
|
||||
/// A refused rule names the value at fault and its range (#9625): a thickness too large is not
|
||||
/// "not positive", and a negative bend radius is not blamed on the K-factor (or the other way).
|
||||
#[test]
|
||||
fn a_refused_rule_names_the_value_at_fault() {
|
||||
let mut s = Session::default();
|
||||
let refused =
|
||||
|s: &mut Session, p: Value| s.execute("sheet.manage_rules", &p).err().map(|e| e.to_string()).unwrap_or_else(|| panic!("{p} was accepted"));
|
||||
let e = refused(&mut s, json!({"name": "R", "thickness": 10000}));
|
||||
assert!(e.contains("the sheet thickness must be more than 0 and less than 10000 mm") && !e.contains("positive"), "{e}");
|
||||
let e = refused(&mut s, json!({"name": "R", "thickness": 0}));
|
||||
assert!(e.contains("the sheet thickness must be more than 0 and less than 10000 mm"), "{e}");
|
||||
let e = refused(&mut s, json!({"name": "R", "thickness": 2, "bend_radius": -1}));
|
||||
assert!(e.contains("the bend radius must not be negative") && !e.contains("K-factor"), "{e}");
|
||||
let e = refused(&mut s, json!({"name": "R", "thickness": 2, "k_factor": 3}));
|
||||
assert!(e.contains("the K-factor must be between 0 and 1") && !e.contains("bend radius"), "{e}");
|
||||
// A sharp bend (radius 0) is allowed, and the message no longer says otherwise.
|
||||
run(&mut s, "sheet.manage_rules", json!({"name": "R", "thickness": 2, "bend_radius": 0}));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn contour_flange_hem_and_tray() {
|
||||
// Oracle 72.
|
||||
|
||||
@@ -1003,3 +1003,47 @@ fn bridged_counterbore_layers_along_x_save_and_refuse_bad_values() {
|
||||
p["cs_diameter"] = json!(12);
|
||||
assert!(refusal(&p).contains("counterbore"), "countersink: {}", refusal(&p));
|
||||
}
|
||||
|
||||
/// A refused hole names the value at fault, not a check it passed (#9625): an unknown fit is not
|
||||
/// an unknown bolt size, a countersink angle out of range is not a countersink too narrow, and a
|
||||
/// diameter too large is not a missing one.
|
||||
#[test]
|
||||
fn a_refused_hole_names_the_value_at_fault() {
|
||||
let refused = |extra: Value| {
|
||||
let mut s = Session::default();
|
||||
run(&mut s, "solid.box", json!({"length": 40, "width": 40, "height": 10, "center": [0, 0, 5]})).unwrap();
|
||||
let mut p = json!({"position": [0, 0, 10]});
|
||||
p.as_object_mut().unwrap().extend(extra.as_object().unwrap().clone());
|
||||
let before = measure(&mut s).unwrap();
|
||||
let e = s.execute("solid.hole", &p).err().map(|e| e.to_string()).unwrap_or_else(|| panic!("{p} was accepted"));
|
||||
assert_eq!(measure(&mut s).unwrap(), before, "{p} changed the part");
|
||||
e
|
||||
};
|
||||
let e = refused(json!({"clearance": "M6", "fit": "tight"}));
|
||||
assert!(e.contains("`fit` must be close, normal or loose, not `tight`") && !e.contains("M1.6"), "{e}");
|
||||
let e = refused(json!({"clearance": "M100"}));
|
||||
assert!(e.contains("no clearance hole for `M100`") && e.contains("M1.6 to M64"), "{e}");
|
||||
for angle in [json!(0), json!(200), json!(-90), json!(0.1)] {
|
||||
let e = refused(json!({"diameter": 3, "type": "countersink", "cs_diameter": 6, "cs_angle": angle}));
|
||||
assert!(e.contains("the countersink angle must be more than 0.115° and less than 180°") && !e.contains("wider"), "{angle}: {e}");
|
||||
}
|
||||
// 0.1° is refused by the floor the message names, and gives the angle as typed.
|
||||
let e = refused(json!({"diameter": 3, "type": "countersink", "cs_diameter": 6, "cs_angle": 0.1}));
|
||||
assert!(e.contains("not 0.1°"), "{e}");
|
||||
// An angle that is no usable number is refused, not replaced by the 90° default.
|
||||
let e = refused(json!({"diameter": 3, "type": "countersink", "cs_diameter": 6, "cs_angle": 1e9}));
|
||||
assert!(e.contains("`cs_angle` must be a number between -1e9 and 1e9"), "{e}");
|
||||
// A blank angle field still means the 90° default, as an omitted one does.
|
||||
let mut s = Session::default();
|
||||
run(&mut s, "solid.box", json!({"length": 40, "width": 40, "height": 10, "center": [0, 0, 5]})).unwrap();
|
||||
let blank = json!({"position": [0, 0, 10], "diameter": 3, "type": "countersink", "cs_diameter": 6, "cs_angle": " "});
|
||||
s.execute("solid.hole", &blank).unwrap_or_else(|e| panic!("a blank cs_angle was refused: {e}"));
|
||||
let e = refused(json!({"diameter": 6, "type": "countersink", "cs_diameter": 3}));
|
||||
assert!(e.contains("the countersink must be wider than the hole") && !e.contains("angle"), "{e}");
|
||||
for d in [json!(1e9), json!(-2e12)] {
|
||||
let e = refused(json!({"diameter": d}));
|
||||
assert!(e.contains("`diameter` must be a number between -1e9 and 1e9") && !e.contains("needs"), "{d}: {e}");
|
||||
}
|
||||
let e = refused(json!({}));
|
||||
assert!(e.contains("needs `diameter`, `thread` (a tapped hole) or `clearance` (a bolt size)"), "{e}");
|
||||
}
|
||||
|
||||
@@ -1639,6 +1639,39 @@ fn preview_of_an_edit() {
|
||||
assert!(Arc::ptr_eq(&doc, &s.doc));
|
||||
}
|
||||
|
||||
/// An extrusion too long says so and gives the limit, not `end = 1000000000` (#9625), whether
|
||||
/// the distance is typed as text or as a number inside the parameter range.
|
||||
#[test]
|
||||
fn an_extrude_too_long_says_so() {
|
||||
for distance in [json!("1e9 mm"), json!(5e8), json!("-2e7")] {
|
||||
let mut s = Session::default();
|
||||
run(&mut s, "sketch.create", json!({"plane": "XY"}));
|
||||
run(&mut s, "sketch.rectangle.two_point", json!({"p0": [0, 0], "p1": [30, 20]}));
|
||||
run(&mut s, "sketch.finish", json!({}));
|
||||
let e = s.execute("solid.extrude", &json!({"distance": distance})).err().map(|e| e.to_string()).unwrap_or_default();
|
||||
assert!(
|
||||
e.contains("the extrusion is too long: its end is") && e.contains("past the limit of 10000000 mm") && !e.contains("end ="),
|
||||
"{distance}: {e}"
|
||||
);
|
||||
assert!(s.model.state().bodies.is_empty(), "{distance}");
|
||||
}
|
||||
// The Edit Extrude dialog previews a redefinition of the feature: the same message.
|
||||
let mut s = Session::default();
|
||||
run(&mut s, "sketch.create", json!({"plane": "XY"}));
|
||||
run(&mut s, "sketch.rectangle.two_point", json!({"p0": [0, 0], "p1": [30, 20]}));
|
||||
run(&mut s, "sketch.finish", json!({}));
|
||||
let fid = run(&mut s, "solid.extrude", json!({"distance": 10}))["feature"].as_u64().unwrap();
|
||||
let idx = s.doc.feature_index(fid).unwrap();
|
||||
run(&mut s, "timeline.roll_to", json!({"position": idx}));
|
||||
let redefine = json!({"feature": fid, "command": "solid.extrude", "params": {"distance": "1e9 mm"}});
|
||||
let e = s.preview(&[("timeline.redefine".into(), redefine)]).err().map(|e| e.to_string()).unwrap_or_default();
|
||||
assert!(e.contains("the extrusion is too long: its end is 1000000000 mm from the sketch plane, past the limit of 10000000 mm"), "{e}");
|
||||
// The kernel's limit on a cylinder, a torus or a revolve is not an extrusion's.
|
||||
let mut s = Session::default();
|
||||
let e = s.execute("solid.cylinder", &json!({"radius": 2e7, "height": 10})).err().map(|e| e.to_string()).unwrap_or_default();
|
||||
assert!(!e.is_empty() && !e.contains("extrusion"), "{e}");
|
||||
}
|
||||
|
||||
/// `operation: "auto"`: into a body cuts; additions default to Join when a solid exists.
|
||||
#[test]
|
||||
fn extrude_auto_operation() {
|
||||
|
||||
Reference in New Issue
Block a user