diff --git a/crates/engine/src/cmd/component.rs b/crates/engine/src/cmd/component.rs index 15e6ebd97..e14ec5c49 100644 --- a/crates/engine/src/cmd/component.rs +++ b/crates/engine/src/cmd/component.rs @@ -3,8 +3,10 @@ //! belong to their feature's component unless moved; occurrences place components (instances //! share contents, "paste new" copies them) and can be grounded and moved. +use std::collections::HashMap; + use serde_json::{Value, json}; -use solidcraft_doc::{FeatureKind, Mat, Occurrence}; +use solidcraft_doc::{Feature, FeatureKind, Mat, Occurrence}; use solidcraft_geom::Vec3; use super::CommandSpec; @@ -204,24 +206,30 @@ fn list(s: &mut Session, p: &Value) -> Result { } v }; + // Each component's bodies, features, occurrences and children, grouped once rather than + // searched for every component (thousands of each in a design with many components). + let mut bodies_of: HashMap> = HashMap::new(); + for b in &st.bodies { + bodies_of.entry(doc.model_body_component(b)).or_default().push(b.name.as_str()); + } + let mut features_of: HashMap> = HashMap::new(); + for f in &doc.features { + features_of.entry(f.component).or_default().push(f); + } + let (mut occurrences_of, mut children_of): (HashMap>, HashMap>) = Default::default(); + for o in &doc.occurrences { + occurrences_of.entry(o.component).or_default().push(o); + children_of.entry(o.parent).or_default().push(o); + } let node = |id: u64, name: &str, parent: Option| { - let bodies: Vec<&str> = st.bodies.iter().filter(|b| doc.model_body_component(b) == id).map(|b| b.name.as_str()).collect(); - let features: Vec<&str> = doc - .features - .iter() - .filter(|f| f.component == id && !matches!(f.kind, FeatureKind::Sketch { .. } | FeatureKind::ConstructionPlane { .. })) - .map(|f| f.name.as_str()) - .collect(); - let sketches: Vec<&str> = - doc.features.iter().filter(|f| f.component == id && matches!(f.kind, FeatureKind::Sketch { .. })).map(|f| f.name.as_str()).collect(); - let construction: Vec<&str> = doc - .features - .iter() - .filter(|f| f.component == id && matches!(f.kind, FeatureKind::ConstructionPlane { .. })) - .map(|f| f.name.as_str()) - .collect(); - let occurrences: Vec = doc.occurrences.iter().filter(|o| o.component == id).map(placement).collect(); - let children: Vec = doc.occurrences.iter().filter(|o| o.parent == id).map(|o| if compact { json!(o.id) } else { json!(o) }).collect(); + let bodies = bodies_of.get(&id).cloned().unwrap_or_default(); + let features = features_of.get(&id).map(Vec::as_slice).unwrap_or_default(); + let named = |keep: fn(&FeatureKind) -> bool| -> Vec<&str> { features.iter().filter(|f| keep(&f.kind)).map(|f| f.name.as_str()).collect() }; + let sketches = named(|k| matches!(k, FeatureKind::Sketch { .. })); + let construction = named(|k| matches!(k, FeatureKind::ConstructionPlane { .. })); + let features = named(|k| !matches!(k, FeatureKind::Sketch { .. } | FeatureKind::ConstructionPlane { .. })); + let occurrences: Vec = occurrences_of.get(&id).into_iter().flatten().map(|o| placement(o)).collect(); + let children: Vec = children_of.get(&id).into_iter().flatten().map(|o| if compact { json!(o.id) } else { json!(o) }).collect(); let bodies = if body_names { json!(bodies) } else { json!(bodies.len()) }; json!({"id": id, "name": name, "parent": parent, "bodies": bodies, "features": names(features), "sketches": names(sketches), "construction": names(construction), "occurrences": occurrences, "children": children}) diff --git a/crates/engine/src/cmd/occurrence_tests.rs b/crates/engine/src/cmd/occurrence_tests.rs index 6d7c85c10..24da8dd81 100644 --- a/crates/engine/src/cmd/occurrence_tests.rs +++ b/crates/engine/src/cmd/occurrence_tests.rs @@ -620,6 +620,37 @@ fn compact_component_list_counts_and_skips_identity_transforms() { assert_eq!(block(&run(&mut s, "component.list", json!({"compact": true, "bodies": true})))["bodies"], json!(["Cube"])); } +/// Each component lists only what it holds, in timeline order: its bodies, features and +/// sketches, its own occurrences and the occurrences inside it, through nested components. +#[test] +fn component_list_gives_each_component_only_its_own_contents() { + let mut s = Session::default(); + run(&mut s, "solid.box", json!({"length": 5, "width": 5, "height": 5, "name": "Base", "body_name": "Base"})); + let (arm, arm_first) = created(&mut s, "Arm"); + run(&mut s, "sketch.create", json!({"plane": "XY", "name": "Arm sketch"})); + run(&mut s, "solid.box", json!({"corner": [0, 20, 0], "length": 2, "width": 2, "height": 2, "name": "Lug", "body_name": "Lug"})); + let pin = run(&mut s, "component.create", json!({"name": "Pin", "parent": arm, "parent_path": [arm_first]})); + let (pin, pin_first) = (pin["component"].as_u64().unwrap(), pin["occurrence"].as_u64().unwrap()); + run(&mut s, "solid.box", json!({"corner": [0, 40, 0], "length": 1, "width": 1, "height": 1, "name": "Shank", "body_name": "Shank"})); + run(&mut s, "solid.box", json!({"corner": [0, 50, 0], "length": 1, "width": 1, "height": 1, "name": "Head", "body_name": "Head"})); + run(&mut s, "component.activate", json!({"component": "root"})); + let arm_second = run(&mut s, "occurrence.copy", json!({"component": arm, "translate": [30, 0, 0]}))["occurrence"].as_u64().unwrap(); + let list = run(&mut s, "component.list", json!({})); + let of = |id: u64| list["components"].as_array().unwrap().iter().find(|c| c["id"] == id).unwrap().clone(); + let ids = |v: &Value| v.as_array().unwrap().iter().map(|o| o["id"].as_u64().unwrap()).collect::>(); + let (root, arm_node, pin_node) = (of(0), of(arm), of(pin)); + assert_eq!((&root["bodies"], &root["features"], &root["sketches"]), (&json!(["Base"]), &json!(["Base"]), &json!([])), "{root}"); + assert_eq!(ids(&root["children"]), vec![arm_first, arm_second], "{root}"); + assert_eq!( + (&arm_node["bodies"], &arm_node["features"], &arm_node["sketches"]), + (&json!(["Lug"]), &json!(["Lug"]), &json!(["Arm sketch"])), + "{arm_node}" + ); + assert_eq!((ids(&arm_node["occurrences"]), ids(&arm_node["children"])), (vec![arm_first, arm_second], vec![pin_first]), "{arm_node}"); + assert_eq!((&pin_node["bodies"], &pin_node["features"]), (&json!(["Shank", "Head"]), &json!(["Shank", "Head"])), "{pin_node}"); + assert_eq!((ids(&pin_node["occurrences"]), ids(&pin_node["children"])), (vec![pin_first], vec![]), "{pin_node}"); +} + /// A script's 3x4 placement matrix (rotation rows, then the translation column) moves an /// occurrence exactly as the same turn and move given as an axis, an angle and a translation. #[test]