ability to set tolerances, but with sane defaults (#3397)

* allow for setting of tolerances

Signed-off-by: Jess Frazelle <github@jessfraz.com>

* autocomplete fixes

Signed-off-by: Jess Frazelle <github@jessfraz.com>

* fix inches default

Signed-off-by: Jess Frazelle <github@jessfraz.com>

---------

Signed-off-by: Jess Frazelle <github@jessfraz.com>

src/wasm-lib/kcl/src/docs.rs

@@ -513,19 +513,27 @@ pub fn get_autocomplete_snippet_from_schema(
                 let mut fn_docs = String::new();
                 fn_docs.push_str("{\n");
                 // Let's print out the object's properties.
-                for (i, (prop_name, prop)) in obj_val.properties.iter().enumerate() {
+                let mut i = 0;
+                for (prop_name, prop) in obj_val.properties.iter() {
                     if prop_name.starts_with('_') {
                         continue;
                     }
 
+                    // Tolerance is a an optional property that we don't want to show in the
+                    // autocomplete, since it is mostly for advanced users.
+                    if prop_name == "tolerance" {
+                        continue;
+                    }
+
                     if let Some((_, snippet)) = get_autocomplete_snippet_from_schema(prop, index + i)? {
                         fn_docs.push_str(&format!("\t{}: {},\n", prop_name, snippet));
+                        i += 1;
                     }
                 }
 
                 fn_docs.push('}');
 
-                return Ok(Some((index + obj_val.properties.len() - 1, fn_docs)));
+                return Ok(Some((index + i - 1, fn_docs)));
             }
 
             if let Some(array_val) = &o.array {
@@ -902,8 +910,8 @@ mod tests {
         assert_eq!(
             snippet,
             r#"revolve({
-	axis: ${1:"X"},
-}, ${2:%})${}"#
+	axis: ${0:"X"},
+}, ${1:%})${}"#
         );
     }
 

src/wasm-lib/kcl/src/std/fillet.rs

@@ -11,11 +11,10 @@ use crate::{
     ast::types::TagDeclarator,
     errors::{KclError, KclErrorDetails},
     executor::{EdgeCut, ExtrudeGroup, ExtrudeSurface, FilletSurface, GeoMeta, KclValue, TagIdentifier, UserVal},
+    settings::types::UnitLength,
     std::Args,
 };
 
-pub(crate) const DEFAULT_TOLERANCE: f64 = 0.0000001;
-
 /// Data for fillets.
 #[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema)]
 #[ts(export)]
@@ -25,6 +24,9 @@ pub struct FilletData {
     pub radius: f64,
     /// The tags of the paths you want to fillet.
     pub tags: Vec<EdgeReference>,
+    /// The tolerance for the fillet.
+    #[serde(default)]
+    pub tolerance: Option<f64>,
 }
 
 /// A tag or a uuid of an edge.
@@ -77,6 +79,32 @@ pub async fn fillet(args: Args) -> Result<KclValue, KclError> {
 ///     ],
 ///   }, %)
 /// ```
+///
+/// ```no_run
+/// const width = 20
+/// const length = 10
+/// const thickness = 1
+/// const filletRadius = 1
+///
+/// const mountingPlateSketch = startSketchOn("XY")
+///   |> startProfileAt([-width/2, -length/2], %)
+///   |> lineTo([width/2, -length/2], %, $edge1)
+///   |> lineTo([width/2, length/2], %, $edge2)
+///   |> lineTo([-width/2, length/2], %, $edge3)
+///   |> close(%, $edge4)
+///
+/// const mountingPlate = extrude(thickness, mountingPlateSketch)
+///   |> fillet({
+///     radius: filletRadius,
+///     tolerance: 0.000001,
+///     tags: [
+///       getNextAdjacentEdge(edge1),
+///       getNextAdjacentEdge(edge2),
+///       getNextAdjacentEdge(edge3),
+///       getNextAdjacentEdge(edge4)
+///     ],
+///   }, %)
+/// ```
 #[stdlib {
     name = "fillet",
 }]
@@ -112,7 +140,7 @@ async fn inner_fillet(
                 edge_id,
                 object_id: extrude_group.id,
                 radius: data.radius,
-                tolerance: DEFAULT_TOLERANCE, // We can let the user set this in the future.
+                tolerance: data.tolerance.unwrap_or(default_tolerance(&args.ctx.settings.units)),
                 cut_type: Some(kittycad::types::CutType::Fillet),
             },
         )
@@ -382,3 +410,14 @@ async fn inner_get_previous_adjacent_edge(tag: TagIdentifier, args: Args) -> Res
         })
     })
 }
+
+pub(crate) fn default_tolerance(units: &UnitLength) -> f64 {
+    match units {
+        UnitLength::Mm => 0.0000001,
+        UnitLength::Cm => 0.0000001,
+        UnitLength::In => 0.0000001,
+        UnitLength::Ft => 0.0001,
+        UnitLength::Yd => 0.001,
+        UnitLength::M => 0.001,
+    }
+}

src/wasm-lib/kcl/src/std/revolve.rs

@@ -11,7 +11,7 @@ use crate::{
     executor::{ExtrudeGroup, KclValue, SketchGroup},
     std::{
         extrude::do_post_extrude,
-        fillet::{EdgeReference, DEFAULT_TOLERANCE},
+        fillet::{default_tolerance, EdgeReference},
         Args,
     },
 };
@@ -25,6 +25,9 @@ pub struct RevolveData {
     pub angle: Option<f64>,
     /// Axis of revolution.
     pub axis: RevolveAxis,
+    /// Tolerance for the revolve operation.
+    #[serde(default)]
+    pub tolerance: Option<f64>,
 }
 
 /// Axis of revolution or tagged edge.
@@ -207,6 +210,24 @@ pub async fn revolve(args: Args) -> Result<KclValue, KclError> {
 /// ```
 ///
 /// ```no_run
+/// const box = startSketchOn('XY')
+///     |> startProfileAt([0, 0], %)
+///     |> line([0, 20], %)
+///     |> line([20, 0], %)
+///     |> line([0, -20], %, $revolveAxis)
+///     |> close(%)
+///     |> extrude(20, %)
+///
+/// const sketch001 = startSketchOn(box, "END")
+///     |> circle([10,10], 4, %)
+///     |> revolve({
+///         angle: 90,
+///         axis: getOppositeEdge(revolveAxis),
+///         tolerance: 0.0001
+///     }, %)
+/// ```
+///
+/// ```no_run
 /// const sketch001 = startSketchOn('XY')
 ///   |> startProfileAt([10, 0], %)
 ///   |> line([5, -5], %)
@@ -254,7 +275,7 @@ async fn inner_revolve(
                     target: sketch_group.id,
                     axis,
                     origin,
-                    tolerance: DEFAULT_TOLERANCE,
+                    tolerance: data.tolerance.unwrap_or(default_tolerance(&args.ctx.settings.units)),
                     axis_is_2d: true,
                 },
             )
@@ -271,7 +292,7 @@ async fn inner_revolve(
                     angle,
                     target: sketch_group.id,
                     edge_id,
-                    tolerance: DEFAULT_TOLERANCE,
+                    tolerance: data.tolerance.unwrap_or(default_tolerance(&args.ctx.settings.units)),
                 },
             )
             .await?;