ByoungSooPark/modeling-app
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Remove units from settings struct

Browse Source
This commit is contained in:
Jonathan Tran
2025-03-14 19:17:33 -04:00
parent 2f362e1774
commit 3dff5b1c30
19 changed files with 153 additions and 615 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
rust/kcl-derive-docs/src/lib.rs
View File

@ -816,7 +816,7 @@ fn generate_code_block_test(fn_name: &str, code_block: &str, index: usize) -> pr
async fn #test_name() -> miette::Result<()> {
let code = #code_block;
// Note, `crate` must be kcl_lib
let result = match crate::test_server::execute_and_snapshot(code, crate::settings::types::UnitLength::Mm, None).await {
let result = match crate::test_server::execute_and_snapshot(code, None).await {
Err(crate::errors::ExecError::Kcl(e)) => {
return Err(miette::Report::new(crate::errors::Report {
error: e.error,

2
rust/kcl-lib/benches/benchmark_kcl_samples.rs
View File

@ -76,7 +76,7 @@ fn run_benchmarks(c: &mut Criterion) {
group.bench_function(format!("execute_{}", dir_name), |b| {
b.iter(|| {
if let Err(err) = rt.block_on(async {
let ctx = kcl_lib::ExecutorContext::new_with_default_client(Default::default()).await?;
let ctx = kcl_lib::ExecutorContext::new_with_default_client().await?;
let mut exec_state = kcl_lib::ExecState::new(&ctx);
ctx.run(black_box(&program), &mut exec_state).await?;
ctx.close().await;

39
rust/kcl-lib/e2e/executor/cache.rs
View File

@ -49,45 +49,6 @@ async fn cache_test(
img_results
}
#[tokio::test(flavor = "multi_thread")]
async fn kcl_test_cache_change_units_changes_output() {
let code = r#"part001 = startSketchOn('XY')
|> startProfileAt([5.5229, 5.25217], %)
|> line(end = [10.50433, -1.19122])
|> line(end = [8.01362, -5.48731])
|> line(end = [-1.02877, -6.76825])
|> line(end = [-11.53311, 2.81559])
|> close()
|> extrude(length = 4)
"#;
let result = cache_test(
"change_units_changes_output",
vec![
Variation {
code,
settings: &kcl_lib::ExecutorSettings {
units: kcl_lib::UnitLength::In,
..Default::default()
},
},
Variation {
code,
settings: &kcl_lib::ExecutorSettings {
units: kcl_lib::UnitLength::Mm,
..Default::default()
},
},
],
)
.await;
let first = result.first().unwrap();
let second = result.last().unwrap();
assert!(first.1 != second.1);
}
#[tokio::test(flavor = "multi_thread")]
async fn kcl_test_cache_change_grid_visualizes_grid_off_to_on() {
let code = r#"part001 = startSketchOn('XY')

231
rust/kcl-lib/e2e/executor/main.rs
View File

@ -2,7 +2,7 @@ mod cache;
use kcl_lib::{
test_server::{execute_and_export_step, execute_and_snapshot, execute_and_snapshot_no_auth},
ExecError, UnitLength,
ExecError,
};
/// The minimum permissible difference between asserted twenty-twenty images.
@ -26,7 +26,7 @@ pub(crate) fn assert_out(test_name: &str, result: &image::DynamicImage) -> Strin
async fn kcl_test_fillet_duplicate_tags() {
let code = kcl_input!("fillet_duplicate_tags");
let result = execute_and_snapshot(code, UnitLength::Mm, None).await;
let result = execute_and_snapshot(code, None).await;
let err = result.expect_err("Code should have failed due to the duplicate edges being filletted");
let err = err.as_kcl_error().unwrap();
@ -48,7 +48,7 @@ async fn kcl_test_execute_engine_error_return() {
|> extrude(length = 4)
"#;
let result = execute_and_snapshot(code, UnitLength::Mm, None).await;
let result = execute_and_snapshot(code, None).await;
assert!(result.is_err());
assert_eq!(
result.err().unwrap().to_string(),
@ -61,7 +61,7 @@ async fn kcl_test_execute_i_shape() {
// This is some code from lee that starts a pipe expression with a variable.
let code = kcl_input!("i_shape");
let result = execute_and_snapshot(code, UnitLength::Mm, None).await.unwrap();
let result = execute_and_snapshot(code, None).await.unwrap();
assert_out("i_shape", &result);
}
@ -70,7 +70,7 @@ async fn kcl_test_execute_i_shape() {
async fn kcl_test_execute_pipes_on_pipes() {
let code = kcl_input!("pipes_on_pipes");
let result = execute_and_snapshot(code, UnitLength::Mm, None).await.unwrap();
let result = execute_and_snapshot(code, None).await.unwrap();
assert_out("pipes_on_pipes", &result);
}
@ -78,7 +78,7 @@ async fn kcl_test_execute_pipes_on_pipes() {
async fn kcl_test_execute_cylinder() {
let code = kcl_input!("cylinder");
let result = execute_and_snapshot(code, UnitLength::Mm, None).await.unwrap();
let result = execute_and_snapshot(code, None).await.unwrap();
assert_out("cylinder", &result);
}
@ -86,7 +86,7 @@ async fn kcl_test_execute_cylinder() {
async fn kcl_test_execute_kittycad_svg() {
let code = kcl_input!("kittycad_svg");
let result = execute_and_snapshot(code, UnitLength::Mm, None).await.unwrap();
let result = execute_and_snapshot(code, None).await.unwrap();
assert_out("kittycad_svg", &result);
}
@ -94,7 +94,7 @@ async fn kcl_test_execute_kittycad_svg() {
async fn kcl_test_execute_lsystem() {
let code = kcl_input!("lsystem");
let result = execute_and_snapshot(code, UnitLength::Mm, None).await.unwrap();
let result = execute_and_snapshot(code, None).await.unwrap();
assert_out("lsystem", &result);
}
@ -102,7 +102,7 @@ async fn kcl_test_execute_lsystem() {
async fn kcl_test_member_expression_sketch() {
let code = kcl_input!("member_expression_sketch");
let result = execute_and_snapshot(code, UnitLength::Mm, None).await.unwrap();
let result = execute_and_snapshot(code, None).await.unwrap();
assert_out("member_expression_sketch", &result);
}
@ -110,7 +110,7 @@ async fn kcl_test_member_expression_sketch() {
async fn kcl_test_helix_defaults() {
let code = kcl_input!("helix_defaults");
let result = execute_and_snapshot(code, UnitLength::Mm, None).await.unwrap();
let result = execute_and_snapshot(code, None).await.unwrap();
assert_out("helix_defaults", &result);
}
@ -118,7 +118,7 @@ async fn kcl_test_helix_defaults() {
async fn kcl_test_helix_defaults_negative_extrude() {
let code = kcl_input!("helix_defaults_negative_extrude");
let result = execute_and_snapshot(code, UnitLength::Mm, None).await.unwrap();
let result = execute_and_snapshot(code, None).await.unwrap();
assert_out("helix_defaults_negative_extrude", &result);
}
@ -126,7 +126,7 @@ async fn kcl_test_helix_defaults_negative_extrude() {
async fn kcl_test_helix_with_length() {
let code = kcl_input!("helix_with_length");
let result = execute_and_snapshot(code, UnitLength::Mm, None).await.unwrap();
let result = execute_and_snapshot(code, None).await.unwrap();
assert_out("helix_with_length", &result);
}
@ -134,7 +134,7 @@ async fn kcl_test_helix_with_length() {
async fn kcl_test_dimensions_match() {
let code = kcl_input!("dimensions_match");
let result = execute_and_snapshot(code, UnitLength::Mm, None).await.unwrap();
let result = execute_and_snapshot(code, None).await.unwrap();
assert_out("dimensions_match", &result);
}
@ -142,7 +142,7 @@ async fn kcl_test_dimensions_match() {
async fn kcl_test_close_arc() {
let code = kcl_input!("close_arc");
let result = execute_and_snapshot(code, UnitLength::Mm, None).await.unwrap();
let result = execute_and_snapshot(code, None).await.unwrap();
assert_out("close_arc", &result);
}
@ -150,7 +150,7 @@ async fn kcl_test_close_arc() {
async fn kcl_test_negative_args() {
let code = kcl_input!("negative_args");
let result = execute_and_snapshot(code, UnitLength::Mm, None).await.unwrap();
let result = execute_and_snapshot(code, None).await.unwrap();
assert_out("negative_args", &result);
}
@ -164,7 +164,7 @@ async fn kcl_test_basic_tangential_arc_with_point() {
|> extrude(length = 10)
"#;
let result = execute_and_snapshot(code, UnitLength::Mm, None).await.unwrap();
let result = execute_and_snapshot(code, None).await.unwrap();
assert_out("tangential_arc_with_point", &result);
}
@ -178,7 +178,7 @@ async fn kcl_test_basic_tangential_arc_to() {
|> extrude(length = 10)
"#;
let result = execute_and_snapshot(code, UnitLength::Mm, None).await.unwrap();
let result = execute_and_snapshot(code, None).await.unwrap();
assert_out("tangential_arc_to", &result);
}
@ -205,7 +205,7 @@ box(30, 43, 18, '-xy')
let thing = box(-12, -15, 10, 'yz')
box(-20, -5, 10, 'xy')"#;
let result = execute_and_snapshot(code, UnitLength::Mm, None).await.unwrap();
let result = execute_and_snapshot(code, None).await.unwrap();
assert_out("different_planes_same_drawing", &result);
}
@ -263,7 +263,7 @@ part004 = startSketchOn('YZ')
|> close()
"#;
let result = execute_and_snapshot(code, UnitLength::Mm, None).await.unwrap();
let result = execute_and_snapshot(code, None).await.unwrap();
assert_out("lots_of_planes", &result);
}
@ -280,7 +280,7 @@ async fn kcl_test_holes() {
|> extrude(length = 2)
"#;
let result = execute_and_snapshot(code, UnitLength::Mm, None).await.unwrap();
let result = execute_and_snapshot(code, None).await.unwrap();
assert_out("holes", &result);
}
@ -299,7 +299,7 @@ async fn optional_params() {
thing = other_circle([2, 2], 20)
"#;
let result = execute_and_snapshot(code, UnitLength::Mm, None).await.unwrap();
let result = execute_and_snapshot(code, None).await.unwrap();
assert_out("optional_params", &result);
}
@ -335,7 +335,7 @@ part = roundedRectangle([0, 0], 20, 20, 4)
|> extrude(length = 2)
"#;
let result = execute_and_snapshot(code, UnitLength::Mm, None).await.unwrap();
let result = execute_and_snapshot(code, None).await.unwrap();
assert_out("rounded_with_holes", &result);
}
@ -343,7 +343,7 @@ part = roundedRectangle([0, 0], 20, 20, 4)
async fn kcl_test_top_level_expression() {
let code = r#"startSketchOn('XY') |> circle(center = [0,0], radius= 22) |> extrude(length = 14)"#;
let result = execute_and_snapshot(code, UnitLength::Mm, None).await.unwrap();
let result = execute_and_snapshot(code, None).await.unwrap();
assert_out("top_level_expression", &result);
}
@ -357,7 +357,7 @@ part = startSketchOn('XY')
|> extrude(length = 1)
"#;
let result = execute_and_snapshot(code, UnitLength::Mm, None).await.unwrap();
let result = execute_and_snapshot(code, None).await.unwrap();
assert_out("patterns_linear_basic_with_math", &result);
}
@ -369,7 +369,7 @@ async fn kcl_test_patterns_linear_basic() {
|> extrude(length = 1)
"#;
let result = execute_and_snapshot(code, UnitLength::Mm, None).await.unwrap();
let result = execute_and_snapshot(code, None).await.unwrap();
assert_out("patterns_linear_basic", &result);
}
@ -385,7 +385,7 @@ async fn kcl_test_patterns_linear_basic_3d() {
|> patternLinear3d(axis = [1, 0, 1], instances = 4, distance = 6)
"#;
let result = execute_and_snapshot(code, UnitLength::Mm, None).await.unwrap();
let result = execute_and_snapshot(code, None).await.unwrap();
assert_out("patterns_linear_basic_3d", &result);
}
@ -397,7 +397,7 @@ async fn kcl_test_patterns_linear_basic_negative_distance() {
|> extrude(length = 1)
"#;
let result = execute_and_snapshot(code, UnitLength::Mm, None).await.unwrap();
let result = execute_and_snapshot(code, None).await.unwrap();
assert_out("patterns_linear_basic_negative_distance", &result);
}
@ -409,7 +409,7 @@ async fn kcl_test_patterns_linear_basic_negative_axis() {
|> extrude(length = 1)
"#;
let result = execute_and_snapshot(code, UnitLength::Mm, None).await.unwrap();
let result = execute_and_snapshot(code, None).await.unwrap();
assert_out("patterns_linear_basic_negative_axis", &result);
}
@ -430,7 +430,7 @@ rectangle = startSketchOn('XY')
"#;
let result = execute_and_snapshot(code, UnitLength::Mm, None).await.unwrap();
let result = execute_and_snapshot(code, None).await.unwrap();
assert_out("patterns_linear_basic_holes", &result);
}
@ -442,7 +442,7 @@ async fn kcl_test_patterns_circular_basic_2d() {
|> extrude(length = 1)
"#;
let result = execute_and_snapshot(code, UnitLength::Mm, None).await.unwrap();
let result = execute_and_snapshot(code, None).await.unwrap();
assert_out("patterns_circular_basic_2d", &result);
}
@ -458,7 +458,7 @@ async fn kcl_test_patterns_circular_basic_3d() {
|> patternCircular3d(axis = [0,0, 1], center = [-20, -20, -20], instances = 41, arcDegrees = 360, rotateDuplicates = false)
"#;
let result = execute_and_snapshot(code, UnitLength::Mm, None).await.unwrap();
let result = execute_and_snapshot(code, None).await.unwrap();
assert_out("patterns_circular_basic_3d", &result);
}
@ -474,7 +474,7 @@ async fn kcl_test_patterns_circular_3d_tilted_axis() {
|> patternCircular3d(axis = [1,1,0], center = [10, 0, 10], instances = 11, arcDegrees = 360, rotateDuplicates = true)
"#;
let result = execute_and_snapshot(code, UnitLength::Mm, None).await.unwrap();
let result = execute_and_snapshot(code, None).await.unwrap();
assert_out("patterns_circular_3d_tilted_axis", &result);
}
@ -483,7 +483,7 @@ async fn kcl_test_import_file_doesnt_exist() {
let code = r#"import 'thing.obj'
model = cube"#;
let result = execute_and_snapshot(code, UnitLength::Mm, None).await;
let result = execute_and_snapshot(code, None).await;
assert!(result.is_err());
assert_eq!(
result.err().unwrap().to_string(),
@ -496,7 +496,7 @@ async fn kcl_test_import_obj_with_mtl() {
let code = r#"import 'e2e/executor/inputs/cube.obj'
model = cube"#;
let result = execute_and_snapshot(code, UnitLength::Mm, None).await.unwrap();
let result = execute_and_snapshot(code, None).await.unwrap();
assert_out("import_obj_with_mtl", &result);
}
@ -506,7 +506,7 @@ async fn kcl_test_import_obj_with_mtl_units() {
import 'e2e/executor/inputs/cube.obj'
model = cube"#;
let result = execute_and_snapshot(code, UnitLength::Mm, None).await.unwrap();
let result = execute_and_snapshot(code, None).await.unwrap();
assert_out("import_obj_with_mtl_units", &result);
}
@ -515,7 +515,7 @@ async fn kcl_test_import_stl() {
let code = r#"import 'e2e/executor/inputs/2-5-long-m8-chc-screw.stl' as screw
model = screw"#;
let result = execute_and_snapshot(code, UnitLength::Mm, None).await.unwrap();
let result = execute_and_snapshot(code, None).await.unwrap();
assert_out("import_stl", &result);
}
@ -524,7 +524,7 @@ async fn kcl_test_import_gltf_with_bin() {
let code = r#"import 'e2e/executor/inputs/cube.gltf'
model = cube"#;
let result = execute_and_snapshot(code, UnitLength::Mm, None).await.unwrap();
let result = execute_and_snapshot(code, None).await.unwrap();
assert_out("import_gltf_with_bin", &result);
}
@ -533,7 +533,7 @@ async fn kcl_test_import_gltf_embedded() {
let code = r#"import 'e2e/executor/inputs/cube-embedded.gltf' as cube
model = cube"#;
let result = execute_and_snapshot(code, UnitLength::Mm, None).await.unwrap();
let result = execute_and_snapshot(code, None).await.unwrap();
assert_out("import_gltf_embedded", &result);
}
@ -542,7 +542,7 @@ async fn kcl_test_import_glb() {
let code = r#"import 'e2e/executor/inputs/cube.glb'
model = cube"#;
let result = execute_and_snapshot(code, UnitLength::Mm, None).await.unwrap();
let result = execute_and_snapshot(code, None).await.unwrap();
assert_out("import_glb", &result);
}
@ -551,7 +551,7 @@ async fn kcl_test_import_glb_no_assign() {
let code = r#"import 'e2e/executor/inputs/cube.glb'
cube"#;
let result = execute_and_snapshot(code, UnitLength::Mm, None).await.unwrap();
let result = execute_and_snapshot(code, None).await.unwrap();
assert_out("import_glb_no_assign", &result);
}
@ -561,7 +561,7 @@ async fn kcl_test_import_ext_doesnt_match() {
import 'e2e/executor/inputs/cube.gltf'
model = cube"#;
let result = execute_and_snapshot(code, UnitLength::Mm, None).await;
let result = execute_and_snapshot(code, None).await;
assert!(result.is_err());
assert_eq!(
result.err().unwrap().to_string(),
@ -586,13 +586,14 @@ async fn kcl_test_cube_mm() {
myCube = cube([0,0], 10)
"#;
let result = execute_and_snapshot(code, UnitLength::Mm, None).await.unwrap();
let result = execute_and_snapshot(code, None).await.unwrap();
assert_out("cube_mm", &result);
}
#[tokio::test(flavor = "multi_thread")]
async fn kcl_test_cube_cm() {
let code = r#"fn cube = (pos, scale) => {
let code = r#"@settings(defaultLengthUnit = cm)
fn cube = (pos, scale) => {
sg = startSketchOn('XY')
|> startProfileAt(pos, %)
|> line(end = [0, scale])
@ -607,13 +608,14 @@ async fn kcl_test_cube_cm() {
myCube = cube([0,0], 10)
"#;
let result = execute_and_snapshot(code, UnitLength::Cm, None).await.unwrap();
let result = execute_and_snapshot(code, None).await.unwrap();
assert_out("cube_cm", &result);
}
#[tokio::test(flavor = "multi_thread")]
async fn kcl_test_cube_m() {
let code = r#"fn cube = (pos, scale) => {
let code = r#"@settings(defaultLengthUnit = m)
fn cube = (pos, scale) => {
sg = startSketchOn('XY')
|> startProfileAt(pos, %)
|> line(end = [0, scale])
@ -628,13 +630,14 @@ async fn kcl_test_cube_m() {
myCube = cube([0,0], 10)
"#;
let result = execute_and_snapshot(code, UnitLength::M, None).await.unwrap();
let result = execute_and_snapshot(code, None).await.unwrap();
assert_out("cube_m", &result);
}
#[tokio::test(flavor = "multi_thread")]
async fn kcl_test_cube_in() {
let code = r#"fn cube = (pos, scale) => {
let code = r#"@settings(defaultLengthUnit = in)
fn cube = (pos, scale) => {
sg = startSketchOn('XY')
|> startProfileAt(pos, %)
|> line(end = [0, scale])
@ -649,13 +652,14 @@ async fn kcl_test_cube_in() {
myCube = cube([0,0], 10)
"#;
let result = execute_and_snapshot(code, UnitLength::In, None).await.unwrap();
let result = execute_and_snapshot(code, None).await.unwrap();
assert_out("cube_in", &result);
}
#[tokio::test(flavor = "multi_thread")]
async fn kcl_test_cube_ft() {
let code = r#"fn cube = (pos, scale) => {
let code = r#"@settings(defaultLengthUnit = ft)
fn cube = (pos, scale) => {
sg = startSketchOn('XY')
|> startProfileAt(pos, %)
|> line(end = [0, scale])
@ -670,13 +674,14 @@ async fn kcl_test_cube_ft() {
myCube = cube([0,0], 10)
"#;
let result = execute_and_snapshot(code, UnitLength::Ft, None).await.unwrap();
let result = execute_and_snapshot(code, None).await.unwrap();
assert_out("cube_ft", &result);
}
#[tokio::test(flavor = "multi_thread")]
async fn kcl_test_cube_yd() {
let code = r#"fn cube = (pos, scale) => {
let code = r#"@settings(defaultLengthUnit = yd)
fn cube = (pos, scale) => {
sg = startSketchOn('XY')
|> startProfileAt(pos, %)
|> line(end = [0, scale])
@ -691,7 +696,7 @@ async fn kcl_test_cube_yd() {
myCube = cube([0,0], 10)
"#;
let result = execute_and_snapshot(code, UnitLength::Yd, None).await.unwrap();
let result = execute_and_snapshot(code, None).await.unwrap();
assert_out("cube_yd", &result);
}
@ -719,7 +724,7 @@ part002 = startSketchOn(part001, part001.sketch.tags.here)
|> extrude(length = 1)
"#;
let result = execute_and_snapshot(code, UnitLength::Mm, None).await;
let result = execute_and_snapshot(code, None).await;
let err = result.err().unwrap();
let ExecError::Kcl(err) = err else {
@ -763,7 +768,7 @@ part003 = startSketchOn(part002, "end")
|> extrude(length = 5)
"#;
let result = execute_and_snapshot(code, UnitLength::Mm, None).await.unwrap();
let result = execute_and_snapshot(code, None).await.unwrap();
assert_out("sketch_on_face_of_face", &result);
}
@ -780,7 +785,7 @@ async fn kcl_test_stdlib_kcl_error_right_code_path() {
|> extrude(length = 2)
"#;
let result = execute_and_snapshot(code, UnitLength::Mm, None).await;
let result = execute_and_snapshot(code, None).await;
let err = result.err().unwrap();
let ExecError::Kcl(err) = err else {
panic!("Expected KCL error, found {err}");
@ -811,7 +816,7 @@ part002 = startSketchOn(part001, "end")
|> extrude(length = 5)
"#;
let result = execute_and_snapshot(code, UnitLength::Mm, None).await.unwrap();
let result = execute_and_snapshot(code, None).await.unwrap();
assert_out("sketch_on_face_circle", &result);
}
@ -853,7 +858,7 @@ part = rectShape([0, 0], 20, 20)
)
"#;
let result = execute_and_snapshot(code, UnitLength::Mm, None).await;
let result = execute_and_snapshot(code, None).await;
let err = result.err().unwrap();
let ExecError::Kcl(err) = err else {
panic!("Expected KCL error, found {err}");
@ -880,7 +885,7 @@ async fn kcl_test_simple_revolve() {
"#;
let result = execute_and_snapshot(code, UnitLength::Mm, None).await.unwrap();
let result = execute_and_snapshot(code, None).await.unwrap();
assert_out("simple_revolve", &result);
}
@ -900,7 +905,7 @@ async fn kcl_test_simple_revolve_uppercase() {
"#;
let result = execute_and_snapshot(code, UnitLength::Mm, None).await.unwrap();
let result = execute_and_snapshot(code, None).await.unwrap();
assert_out("simple_revolve_uppercase", &result);
}
@ -920,7 +925,7 @@ async fn kcl_test_simple_revolve_negative() {
"#;
let result = execute_and_snapshot(code, UnitLength::Mm, None).await.unwrap();
let result = execute_and_snapshot(code, None).await.unwrap();
assert_out("simple_revolve_negative", &result);
}
@ -940,7 +945,7 @@ async fn kcl_test_revolve_bad_angle_low() {
"#;
let result = execute_and_snapshot(code, UnitLength::Mm, None).await;
let result = execute_and_snapshot(code, None).await;
assert!(result.is_err());
assert!(result
@ -966,7 +971,7 @@ async fn kcl_test_revolve_bad_angle_high() {
"#;
let result = execute_and_snapshot(code, UnitLength::Mm, None).await;
let result = execute_and_snapshot(code, None).await;
assert!(result.is_err());
assert!(result
@ -992,7 +997,7 @@ async fn kcl_test_simple_revolve_custom_angle() {
"#;
let result = execute_and_snapshot(code, UnitLength::Mm, None).await.unwrap();
let result = execute_and_snapshot(code, None).await.unwrap();
assert_out("simple_revolve_custom_angle", &result);
}
@ -1012,7 +1017,7 @@ async fn kcl_test_simple_revolve_custom_axis() {
"#;
let result = execute_and_snapshot(code, UnitLength::Mm, None).await.unwrap();
let result = execute_and_snapshot(code, None).await.unwrap();
assert_out("simple_revolve_custom_axis", &result);
}
@ -1036,7 +1041,7 @@ sketch001 = startSketchOn(box, "end")
"#;
let result = execute_and_snapshot(code, UnitLength::Mm, None).await.unwrap();
let result = execute_and_snapshot(code, None).await.unwrap();
assert_out("revolve_on_edge", &result);
}
@ -1060,7 +1065,7 @@ sketch001 = startSketchOn(box, revolveAxis)
"#;
let result = execute_and_snapshot(code, UnitLength::Mm, None).await;
let result = execute_and_snapshot(code, None).await;
result.unwrap_err();
//this fails right now, but slightly differently, lets just say its enough for it to fail - mike
@ -1088,7 +1093,7 @@ sketch001 = startSketchOn(box, "END")
)
"#;
let result = execute_and_snapshot(code, UnitLength::Mm, None).await.unwrap();
let result = execute_and_snapshot(code, None).await.unwrap();
assert_out("revolve_on_face_circle_edge", &result);
}
@ -1110,7 +1115,7 @@ sketch001 = startSketchOn(box, "END")
)
"#;
let result = execute_and_snapshot(code, UnitLength::Mm, None).await.unwrap();
let result = execute_and_snapshot(code, None).await.unwrap();
assert_out("revolve_on_face_circle", &result);
}
@ -1136,7 +1141,7 @@ sketch001 = startSketchOn(box, "end")
)
"#;
let result = execute_and_snapshot(code, UnitLength::Mm, None).await.unwrap();
let result = execute_and_snapshot(code, None).await.unwrap();
assert_out("revolve_on_face", &result);
}
@ -1150,7 +1155,7 @@ async fn kcl_test_basic_revolve_circle() {
)
"#;
let result = execute_and_snapshot(code, UnitLength::Mm, None).await.unwrap();
let result = execute_and_snapshot(code, None).await.unwrap();
assert_out("basic_revolve_circle", &result);
}
@ -1177,7 +1182,7 @@ part002 = startSketchOn(part001, 'end')
|> extrude(length = 5)
"#;
let result = execute_and_snapshot(code, UnitLength::Mm, None).await.unwrap();
let result = execute_and_snapshot(code, None).await.unwrap();
assert_out("simple_revolve_sketch_on_edge", &result);
}
@ -1240,7 +1245,7 @@ plumbus1 = circle1
)
"#;
let result = execute_and_snapshot(code, UnitLength::Mm, None).await.unwrap();
let result = execute_and_snapshot(code, None).await.unwrap();
assert_out("plumbus_fillets", &result);
}
@ -1248,7 +1253,7 @@ plumbus1 = circle1
async fn kcl_test_empty_file_is_ok() {
let code = r#""#;
let result = execute_and_snapshot(code, UnitLength::Mm, None).await;
let result = execute_and_snapshot(code, None).await;
result.unwrap();
}
@ -1278,7 +1283,7 @@ async fn kcl_test_member_expression_in_params() {
capScrew([0, 0.5, 0], 50, 37.5, 50, 25)
"#;
let result = execute_and_snapshot(code, UnitLength::Mm, None).await.unwrap();
let result = execute_and_snapshot(code, None).await.unwrap();
assert_out("member_expression_in_params", &result);
}
@ -1323,7 +1328,7 @@ bracket = startSketchOn('XY')
)
"#;
let result = execute_and_snapshot(code, UnitLength::Mm, None).await;
let result = execute_and_snapshot(code, None).await;
result.unwrap();
}
@ -1343,7 +1348,7 @@ secondSketch = startSketchOn(part001, '')
|> extrude(length = 20)
"#;
let result = execute_and_snapshot(code, UnitLength::Mm, None).await;
let result = execute_and_snapshot(code, None).await;
assert!(result.is_err());
assert_eq!(
result.err().unwrap().to_string(),
@ -1374,7 +1379,7 @@ extrusion = startSketchOn('XY')
|> extrude(length = height)
"#;
let result = execute_and_snapshot(code, UnitLength::Mm, None).await;
let result = execute_and_snapshot(code, None).await;
assert!(result.is_err());
assert_eq!(
result.err().unwrap().to_string(),
@ -1407,7 +1412,7 @@ sketch001 = [profile001, profile002]
extrude(sketch001, length = 10)
"#;
let result = execute_and_snapshot(code, UnitLength::Mm, None).await.unwrap();
let result = execute_and_snapshot(code, None).await.unwrap();
assert_out("array_of_sketches", &result);
}
@ -1444,7 +1449,7 @@ pattn1 = patternLinear3d(
)
"#;
let result = execute_and_snapshot(code, UnitLength::Mm, None).await.unwrap();
let result = execute_and_snapshot(code, None).await.unwrap();
assert_out("pattern3d_array_of_extrudes", &result);
}
@ -1492,7 +1497,7 @@ baseExtrusion = extrude(sketch001, length = width)
)
"#;
let result = execute_and_snapshot(code, UnitLength::Mm, None).await.unwrap();
let result = execute_and_snapshot(code, None).await.unwrap();
assert_out("fillets_referencing_other_fillets", &result);
}
@ -1540,7 +1545,7 @@ baseExtrusion = extrude(sketch001, length = width)
)
"#;
let result = execute_and_snapshot(code, UnitLength::Mm, None).await.unwrap();
let result = execute_and_snapshot(code, None).await.unwrap();
assert_out("chamfers_referencing_other_chamfers", &result);
}
@ -1560,7 +1565,7 @@ async fn kcl_test_shell_with_tag() {
)
"#;
let result = execute_and_snapshot(code, UnitLength::Mm, None).await.unwrap();
let result = execute_and_snapshot(code, None).await.unwrap();
assert_out("shell_with_tag", &result);
}
@ -1591,7 +1596,7 @@ pattn1 = patternLinear3d(
)
"#;
let result = execute_and_snapshot(code, UnitLength::Mm, None).await.unwrap();
let result = execute_and_snapshot(code, None).await.unwrap();
assert_out("linear_pattern3d_filleted_sketch", &result);
}
@ -1618,7 +1623,7 @@ pattn2 = patternCircular3d(part001, axis = [0,0, 1], center = [-20, -20, -20], i
"#;
let result = execute_and_snapshot(code, UnitLength::Mm, None).await.unwrap();
let result = execute_and_snapshot(code, None).await.unwrap();
assert_out("circular_pattern3d_filleted_sketch", &result);
}
@ -1644,7 +1649,7 @@ part001 = cube([0,0], 20)
pattn2 = patternCircular3d(part001, axis = [0,0, 1], center = [-20, -20, -20], instances = 5, arcDegrees = 360, rotateDuplicates = false)
"#;
let result = execute_and_snapshot(code, UnitLength::Mm, None).await.unwrap();
let result = execute_and_snapshot(code, None).await.unwrap();
assert_out("circular_pattern3d_chamfered_sketch", &result);
}
@ -1671,7 +1676,7 @@ part001 = cube([0,0], 20)
"#;
let result = execute_and_snapshot(code, UnitLength::Mm, None).await;
let result = execute_and_snapshot(code, None).await;
let err = result.err().unwrap();
let ExecError::Kcl(err) = err else {
panic!("Expected KCL error, found {err}");
@ -1701,7 +1706,7 @@ async fn kcl_test_duplicate_tags_should_error() {
let p = triangle(200)
"#;
let result = execute_and_snapshot(code, UnitLength::Mm, None).await;
let result = execute_and_snapshot(code, None).await;
assert!(result.is_err());
assert_eq!(
result.err().unwrap().to_string(),
@ -1712,49 +1717,49 @@ let p = triangle(200)
#[tokio::test(flavor = "multi_thread")]
async fn kcl_test_global_tags() {
let code = kcl_input!("global-tags");
let result = execute_and_snapshot(code, UnitLength::Mm, None).await.unwrap();
let result = execute_and_snapshot(code, None).await.unwrap();
assert_out("global_tags", &result);
}
#[tokio::test(flavor = "multi_thread")]
async fn kcl_test_extrude_inside_fn_with_tags() {
let code = kcl_input!("extrude-inside-fn-with-tags");
let result = execute_and_snapshot(code, UnitLength::Mm, None).await.unwrap();
let result = execute_and_snapshot(code, None).await.unwrap();
assert_out("extrude-inside-fn-with-tags", &result);
}
#[tokio::test(flavor = "multi_thread")]
async fn kcl_test_pattern_vase() {
let code = kcl_input!("pattern_vase");
let result = execute_and_snapshot(code, UnitLength::Mm, None).await.unwrap();
let result = execute_and_snapshot(code, None).await.unwrap();
assert_out("pattern_vase", &result);
}
#[tokio::test(flavor = "multi_thread")]
async fn kcl_test_scoped_tags() {
let code = kcl_input!("scoped-tags");
let result = execute_and_snapshot(code, UnitLength::Mm, None).await.unwrap();
let result = execute_and_snapshot(code, None).await.unwrap();
assert_out("scoped_tags", &result);
}
#[tokio::test(flavor = "multi_thread")]
async fn kcl_test_order_sketch_extrude_in_order() {
let code = kcl_input!("order-sketch-extrude-in-order");
let result = execute_and_snapshot(code, UnitLength::Mm, None).await.unwrap();
let result = execute_and_snapshot(code, None).await.unwrap();
assert_out("order-sketch-extrude-in-order", &result);
}
#[tokio::test(flavor = "multi_thread")]
async fn kcl_test_order_sketch_extrude_out_of_order() {
let code = kcl_input!("order-sketch-extrude-out-of-order");
let result = execute_and_snapshot(code, UnitLength::Mm, None).await.unwrap();
let result = execute_and_snapshot(code, None).await.unwrap();
assert_out("order-sketch-extrude-out-of-order", &result);
}
#[tokio::test(flavor = "multi_thread")]
async fn kcl_test_extrude_custom_plane() {
let code = kcl_input!("extrude-custom-plane");
let result = execute_and_snapshot(code, UnitLength::Mm, None).await.unwrap();
let result = execute_and_snapshot(code, None).await.unwrap();
assert_out("extrude-custom-plane", &result);
}
@ -1776,7 +1781,7 @@ async fn kcl_test_arc_error_same_start_end() {
)
"#;
let result = execute_and_snapshot(code, UnitLength::Mm, None).await;
let result = execute_and_snapshot(code, None).await;
assert!(result.is_err());
assert_eq!(
result.err().unwrap().to_string(),
@ -1796,7 +1801,7 @@ async fn kcl_test_angled_line_to_x_90() {
example = extrude(exampleSketch, length = 10)
"#;
let result = execute_and_snapshot(code, UnitLength::Mm, None).await;
let result = execute_and_snapshot(code, None).await;
assert!(result.is_err());
assert_eq!(
result.err().unwrap().to_string(),
@ -1816,7 +1821,7 @@ async fn kcl_test_angled_line_to_x_270() {
example = extrude(exampleSketch, length = 10)
"#;
let result = execute_and_snapshot(code, UnitLength::Mm, None).await;
let result = execute_and_snapshot(code, None).await;
assert!(result.is_err());
assert_eq!(
result.err().unwrap().to_string(),
@ -1836,7 +1841,7 @@ async fn kcl_test_angled_line_to_y_0() {
example = extrude(exampleSketch, length = 10)
"#;
let result = execute_and_snapshot(code, UnitLength::Mm, None).await;
let result = execute_and_snapshot(code, None).await;
assert!(result.is_err());
assert_eq!(
result.err().unwrap().to_string(),
@ -1856,7 +1861,7 @@ async fn kcl_test_angled_line_to_y_180() {
example = extrude(exampleSketch, length = 10)
"#;
let result = execute_and_snapshot(code, UnitLength::Mm, None).await;
let result = execute_and_snapshot(code, None).await;
assert!(result.is_err());
assert_eq!(
result.err().unwrap().to_string(),
@ -1876,7 +1881,7 @@ async fn kcl_test_angled_line_of_x_length_90() {
extrusion = extrude(sketch001, length = 10)
"#;
let result = execute_and_snapshot(code, UnitLength::Mm, None).await;
let result = execute_and_snapshot(code, None).await;
assert!(result.is_err());
assert_eq!(
result.err().unwrap().to_string(),
@ -1896,7 +1901,7 @@ async fn kcl_test_angled_line_of_x_length_270() {
extrusion = extrude(sketch001, length = 10)
"#;
let result = execute_and_snapshot(code, UnitLength::Mm, None).await;
let result = execute_and_snapshot(code, None).await;
assert!(result.is_err());
assert_eq!(
result.err().unwrap().to_string(),
@ -1918,7 +1923,7 @@ async fn kcl_test_angled_line_of_y_length_0() {
example = extrude(exampleSketch, length = 10)
"#;
let result = execute_and_snapshot(code, UnitLength::Mm, None).await;
let result = execute_and_snapshot(code, None).await;
assert!(result.is_err());
assert_eq!(
result.err().unwrap().to_string(),
@ -1940,7 +1945,7 @@ async fn kcl_test_angled_line_of_y_length_180() {
example = extrude(exampleSketch, length = 10)
"#;
let result = execute_and_snapshot(code, UnitLength::Mm, None).await;
let result = execute_and_snapshot(code, None).await;
assert!(result.is_err());
assert_eq!(
result.err().unwrap().to_string(),
@ -1962,7 +1967,7 @@ async fn kcl_test_angled_line_of_y_length_negative_180() {
example = extrude(exampleSketch, length = 10)
"#;
let result = execute_and_snapshot(code, UnitLength::Mm, None).await;
let result = execute_and_snapshot(code, None).await;
assert!(result.is_err());
assert_eq!(
result.err().unwrap().to_string(),
@ -1979,7 +1984,7 @@ async fn kcl_test_error_inside_fn_also_has_source_range_of_call_site() {
someFunction('INVALID')
"#;
let result = execute_and_snapshot(code, UnitLength::Mm, None).await;
let result = execute_and_snapshot(code, None).await;
assert!(result.is_err());
assert_eq!(
result.err().unwrap().to_string(),
@ -2000,7 +2005,7 @@ async fn kcl_test_error_inside_fn_also_has_source_range_of_call_site_recursive()
someFunction('INVALID')
"#;
let result = execute_and_snapshot(code, UnitLength::Mm, None).await;
let result = execute_and_snapshot(code, None).await;
assert!(result.is_err());
assert_eq!(
result.err().unwrap().to_string(),
@ -2024,7 +2029,7 @@ async fn kcl_test_error_no_auth_websocket() {
)
"#;
let result = execute_and_snapshot_no_auth(code, UnitLength::Mm, None).await;
let result = execute_and_snapshot_no_auth(code, None).await;
assert!(result.is_err());
assert!(result
.err()
@ -2050,9 +2055,7 @@ sketch000 = startSketchOn('XY')
|> line(end = [0, innerDiameter / 2])
"#;
let ctx = kcl_lib::ExecutorContext::new_with_default_client(Default::default())
.await
.unwrap();
let ctx = kcl_lib::ExecutorContext::new_with_default_client().await.unwrap();
let mut exec_state = kcl_lib::ExecState::new(&ctx);
let program = kcl_lib::Program::parse_no_errs(code).unwrap();
ctx.run(&program, &mut exec_state).await.unwrap();
@ -2075,9 +2078,7 @@ async fn kcl_test_ensure_nothing_left_in_batch_multi_file() {
// Change the current working directory to the test directory.
std::env::set_current_dir(path.parent().unwrap()).unwrap();
let ctx = kcl_lib::ExecutorContext::new_with_default_client(Default::default())
.await
.unwrap();
let ctx = kcl_lib::ExecutorContext::new_with_default_client().await.unwrap();
let mut exec_state = kcl_lib::ExecState::new(&ctx);
let program = kcl_lib::Program::parse_no_errs(&code).unwrap();
ctx.run(&program, &mut exec_state).await.unwrap();
@ -2095,7 +2096,7 @@ async fn kcl_test_better_type_names() {
|> circle(center = [-95.51, -74.7], radius = 262.23)
|> appearance(metalness = 0.9)
"#;
let result = execute_and_snapshot(code, UnitLength::Mm, None).await;
let result = execute_and_snapshot(code, None).await;
let err = match result.err() {
Some(x) => match x {
@ -2114,7 +2115,7 @@ async fn kcl_test_exporting_step_file() {
// This tests export like how we do it in cli and kcl.py.
let code = kcl_input!("helix_defaults_negative_extrude");
let (_, _, files) = execute_and_export_step(code, UnitLength::Mm, None).await.unwrap();
let (_, _, files) = execute_and_export_step(code, None).await.unwrap();
for file in files {
expectorate::assert_contents(
format!("e2e/executor/outputs/helix_defaults_negative_extrude_{}", file.name),

2
rust/kcl-lib/e2e/modify/main.rs
View File

@ -9,7 +9,7 @@ use pretty_assertions::assert_eq;
/// Setup the engine and parse code for an ast.
async fn setup(code: &str, name: &str) -> Result<(ExecutorContext, Program, ModuleId, uuid::Uuid)> {
let program = Program::parse_no_errs(code)?;
let ctx = kcl_lib::ExecutorContext::new_with_default_client(Default::default()).await?;
let ctx = kcl_lib::ExecutorContext::new_with_default_client().await?;
let mut exec_state = ExecState::new(&ctx);
let result = ctx.run(&program, &mut exec_state).await?;
let outcome = exec_state.to_wasm_outcome(result.0).await;

2
rust/kcl-lib/src/docs/gen_std_tests.rs
View File

@ -1152,7 +1152,7 @@ fn find_examples(text: &str, filename: &str) -> Vec<(String, String)> {
async fn run_example(text: &str) -> Result<()> {
let program = crate::Program::parse_no_errs(text)?;
let ctx = ExecutorContext::new_with_default_client(crate::UnitLength::Mm).await?;
let ctx = ExecutorContext::new_with_default_client().await?;
let mut exec_state = crate::execution::ExecState::new(&ctx);
ctx.run(&program, &mut exec_state).await?;
Ok(())

5
rust/kcl-lib/src/docs/kcl_doc.rs
View File

@ -868,10 +868,7 @@ mod test {
let std = walk_prelude();
for d in std {
for (i, eg) in d.examples().enumerate() {
let result =
match crate::test_server::execute_and_snapshot(eg, crate::settings::types::UnitLength::Mm, None)
.await
{
let result = match crate::test_server::execute_and_snapshot(eg, None).await {
Err(crate::errors::ExecError::Kcl(e)) => {
return Err(miette::Report::new(crate::errors::Report {
error: e.error,

3
rust/kcl-lib/src/engine/mod.rs
View File

@ -252,9 +252,6 @@ pub trait EngineManager: std::fmt::Debug + Send + Sync + 'static {
// Set the edge visibility.
self.set_edge_visibility(settings.highlight_edges, source_range).await?;
// Change the units.
self.set_units(settings.units, source_range).await?;
// Send the command to show the grid.
self.modify_grid(!settings.show_grid, source_range).await?;

53
rust/kcl-lib/src/execution/cache.rs
View File

@ -97,15 +97,6 @@ pub(super) async fn get_changed_program(old: CacheInformation<'_>, new: CacheInf
// If the settings are different we might need to bust the cache.
// We specifically do this before checking if they are the exact same.
if old.settings != new.settings {
// If the units are different we need to re-execute the whole thing.
if old.settings.units != new.settings.units {
return CacheResult::ReExecute {
clear_scene: true,
reapply_settings: true,
program: new.ast.clone(),
};
}
// If anything else is different we may not need to re-execute, but rather just
// run the settings again.
reapply_settings = true;
@ -424,50 +415,6 @@ shell(firstSketch, faces = ['end'], thickness = 0.25)"#;
assert_eq!(result, CacheResult::NoAction(false));
}
// Changing the units with the exact same file should bust the cache.
#[tokio::test(flavor = "multi_thread")]
async fn test_get_changed_program_same_code_but_different_units() {
let new = r#"// Remove the end face for the extrusion.
firstSketch = startSketchOn('XY')
|> startProfileAt([-12, 12], %)
|> line(end = [24, 0])
|> line(end = [0, -24])
|> line(end = [-24, 0])
|> close()
|> extrude(length = 6)
// Remove the end face for the extrusion.
shell(firstSketch, faces = ['end'], thickness = 0.25)"#;
let ExecTestResults {
program, mut exec_ctxt, ..
} = parse_execute(new).await.unwrap();
// Change the settings to cm.
exec_ctxt.settings.units = crate::UnitLength::Cm;
let result = get_changed_program(
CacheInformation {
ast: &program.ast,
settings: &Default::default(),
},
CacheInformation {
ast: &program.ast,
settings: &exec_ctxt.settings,
},
)
.await;
assert_eq!(
result,
CacheResult::ReExecute {
clear_scene: true,
reapply_settings: true,
program: program.ast
}
);
}
// Changing the grid settings with the exact same file should NOT bust the cache.
#[tokio::test(flavor = "multi_thread")]
async fn test_get_changed_program_same_code_but_different_grid_setting() {

7
rust/kcl-lib/src/execution/exec_ast.rs
View File

@ -101,12 +101,7 @@ impl ExecutorContext {
let old_units = exec_state.length_unit();
let original_execution = self.engine.replace_execution_kind(exec_kind).await;
let mut local_state = ModuleState::new(
&self.settings,
path.std_path(),
exec_state.stack().memory.clone(),
Some(module_id),
);
let mut local_state = ModuleState::new(path.std_path(), exec_state.stack().memory.clone(), Some(module_id));
if !preserve_mem {
std::mem::swap(&mut exec_state.mod_local, &mut local_state);
}

38
rust/kcl-lib/src/execution/mod.rs
View File

@ -38,7 +38,6 @@ use crate::{
fs::FileManager,
modules::{ModuleId, ModulePath},
parsing::ast::types::{Expr, ImportPath, NodeRef},
settings::types::UnitLength,
source_range::SourceRange,
std::StdLib,
CompilationError, ExecError, ExecutionKind, KclErrorWithOutputs,
@ -263,8 +262,6 @@ pub struct ExecutorContext {
#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema)]
#[ts(export)]
pub struct ExecutorSettings {
/// The project-default unit to use in modeling dimensions.
pub units: UnitLength,
/// Highlight edges of 3D objects?
pub highlight_edges: bool,
/// Whether or not Screen Space Ambient Occlusion (SSAO) is enabled.
@ -285,7 +282,6 @@ pub struct ExecutorSettings {
impl Default for ExecutorSettings {
fn default() -> Self {
Self {
units: Default::default(),
highlight_edges: true,
enable_ssao: false,
show_grid: false,
@ -299,7 +295,6 @@ impl Default for ExecutorSettings {
impl From<crate::settings::types::Configuration> for ExecutorSettings {
fn from(config: crate::settings::types::Configuration) -> Self {
Self {
units: config.settings.modeling.base_unit,
highlight_edges: config.settings.modeling.highlight_edges.into(),
enable_ssao: config.settings.modeling.enable_ssao.into(),
show_grid: config.settings.modeling.show_scale_grid,
@ -313,7 +308,6 @@ impl From<crate::settings::types::Configuration> for ExecutorSettings {
impl From<crate::settings::types::project::ProjectConfiguration> for ExecutorSettings {
fn from(config: crate::settings::types::project::ProjectConfiguration) -> Self {
Self {
units: config.settings.modeling.base_unit,
highlight_edges: config.settings.modeling.highlight_edges.into(),
enable_ssao: config.settings.modeling.enable_ssao.into(),
show_grid: Default::default(),
@ -327,7 +321,6 @@ impl From<crate::settings::types::project::ProjectConfiguration> for ExecutorSet
impl From<crate::settings::types::ModelingSettings> for ExecutorSettings {
fn from(modeling: crate::settings::types::ModelingSettings) -> Self {
Self {
units: modeling.base_unit,
highlight_edges: modeling.highlight_edges.into(),
enable_ssao: modeling.enable_ssao.into(),
show_grid: modeling.show_scale_grid,
@ -341,7 +334,6 @@ impl From<crate::settings::types::ModelingSettings> for ExecutorSettings {
impl From<crate::settings::types::project::ProjectModelingSettings> for ExecutorSettings {
fn from(modeling: crate::settings::types::project::ProjectModelingSettings) -> Self {
Self {
units: modeling.base_unit,
highlight_edges: modeling.highlight_edges.into(),
enable_ssao: modeling.enable_ssao.into(),
show_grid: Default::default(),
@ -474,26 +466,17 @@ impl ExecutorContext {
/// This allows for passing in `ZOO_API_TOKEN` and `ZOO_HOST` as environment
/// variables.
#[cfg(not(target_arch = "wasm32"))]
pub async fn new_with_default_client(units: UnitLength) -> Result<Self> {
pub async fn new_with_default_client() -> Result<Self> {
// Create the client.
let ctx = Self::new_with_client(
ExecutorSettings {
units,
..Default::default()
},
None,
None,
)
.await?;
let ctx = Self::new_with_client(Default::default(), None, None).await?;
Ok(ctx)
}
/// For executing unit tests.
#[cfg(not(target_arch = "wasm32"))]
pub async fn new_for_unit_test(units: UnitLength, engine_addr: Option<String>) -> Result<Self> {
pub async fn new_for_unit_test(engine_addr: Option<String>) -> Result<Self> {
let ctx = ExecutorContext::new_with_client(
ExecutorSettings {
units,
highlight_edges: true,
enable_ssao: false,
show_grid: false,
@ -844,11 +827,6 @@ impl ExecutorContext {
Ok(())
}
/// Update the units for the executor.
pub(crate) fn update_units(&mut self, units: UnitLength) {
self.settings.units = units;
}
/// Get a snapshot of the current scene.
pub async fn prepare_snapshot(&self) -> std::result::Result<TakeSnapshot, ExecError> {
// Zoom to fit.
@ -1905,9 +1883,7 @@ let w = f() + f()
)
"#;
let ctx = crate::test_server::new_context(UnitLength::Mm, true, None)
.await
.unwrap();
let ctx = crate::test_server::new_context(true, None).await.unwrap();
let old_program = crate::Program::parse_no_errs(code).unwrap();
// Execute the program.
@ -1960,9 +1936,7 @@ let w = f() + f()
)
"#;
let mut ctx = crate::test_server::new_context(UnitLength::Mm, true, None)
.await
.unwrap();
let mut ctx = crate::test_server::new_context(true, None).await.unwrap();
let old_program = crate::Program::parse_no_errs(code).unwrap();
// Execute the program.
@ -1998,7 +1972,7 @@ let w = f() + f()
#[tokio::test(flavor = "multi_thread")]
async fn mock_after_not_mock() {
let ctx = ExecutorContext::new_with_default_client(UnitLength::Mm).await.unwrap();
let ctx = ExecutorContext::new_with_default_client().await.unwrap();
let program = crate::Program::parse_no_errs("x = 2").unwrap();
let result = ctx.run_with_caching(program).await.unwrap();
assert_eq!(result.variables.get("x").unwrap().as_f64().unwrap(), 2.0);

13
rust/kcl-lib/src/execution/state.rs
View File

@ -79,7 +79,7 @@ impl ExecState {
pub fn new(exec_context: &super::ExecutorContext) -> Self {
ExecState {
global: GlobalState::new(&exec_context.settings),
mod_local: ModuleState::new(&exec_context.settings, None, ProgramMemory::new(), Default::default()),
mod_local: ModuleState::new(None, ProgramMemory::new(), Default::default()),
exec_context: Some(exec_context.clone()),
}
}
@ -89,7 +89,7 @@ impl ExecState {
*self = ExecState {
global,
mod_local: ModuleState::new(&exec_context.settings, None, ProgramMemory::new(), Default::default()),
mod_local: ModuleState::new(None, ProgramMemory::new(), Default::default()),
exec_context: Some(exec_context.clone()),
};
}
@ -286,19 +286,14 @@ impl GlobalState {
}
impl ModuleState {
pub(super) fn new(
exec_settings: &ExecutorSettings,
std_path: Option<String>,
memory: Arc<ProgramMemory>,
module_id: Option<ModuleId>,
) -> Self {
pub(super) fn new(std_path: Option<String>, memory: Arc<ProgramMemory>, module_id: Option<ModuleId>) -> Self {
ModuleState {
id_generator: IdGenerator::new(module_id),
stack: memory.new_stack(),
pipe_value: Default::default(),
module_exports: Default::default(),
settings: MetaSettings {
default_length_units: exec_settings.units.into(),
default_length_units: Default::default(),
default_angle_units: Default::default(),
std_path,
},

50
rust/kcl-lib/src/lsp/kcl/mod.rs
View File

@ -812,56 +812,6 @@ impl Backend {
Ok(())
}
pub async fn update_units(
&self,
params: custom_notifications::UpdateUnitsParams,
) -> RpcResult<Option<custom_notifications::UpdateUnitsResponse>> {
{
let mut ctx = self.executor_ctx.write().await;
// Borrow the executor context mutably.
let Some(ref mut executor_ctx) = *ctx else {
self.client
.log_message(MessageType::ERROR, "no executor context set to update units for")
.await;
return Ok(None);
};
self.client
.log_message(MessageType::INFO, format!("update units: {:?}", params))
.await;
if executor_ctx.settings.units == params.units
&& !self.has_diagnostics(params.text_document.uri.as_ref()).await
{
// Return early the units are the same.
return Ok(None);
}
// Set the engine units.
executor_ctx.update_units(params.units);
}
// Lock is dropped here since nested.
// This is IMPORTANT.
let new_params = TextDocumentItem {
uri: params.text_document.uri.clone(),
text: std::mem::take(&mut params.text.to_string()),
version: Default::default(),
language_id: Default::default(),
};
// Force re-execution.
self.inner_on_change(new_params, true).await;
// Check if we have diagnostics.
// If we do we return early, since we failed in some way.
if self.has_diagnostics(params.text_document.uri.as_ref()).await {
return Ok(None);
}
Ok(Some(custom_notifications::UpdateUnitsResponse {}))
}
pub async fn update_can_execute(
&self,
params: custom_notifications::UpdateCanExecuteParams,

1
rust/kcl-lib/src/lsp/test_util.rs
View File

@ -42,7 +42,6 @@ pub async fn kcl_lsp_server(execute: bool) -> Result<crate::lsp::kcl::Backend> {
can_execute: Arc::new(tokio::sync::RwLock::new(can_execute)),
is_initialized: Default::default(),
})
.custom_method("kcl/updateUnits", crate::lsp::kcl::Backend::update_units)
.custom_method("kcl/updateCanExecute", crate::lsp::kcl::Backend::update_can_execute)
.finish();

258
rust/kcl-lib/src/lsp/tests.rs
View File

@ -2320,78 +2320,6 @@ async fn kcl_test_kcl_lsp_on_change_update_memory() {
.await;
}
#[tokio::test(flavor = "multi_thread", worker_threads = 10)]
async fn kcl_test_kcl_lsp_update_units() {
let server = kcl_lsp_server(true).await.unwrap();
let same_text = r#"fn cube = (pos, scale) => {
sg = startSketchOn('XY')
|> startProfileAt(pos, %)
|> line(end = [0, scale])
|> line(end = [scale, 0])
|> line(end = [0, -scale])
return sg
}
part001 = cube([0,0], 20)
|> close()
|> extrude(length = 20)"#
.to_string();
// Send open file.
server
.did_open(tower_lsp::lsp_types::DidOpenTextDocumentParams {
text_document: tower_lsp::lsp_types::TextDocumentItem {
uri: "file:///test.kcl".try_into().unwrap(),
language_id: "kcl".to_string(),
version: 1,
text: same_text.clone(),
},
})
.await;
// Get the tokens.
let tokens = server.token_map.get("file:///test.kcl").unwrap().clone();
assert_eq!(tokens.as_slice().len(), 123);
// Get the ast.
let ast = server.ast_map.get("file:///test.kcl").unwrap().clone();
assert_eq!(ast.ast.body.len(), 2);
// Send change file.
server
.did_change(tower_lsp::lsp_types::DidChangeTextDocumentParams {
text_document: tower_lsp::lsp_types::VersionedTextDocumentIdentifier {
uri: "file:///test.kcl".try_into().unwrap(),
version: 1,
},
content_changes: vec![tower_lsp::lsp_types::TextDocumentContentChangeEvent {
range: None,
range_length: None,
text: same_text.clone(),
}],
})
.await;
let units = server.executor_ctx.read().await.clone().unwrap().settings.units;
assert_eq!(units, crate::settings::types::UnitLength::Mm);
// Update the units.
server
.update_units(crate::lsp::kcl::custom_notifications::UpdateUnitsParams {
text_document: crate::lsp::kcl::custom_notifications::TextDocumentIdentifier {
uri: "file:///test.kcl".try_into().unwrap(),
},
units: crate::settings::types::UnitLength::M,
text: same_text.clone(),
})
.await
.unwrap();
let units = server.executor_ctx().await.clone().unwrap().settings.units;
assert_eq!(units, crate::settings::types::UnitLength::M);
}
#[tokio::test(flavor = "multi_thread")]
async fn kcl_test_kcl_lsp_empty_file_execute_ok() {
let server = kcl_lsp_server(true).await.unwrap();
@ -2719,141 +2647,6 @@ async fn kcl_test_kcl_lsp_code_and_ast_unchanged_but_has_diagnostics_reexecute()
assert_diagnostic_count(server.diagnostics_map.get("file:///test.kcl").as_deref(), 0);
}
#[tokio::test(flavor = "multi_thread")]
async fn kcl_test_kcl_lsp_code_and_ast_units_unchanged_but_has_diagnostics_reexecute_on_unit_change() {
let server = kcl_lsp_server(true).await.unwrap();
let code = r#"part001 = startSketchOn('XY')
|> startProfileAt([-10, -10], %)
|> line(end = [20, 0])
|> line(end = [0, 20])
|> line(end = [-20, 0])
|> close()
|> extrude(length = 3.14)"#;
// Send open file.
server
.did_open(tower_lsp::lsp_types::DidOpenTextDocumentParams {
text_document: tower_lsp::lsp_types::TextDocumentItem {
uri: "file:///test.kcl".try_into().unwrap(),
language_id: "kcl".to_string(),
version: 1,
text: code.to_string(),
},
})
.await;
// Get the ast.
let ast = server.ast_map.get("file:///test.kcl").unwrap().clone();
assert!(ast.ast != Node::<Program>::default());
// Assure we have no diagnostics.
assert_diagnostic_count(server.diagnostics_map.get("file:///test.kcl").as_deref(), 0);
// Add some fake diagnostics.
server.diagnostics_map.insert(
"file:///test.kcl".to_string(),
vec![tower_lsp::lsp_types::Diagnostic {
range: tower_lsp::lsp_types::Range {
start: tower_lsp::lsp_types::Position { line: 0, character: 0 },
end: tower_lsp::lsp_types::Position { line: 0, character: 0 },
},
message: "fake diagnostic".to_string(),
severity: Some(tower_lsp::lsp_types::DiagnosticSeverity::ERROR),
code: None,
source: None,
related_information: None,
tags: None,
data: None,
code_description: None,
}],
);
// Assure we have one diagnostics.
assert_diagnostic_count(server.diagnostics_map.get("file:///test.kcl").as_deref(), 1);
let units = server.executor_ctx().await.clone().unwrap().settings.units;
assert_eq!(units, crate::settings::types::UnitLength::Mm);
// Update the units to the _same_ units.
server
.update_units(crate::lsp::kcl::custom_notifications::UpdateUnitsParams {
text_document: crate::lsp::kcl::custom_notifications::TextDocumentIdentifier {
uri: "file:///test.kcl".try_into().unwrap(),
},
units: crate::settings::types::UnitLength::Mm,
text: code.to_string(),
})
.await
.unwrap();
let units = server.executor_ctx().await.clone().unwrap().settings.units;
assert_eq!(units, crate::settings::types::UnitLength::Mm);
// Get the ast.
let ast = server.ast_map.get("file:///test.kcl").unwrap().clone();
assert!(ast.ast != Node::<Program>::default());
// Assure we have no diagnostics.
assert_diagnostic_count(server.diagnostics_map.get("file:///test.kcl").as_deref(), 0);
}
#[tokio::test(flavor = "multi_thread")]
async fn kcl_test_kcl_lsp_code_and_ast_units_unchanged_but_has_memory_reexecute_on_unit_change() {
let server = kcl_lsp_server(true).await.unwrap();
let code = r#"part001 = startSketchOn('XY')
|> startProfileAt([-10, -10], %)
|> line(end = [20, 0])
|> line(end = [0, 20])
|> line(end = [-20, 0])
|> close()
|> extrude(length = 3.14)"#;
// Send open file.
server
.did_open(tower_lsp::lsp_types::DidOpenTextDocumentParams {
text_document: tower_lsp::lsp_types::TextDocumentItem {
uri: "file:///test.kcl".try_into().unwrap(),
language_id: "kcl".to_string(),
version: 1,
text: code.to_string(),
},
})
.await;
// Get the ast.
let ast = server.ast_map.get("file:///test.kcl").unwrap().clone();
assert!(ast.ast != Node::<Program>::default());
// Assure we have no diagnostics.
assert_diagnostic_count(server.diagnostics_map.get("file:///test.kcl").as_deref(), 0);
let units = server.executor_ctx().await.clone().unwrap().settings.units;
assert_eq!(units, crate::settings::types::UnitLength::Mm);
// Update the units to the _same_ units.
server
.update_units(crate::lsp::kcl::custom_notifications::UpdateUnitsParams {
text_document: crate::lsp::kcl::custom_notifications::TextDocumentIdentifier {
uri: "file:///test.kcl".try_into().unwrap(),
},
units: crate::settings::types::UnitLength::Mm,
text: code.to_string(),
})
.await
.unwrap();
let units = server.executor_ctx().await.clone().unwrap().settings.units;
assert_eq!(units, crate::settings::types::UnitLength::Mm);
// Get the ast.
let ast = server.ast_map.get("file:///test.kcl").unwrap().clone();
assert!(ast.ast != Node::<Program>::default());
// Assure we have no diagnostics.
assert_diagnostic_count(server.diagnostics_map.get("file:///test.kcl").as_deref(), 0);
}
#[tokio::test(flavor = "multi_thread")]
async fn kcl_test_kcl_lsp_cant_execute_set() {
let server = kcl_lsp_server(true).await.unwrap();
@ -2885,23 +2678,6 @@ async fn kcl_test_kcl_lsp_cant_execute_set() {
// Assure we have no diagnostics.
assert_diagnostic_count(server.diagnostics_map.get("file:///test.kcl").as_deref(), 0);
// Update the units to the _same_ units.
let units = server.executor_ctx().await.clone().unwrap().settings.units;
assert_eq!(units, crate::settings::types::UnitLength::Mm);
server
.update_units(crate::lsp::kcl::custom_notifications::UpdateUnitsParams {
text_document: crate::lsp::kcl::custom_notifications::TextDocumentIdentifier {
uri: "file:///test.kcl".try_into().unwrap(),
},
units: crate::settings::types::UnitLength::Mm,
text: code.to_string(),
})
.await
.unwrap();
let units = server.executor_ctx().await.clone().unwrap().settings.units;
assert_eq!(units, crate::settings::types::UnitLength::Mm);
// Get the ast.
let ast = server.ast_map.get("file:///test.kcl").unwrap().clone();
assert!(ast.ast != Node::<Program>::default());
@ -2918,23 +2694,6 @@ async fn kcl_test_kcl_lsp_cant_execute_set() {
.unwrap();
assert_eq!(server.can_execute().await, false);
// Update the units to the _same_ units.
let units = server.executor_ctx().await.clone().unwrap().settings.units;
assert_eq!(units, crate::settings::types::UnitLength::Mm);
server
.update_units(crate::lsp::kcl::custom_notifications::UpdateUnitsParams {
text_document: crate::lsp::kcl::custom_notifications::TextDocumentIdentifier {
uri: "file:///test.kcl".try_into().unwrap(),
},
units: crate::settings::types::UnitLength::Mm,
text: code.to_string(),
})
.await
.unwrap();
let units = server.executor_ctx().await.clone().unwrap().settings.units;
assert_eq!(units, crate::settings::types::UnitLength::Mm);
let mut default_hashed = Node::<Program>::default();
default_hashed.compute_digest();
@ -2952,23 +2711,6 @@ async fn kcl_test_kcl_lsp_cant_execute_set() {
.unwrap();
assert_eq!(server.can_execute().await, true);
// Update the units to the _same_ units.
let units = server.executor_ctx.read().await.clone().unwrap().settings.units;
assert_eq!(units, crate::settings::types::UnitLength::Mm);
server
.update_units(crate::lsp::kcl::custom_notifications::UpdateUnitsParams {
text_document: crate::lsp::kcl::custom_notifications::TextDocumentIdentifier {
uri: "file:///test.kcl".try_into().unwrap(),
},
units: crate::settings::types::UnitLength::Mm,
text: code.to_string(),
})
.await
.unwrap();
let units = server.executor_ctx.read().await.clone().unwrap().settings.units;
assert_eq!(units, crate::settings::types::UnitLength::Mm);
// Get the ast.
let ast = server.ast_map.get("file:///test.kcl").unwrap().clone();
assert!(ast.ast != Node::<Program>::default());

8
rust/kcl-lib/src/simulation_tests.rs
View File

@ -153,12 +153,8 @@ async fn execute_test(test: &Test, render_to_png: bool, export_step: bool) {
let ast = crate::Program::parse_no_errs(&input).unwrap();
// Run the program.
let exec_res = crate::test_server::execute_and_snapshot_ast(
ast,
crate::settings::types::UnitLength::Mm,
Some(test.input_dir.join(&test.entry_point)),
export_step,
)
let exec_res =
crate::test_server::execute_and_snapshot_ast(ast, Some(test.input_dir.join(&test.entry_point)), export_step)
.await;
match exec_res {
Ok((exec_state, env_ref, png, step)) => {

25
rust/kcl-lib/src/test_server.rs
View File

@ -6,7 +6,6 @@ use crate::{
engine::new_zoo_client,
errors::ExecErrorWithState,
execution::{EnvironmentRef, ExecState, ExecutorContext, ExecutorSettings},
settings::types::UnitLength,
ConnectionError, ExecError, KclError, KclErrorWithOutputs, Program,
};
@ -19,12 +18,8 @@ pub struct RequestBody {
/// Executes a kcl program and takes a snapshot of the result.
/// This returns the bytes of the snapshot.
pub async fn execute_and_snapshot(
code: &str,
units: UnitLength,
current_file: Option<PathBuf>,
) -> Result<image::DynamicImage, ExecError> {
let ctx = new_context(units, true, current_file).await?;
pub async fn execute_and_snapshot(code: &str, current_file: Option<PathBuf>) -> Result<image::DynamicImage, ExecError> {
let ctx = new_context(true, current_file).await?;
let program = Program::parse_no_errs(code).map_err(KclErrorWithOutputs::no_outputs)?;
let res = do_execute_and_snapshot(&ctx, program)
.await
@ -38,11 +33,10 @@ pub async fn execute_and_snapshot(
/// This returns the bytes of the snapshot.
pub async fn execute_and_snapshot_ast(
ast: Program,
units: UnitLength,
current_file: Option<PathBuf>,
with_export_step: bool,
) -> Result<(ExecState, EnvironmentRef, image::DynamicImage, Option<Vec<u8>>), ExecErrorWithState> {
let ctx = new_context(units, true, current_file).await?;
let ctx = new_context(true, current_file).await?;
let (exec_state, env, img) = do_execute_and_snapshot(&ctx, ast).await?;
let mut step = None;
if with_export_step {
@ -64,10 +58,9 @@ pub async fn execute_and_snapshot_ast(
pub async fn execute_and_snapshot_no_auth(
code: &str,
units: UnitLength,
current_file: Option<PathBuf>,
) -> Result<(image::DynamicImage, EnvironmentRef), ExecError> {
let ctx = new_context(units, false, current_file).await?;
let ctx = new_context(false, current_file).await?;
let program = Program::parse_no_errs(code).map_err(KclErrorWithOutputs::no_outputs)?;
let res = do_execute_and_snapshot(&ctx, program)
.await
@ -111,11 +104,7 @@ async fn do_execute_and_snapshot(
Ok((exec_state, result.0, img))
}
pub async fn new_context(
units: UnitLength,
with_auth: bool,
current_file: Option<PathBuf>,
) -> Result<ExecutorContext, ConnectionError> {
pub async fn new_context(with_auth: bool, current_file: Option<PathBuf>) -> Result<ExecutorContext, ConnectionError> {
let mut client = new_zoo_client(if with_auth { None } else { Some("bad_token".to_string()) }, None)
.map_err(ConnectionError::CouldNotMakeClient)?;
if !with_auth {
@ -126,7 +115,6 @@ pub async fn new_context(
}
let mut settings = ExecutorSettings {
units,
highlight_edges: true,
enable_ssao: false,
show_grid: false,
@ -145,7 +133,6 @@ pub async fn new_context(
pub async fn execute_and_export_step(
code: &str,
units: UnitLength,
current_file: Option<PathBuf>,
) -> Result<
(
@ -155,7 +142,7 @@ pub async fn execute_and_export_step(
),
ExecErrorWithState,
> {
let ctx = new_context(units, true, current_file).await?;
let ctx = new_context(true, current_file).await?;
let mut exec_state = ExecState::new(&ctx);
let program = Program::parse_no_errs(code)
.map_err(|err| ExecErrorWithState::new(KclErrorWithOutputs::no_outputs(err).into(), exec_state.clone()))?;

6
rust/kcl-test-server/src/lib.rs
View File

@ -15,7 +15,7 @@ use hyper::{
service::{make_service_fn, service_fn},
Body, Error, Response, Server,
};
use kcl_lib::{test_server::RequestBody, ExecState, ExecutorContext, Program, UnitLength};
use kcl_lib::{test_server::RequestBody, ExecState, ExecutorContext, Program};
use tokio::{
sync::{mpsc, oneshot},
task::JoinHandle,
@ -69,9 +69,7 @@ fn start_worker(i: u8, engine_addr: Option<String>) -> mpsc::Sender<WorkerReq> {
// Make a work queue for this worker.
let (tx, mut rx) = mpsc::channel(1);
tokio::task::spawn(async move {
let state = ExecutorContext::new_for_unit_test(UnitLength::Mm, engine_addr)
.await
.unwrap();
let state = ExecutorContext::new_for_unit_test(engine_addr).await.unwrap();
println!("Worker {i} ready");
while let Some(req) = rx.recv().await {
let req: WorkerReq = req;

1
rust/kcl-wasm-lib/src/lsp.rs
View File

@ -69,7 +69,6 @@ pub async fn lsp_run_kcl(config: LspServerConfig, token: String, baseurl: String
let (service, socket) = LspService::build(|client| {
kcl_lib::KclLspBackend::new_wasm(client, executor_ctx, fs, zoo_client, can_send_telemetry).unwrap()
})
.custom_method("kcl/updateUnits", kcl_lib::KclLspBackend::update_units)
.custom_method("kcl/updateCanExecute", kcl_lib::KclLspBackend::update_can_execute)
.finish();