Skip to main content

omena_bridge/
selector_references.rs

1use engine_input_producers::{
2    EngineInputV2, RangeV2, summarize_selector_usage_evaluator_candidates_input,
3};
4use serde::Serialize;
5
6#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
7#[serde(rename_all = "camelCase")]
8pub struct SelectorReferenceEngineSummaryV0 {
9    pub schema_version: &'static str,
10    pub product: &'static str,
11    pub style_path: Option<String>,
12    pub selector_count: usize,
13    pub referenced_selector_count: usize,
14    pub unreferenced_selector_count: usize,
15    pub total_reference_sites: usize,
16    pub selectors: Vec<SelectorReferenceSummaryV0>,
17}
18
19#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
20#[serde(rename_all = "camelCase")]
21pub struct SelectorReferenceSummaryV0 {
22    pub canonical_id: String,
23    pub file_path: String,
24    pub local_name: String,
25    pub total_references: usize,
26    pub direct_reference_count: usize,
27    pub editable_direct_reference_count: usize,
28    pub exact_reference_count: usize,
29    pub inferred_or_better_reference_count: usize,
30    pub has_expanded_references: bool,
31    pub has_style_dependency_references: bool,
32    pub has_any_references: bool,
33    pub sites: Vec<SelectorReferenceSiteV0>,
34    pub editable_direct_sites: Vec<SelectorEditableDirectReferenceSiteV0>,
35}
36
37#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
38#[serde(rename_all = "camelCase")]
39pub struct SelectorReferenceSiteV0 {
40    pub file_path: String,
41    pub range: RangeV2,
42    pub expansion: String,
43    pub reference_kind: String,
44}
45
46#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
47#[serde(rename_all = "camelCase")]
48pub struct SelectorEditableDirectReferenceSiteV0 {
49    pub file_path: String,
50    pub range: RangeV2,
51    pub class_name: String,
52}
53
54pub fn summarize_omena_bridge_selector_reference_engine(
55    input: &EngineInputV2,
56    style_path: Option<&str>,
57) -> SelectorReferenceEngineSummaryV0 {
58    let candidates = summarize_selector_usage_evaluator_candidates_input(input);
59    let selectors = candidates
60        .results
61        .into_iter()
62        .filter(|candidate| match style_path {
63            Some(path) => candidate.file_path == path,
64            None => true,
65        })
66        .map(|candidate| {
67            let payload = candidate.payload;
68            SelectorReferenceSummaryV0 {
69                canonical_id: format!("selector:{}", payload.canonical_name),
70                file_path: candidate.file_path,
71                local_name: payload.canonical_name,
72                total_references: payload.total_references,
73                direct_reference_count: payload.direct_reference_count,
74                editable_direct_reference_count: payload.editable_direct_reference_count,
75                exact_reference_count: payload.exact_reference_count,
76                inferred_or_better_reference_count: payload.inferred_or_better_reference_count,
77                has_expanded_references: payload.has_expanded_references,
78                has_style_dependency_references: payload.has_style_dependency_references,
79                has_any_references: payload.has_any_references,
80                sites: payload
81                    .all_sites
82                    .into_iter()
83                    .map(|site| SelectorReferenceSiteV0 {
84                        file_path: site.file_path,
85                        range: site.range,
86                        expansion: site.expansion,
87                        reference_kind: site.reference_kind,
88                    })
89                    .collect(),
90                editable_direct_sites: payload
91                    .editable_direct_sites
92                    .into_iter()
93                    .map(|site| SelectorEditableDirectReferenceSiteV0 {
94                        file_path: site.file_path,
95                        range: site.range,
96                        class_name: site.class_name,
97                    })
98                    .collect(),
99            }
100        })
101        .collect::<Vec<_>>();
102
103    let referenced_selector_count = selectors
104        .iter()
105        .filter(|selector| selector.has_any_references)
106        .count();
107    let total_reference_sites = selectors
108        .iter()
109        .map(|selector| selector.sites.len())
110        .sum::<usize>();
111
112    SelectorReferenceEngineSummaryV0 {
113        schema_version: "0",
114        product: "omena-semantic.selector-references",
115        style_path: style_path.map(ToOwned::to_owned),
116        selector_count: selectors.len(),
117        referenced_selector_count,
118        unreferenced_selector_count: selectors.len() - referenced_selector_count,
119        total_reference_sites,
120        selectors,
121    }
122}