KCL: Convert angledLineThatIntersects to use kwargs

rust/kcl-lib/src/std/args.rs

@@ -1077,17 +1077,32 @@ macro_rules! let_field_of {
     };
 }
 
-impl<'a> FromKclValue<'a> for super::sketch::AngledLineThatIntersectsData {
+impl<'a> FromKclValue<'a> for crate::std::import::ImportFormat {
     fn from_kcl_val(arg: &'a KclValue) -> Option<Self> {
         let obj = arg.as_object()?;
-        let_field_of!(obj, angle);
-        let_field_of!(obj, intersect_tag "intersectTag");
-        let_field_of!(obj, offset?);
-        Some(Self {
-            angle,
-            intersect_tag,
-            offset,
-        })
+        let_field_of!(obj, typ "format");
+        match typ {
+            "fbx" => Some(Self::Fbx {}),
+            "gltf" => Some(Self::Gltf {}),
+            "sldprt" => Some(Self::Sldprt {}),
+            "step" => Some(Self::Step {}),
+            "stl" => {
+                let_field_of!(obj, coords?);
+                let_field_of!(obj, units);
+                Some(Self::Stl { coords, units })
+            }
+            "obj" => {
+                let_field_of!(obj, coords?);
+                let_field_of!(obj, units);
+                Some(Self::Obj { coords, units })
+            }
+            "ply" => {
+                let_field_of!(obj, coords?);
+                let_field_of!(obj, units);
+                Some(Self::Ply { coords, units })
+            }
+            _ => None,
+        }
     }
 }
 

rust/kcl-lib/src/std/sketch.rs

@@ -840,25 +840,16 @@ async fn inner_angled_line_to_y(
     Ok(new_sketch)
 }
 
-/// Data for drawing an angled line that intersects with a given line.
-#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema)]
-#[ts(export)]
-#[serde(rename_all = "camelCase")]
-// TODO: make sure the docs on the args below are correct.
-pub struct AngledLineThatIntersectsData {
-    /// The angle of the line.
-    pub angle: f64,
-    /// The tag of the line to intersect with.
-    pub intersect_tag: TagIdentifier,
-    /// The offset from the intersecting line.
-    pub offset: Option<f64>,
-}
-
 /// Draw an angled line that intersects with a given line.
 pub async fn angled_line_that_intersects(exec_state: &mut ExecState, args: Args) -> Result<KclValue, KclError> {
-    let (data, sketch, tag): (AngledLineThatIntersectsData, Sketch, Option<TagNode>) =
-        args.get_data_and_sketch_and_tag(exec_state)?;
-    let new_sketch = inner_angled_line_that_intersects(data, sketch, tag, exec_state, args).await?;
+    let sketch =
+        args.get_unlabeled_kw_arg_typed("sketch", &RuntimeType::Primitive(PrimitiveType::Sketch), exec_state)?;
+    let angle: f64 = args.get_kw_arg("angle")?;
+    let intersect_tag: TagIdentifier = args.get_kw_arg("intersectTag")?;
+    let offset: Option<f64> = args.get_kw_arg_opt("offset")?;
+    let tag: Option<TagNode> = args.get_kw_arg_opt("tag")?;
+    let new_sketch =
+        inner_angled_line_that_intersects(sketch, angle, intersect_tag, offset, tag, exec_state, args).await?;
     Ok(KclValue::Sketch {
         value: Box::new(new_sketch),
     })
@@ -874,26 +865,38 @@ pub async fn angled_line_that_intersects(exec_state: &mut ExecState, args: Args)
 ///   |> line(endAbsolute = [5, 10])
 ///   |> line(endAbsolute = [-10, 10], tag = $lineToIntersect)
 ///   |> line(endAbsolute = [0, 20])
-///   |> angledLineThatIntersects({
+///   |> angledLineThatIntersects(
 ///        angle = 80,
 ///        intersectTag = lineToIntersect,
-///        offset = 10
-///      }, %)
+///        offset = 10,
+///      )
 ///   |> close()
 ///
 /// example = extrude(exampleSketch, length = 10)
 /// ```
 #[stdlib {
     name = "angledLineThatIntersects",
+    keywords = true,
+    unlabeled_first = true,
+    args = {
+        sketch = { docs = "Which sketch should this path be added to?"},
+        angle = { docs = "Which angle should the line be drawn at?" },
+        intersect_tag = { docs = "The tag of the line to intersect with" },
+        offset = { docs = "The offset from the intersecting line. Defaults to 0." },
+        end_absolute_y = { docs = "Draw the line along the given angle until it reaches this point along the Y axis. Only one of `length`, `lengthX`, `lengthY`, `lengthAbsoluteEndX`, `lengthAbsoluteEndY` can be given."},
+        tag = { docs = "Create a new tag which refers to this line"},
+    }
 }]
 pub async fn inner_angled_line_that_intersects(
-    data: AngledLineThatIntersectsData,
     sketch: Sketch,
+    angle: f64,
+    intersect_tag: TagIdentifier,
+    offset: Option<f64>,
     tag: Option<TagNode>,
     exec_state: &mut ExecState,
     args: Args,
 ) -> Result<Sketch, KclError> {
-    let intersect_path = args.get_tag_engine_info(exec_state, &data.intersect_tag)?;
+    let intersect_path = args.get_tag_engine_info(exec_state, &intersect_tag)?;
     let path = intersect_path.path.clone().ok_or_else(|| {
         KclError::Type(KclErrorDetails {
             message: format!("Expected an intersect path with a path, found `{:?}`", intersect_path),
@@ -904,8 +907,8 @@ pub async fn inner_angled_line_that_intersects(
     let from = sketch.current_pen_position()?;
     let to = intersection_with_parallel_line(
         &[path.get_from().into(), path.get_to().into()],
-        data.offset.unwrap_or_default(),
-        data.angle,
+        offset.unwrap_or_default(),
+        angle,
         from,
     );
 

rust/kcl-lib/src/unparser.rs

@@ -2141,11 +2141,11 @@ mySk1 = startSketchOn(XY)
   |> startProfileAt([-0.01, -0.08], %)
   |> line([0.62, 4.15], %, $seg01)
   |> line([2.77, -1.24], %)
-  |> angledLineThatIntersects({
+  |> angledLineThatIntersects(
        angle = 201,
        offset = -1.35,
        intersectTag = seg01
-     }, %)
+     )
   |> line([-0.42, -1.72], %)"#;
         let program = crate::parsing::top_level_parse(some_program_string).unwrap();