brep_kernel/feature_pipeline/

context_offer.rs

//! Selection-context applicability — kernel-owned show/no-show for the app's
//! selection context bar.
//!
//! Each feature module exposes `context_applicable(&SelectionProbe) -> bool`
//! next to its `schema()`: the ONE per-feature answer to "does the current
//! selection make creating me meaningful?". This module only AGGREGATES those
//! functions (the `schema.rs` pattern) into [`FEATURE_APPLICABILITY`], keyed by
//! the catalogue `type` string, and the assembly-constraint equivalents live as
//! `applicable` on each [`super::assembly::constraints::ConstraintTypeDef`].
//!
//! The probe is a KIND-LEVEL summary — per-kind counts plus a few app-derived
//! roll-up booleans (`all_component`, `all_sheet_metal`) that answer ownership
//! questions the raw names would; never the names themselves. Predicates decide
//! eligibility; the app still derives WHICH reference fields to pre-fill from
//! the schema `selectionFilter`s. A feature whose references a selection can
//! never satisfy (primitives, datum-driven splines) simply returns `false`.

/// Kind-level summary of the user's current selection, handed to each
/// feature's / constraint's `context_applicable` test.
///
/// `solids` counts REAL solids only — committed sketches present in the scene
/// as solids, but their reference kind is `SKETCH`, so the app partitions them
/// into `sketches` before probing (the context bar's established split).
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
pub struct SelectionProbe {
    pub solids: usize,
    pub sketches: usize,
    pub faces: usize,
    pub edges: usize,
    /// Selected construction PLANES / DATUM planes (their scene FRAME names, e.g.
    /// `Datum:XY` or a `P` plane feature's id). A datum/plane can seat a sketch's
    /// `sketchPlane` (the kernel resolves a frame name there), so Sketch offers on
    /// a plane-only selection just like it does on a planar face.
    pub planes: usize,
    /// Selected vertices (position-keyed, no names — no feature offer keys on
    /// them, but they disqualify component-only shapes via `all_component`).
    pub vertices: usize,
    /// Distinct owning ACOMP components across the selected named entities.
    pub components: usize,
    /// Every selected named entity is component-owned (and ≥1 is selected).
    /// Feature creation is fenced on component geometry, so feature predicates
    /// never see it; constraint predicates REQUIRE it (`mapping::resolve_element`
    /// rejects non-component references).
    pub all_component: bool,
    /// Every selected named entity sits on a SHEET-METAL body (and ≥1 is
    /// selected) — the app resolves each pick's owning solid and checks its
    /// `SheetTree` marker. The sheet-metal EDIT features (SM Flange / Fillet /
    /// Chamfer) require it: they mutate an existing sheet-metal body, so they
    /// are meaningless on plain geometry.
    pub all_sheet_metal: bool,
}

impl SelectionProbe {
    /// A profile source is selected (the extrude/revolve/sweep family's
    /// `["SKETCH","FACE"]` fields).
    pub fn has_profile(&self) -> bool {
        self.faces > 0 || self.sketches > 0
    }
}

/// Every catalogue feature's applicability predicate, catalogue order, keyed by
/// the schema `type` string ([`super::schema::feature_schema_catalogue`] —
/// `sheet_metal_corner` contributes two entries from one module). The paired
/// test keeps this 1:1 with the catalogue.
pub static FEATURE_APPLICABILITY: &[(&str, fn(&SelectionProbe) -> bool)] = &[
    ("D", super::features::datum::context_applicable),
    ("P", super::features::plane::context_applicable),
    ("P.CU", super::features::cube::context_applicable),
    ("P.CY", super::features::cylinder::context_applicable),
    ("P.CO", super::features::cone::context_applicable),
    ("P.S", super::features::sphere::context_applicable),
    ("P.T", super::features::torus::context_applicable),
    ("P.PY", super::features::pyramid::context_applicable),
    ("IMPORT3D", super::features::import3d::context_applicable),
    ("S", super::features::sketch::context_applicable),
    ("SP", super::features::spline::context_applicable),
    ("PORT", super::features::port::context_applicable),
    ("HX", super::features::helix::context_applicable),
    ("E", super::features::extrude::context_applicable),
    ("B", super::features::boolean::context_applicable),
    ("F", super::features::fillet::context_applicable),
    ("CH", super::features::chamfer::context_applicable),
    ("O.S", super::features::offset_shell::context_applicable),
    ("O.F", super::features::offset_face::context_applicable),
    ("PF", super::features::push_face::context_applicable),
    ("DF", super::features::delete_face::context_applicable),
    ("THK", super::features::thicken::context_applicable),
    ("SM.TAB", super::features::sheet_metal_tab::context_applicable),
    ("SM.CF", super::features::sheet_metal_contour_flange::context_applicable),
    ("SM.F", super::features::sheet_metal_flange::context_applicable),
    ("SM.HEM", super::features::sheet_metal_hem::context_applicable),
    ("SM.FILLET", super::features::sheet_metal_corner::context_applicable),
    ("SM.CHAMFER", super::features::sheet_metal_corner::context_applicable),
    ("SM.CUTOUT", super::features::sheet_metal_cutout::context_applicable),
    ("LOFT", super::features::loft::context_applicable),
    ("M", super::features::mirror::context_applicable),
    ("SPL", super::features::split::context_applicable),
    ("R", super::features::revolve::context_applicable),
    ("RIB", super::features::rib::context_applicable),
    ("SW", super::features::sweep::context_applicable),
    ("SWP", super::features::path_sweep::context_applicable),
    ("H", super::features::hole::context_applicable),
    ("TU", super::features::tube::context_applicable),
    ("XFORM", super::features::transform::context_applicable),
    ("PATTERN", super::features::pattern::context_applicable),
    ("ACOMP", super::features::assembly_component::context_applicable),
];

/// Run feature `type_id`'s applicability predicate. Unknown type → `false`
/// (nothing is offered for a feature the registry does not know).
pub fn feature_context_applicable(type_id: &str, probe: &SelectionProbe) -> bool {
    FEATURE_APPLICABILITY
        .iter()
        .find(|(id, _)| *id == type_id)
        .is_some_and(|(_, applicable)| applicable(probe))
}

#[cfg(test)]
mod tests {
    use super::*;

    /// The registry stays 1:1 with the schema catalogue: every catalogue `type`
    /// has exactly one predicate, and no registry row points at a type outside
    /// the catalogue.
    #[test]
    fn applicability_registry_matches_the_catalogue() {
        let catalogue = crate::feature_pipeline::feature_schema_catalogue();
        let types: Vec<String> = catalogue["features"]
            .as_array()
            .expect("features array")
            .iter()
            .map(|f| f["type"].as_str().expect("type string").to_string())
            .collect();
        let registry: Vec<&str> = FEATURE_APPLICABILITY.iter().map(|(id, _)| *id).collect();
        for ty in &types {
            assert!(
                registry.contains(&ty.as_str()),
                "catalogue feature {ty} has no applicability predicate"
            );
        }
        for id in &registry {
            assert!(
                types.iter().any(|ty| ty == id),
                "registry row {id} is not a catalogue feature"
            );
        }
        assert_eq!(registry.len(), types.len(), "duplicate registry rows");
    }

    /// The one user-specified nuance: Revolve needs a profile AND an axis edge
    /// — a face or sketch alone no longer offers it.
    #[test]
    fn revolve_requires_profile_and_axis() {
        let face_only = SelectionProbe { faces: 1, ..Default::default() };
        assert!(!feature_context_applicable("R", &face_only));
        let sketch_only = SelectionProbe { sketches: 1, ..Default::default() };
        assert!(!feature_context_applicable("R", &sketch_only));
        let edge_only = SelectionProbe { edges: 1, ..Default::default() };
        assert!(!feature_context_applicable("R", &edge_only));
        let face_and_axis = SelectionProbe { faces: 1, edges: 1, ..Default::default() };
        assert!(feature_context_applicable("R", &face_and_axis));
        let sketch_and_axis = SelectionProbe { sketches: 1, edges: 1, ..Default::default() };
        assert!(feature_context_applicable("R", &sketch_and_axis));
    }

    /// The sheet-metal EDIT features (SM Flange / SM Fillet / SM Chamfer) only
    /// offer when the selection sits on an existing sheet-metal body: without
    /// `all_sheet_metal`, a plain face/edge/solid offers none of them; with it,
    /// each offers on the kind it accepts.
    #[test]
    fn sheet_metal_edits_require_a_sheet_metal_selection() {
        for probe in [
            SelectionProbe { faces: 1, ..Default::default() },
            SelectionProbe { edges: 1, ..Default::default() },
            SelectionProbe { solids: 1, ..Default::default() },
        ] {
            for ty in ["SM.F", "SM.FILLET", "SM.CHAMFER"] {
                assert!(
                    !feature_context_applicable(ty, &probe),
                    "{ty} must not offer on non-sheet-metal geometry: {probe:?}"
                );
            }
        }
        // On a sheet-metal body: Flange takes an edge or a side face; SM Fillet /
        // Chamfer additionally take the whole solid (a corner of the flat).
        let sm_face = SelectionProbe { faces: 1, all_sheet_metal: true, ..Default::default() };
        let sm_edge = SelectionProbe { edges: 1, all_sheet_metal: true, ..Default::default() };
        let sm_solid = SelectionProbe { solids: 1, all_sheet_metal: true, ..Default::default() };
        for probe in [&sm_face, &sm_edge] {
            for ty in ["SM.F", "SM.FILLET", "SM.CHAMFER"] {
                assert!(feature_context_applicable(ty, probe), "{ty} offers on sheet metal");
            }
        }
        // A lone sheet-metal SOLID: SM Fillet / Chamfer accept it, Flange (edge/
        // face only) does not.
        assert!(feature_context_applicable("SM.FILLET", &sm_solid));
        assert!(feature_context_applicable("SM.CHAMFER", &sm_solid));
        assert!(!feature_context_applicable("SM.F", &sm_solid));
    }

    /// A construction PLANE / DATUM plane selection (its scene frame name) offers
    /// Sketch: the `sketchPlane` field resolves a frame name just like a planar
    /// face, so a plane-only selection is a valid sketch seat.
    #[test]
    fn plane_selection_offers_sketch() {
        let plane_only = SelectionProbe { planes: 1, ..Default::default() };
        assert!(
            feature_context_applicable("S", &plane_only),
            "a plane/datum-only selection should offer Sketch"
        );
        // …and it drives nothing else (no profile/solid/edge feature keys on a
        // bare plane).
        for ty in ["E", "F", "CH", "B", "XFORM", "R"] {
            assert!(
                !feature_context_applicable(ty, &plane_only),
                "{ty} must not offer on a plane-only selection"
            );
        }
    }

    /// Parity spot-checks: the schema-intersection semantics the predicates
    /// preserve for everything but revolve.
    #[test]
    fn parity_predicates_match_reference_filters() {
        let face = SelectionProbe { faces: 1, ..Default::default() };
        let edge = SelectionProbe { edges: 1, ..Default::default() };
        let solid = SelectionProbe { solids: 1, ..Default::default() };
        let sketch = SelectionProbe { sketches: 1, ..Default::default() };

        // FACE drives the face-primary features…
        for ty in ["E", "O.F", "PF", "O.S", "THK", "DF", "F", "CH", "M", "SPL", "PATTERN", "S"] {
            assert!(feature_context_applicable(ty, &face), "FACE should offer {ty}");
        }
        // …EDGE the edge-primary ones…
        for ty in ["F", "CH", "TU", "HX", "RIB", "S"] {
            assert!(feature_context_applicable(ty, &edge), "EDGE should offer {ty}");
        }
        assert!(!feature_context_applicable("E", &edge), "EDGE must not offer Extrude");
        // …SOLID the solid-primary ones…
        for ty in ["B", "M", "XFORM", "PATTERN", "SPL", "RIB", "SM.CUTOUT"] {
            assert!(feature_context_applicable(ty, &solid), "SOLID should offer {ty}");
        }
        assert!(!feature_context_applicable("F", &solid), "SOLID must not offer Fillet");
        // …SKETCH the profile-driven ones (hole places on a sketch)…
        for ty in ["E", "H", "SM.CUTOUT", "SM.TAB", "SW", "SWP", "LOFT"] {
            assert!(feature_context_applicable(ty, &sketch), "SKETCH should offer {ty}");
        }
        // …and no selection ever offers a primitive or reference-less feature.
        let all = SelectionProbe {
            solids: 1,
            sketches: 1,
            faces: 1,
            edges: 1,
            ..Default::default()
        };
        for ty in ["P.CU", "P.CY", "P.CO", "P.S", "P.T", "P.PY", "D", "IMPORT3D", "SP", "ACOMP"] {
            assert!(!feature_context_applicable(ty, &all), "{ty} must never be offered");
        }
        // Unknown type → false, never a panic.
        assert!(!feature_context_applicable("NOPE", &all));
    }
}