rite-ls 0.2.2

Language server for the Rite ceremony DSL
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140

//! Document symbols for ceremony YAML.
//!
//! Produces a nested symbol tree for editor outline/breadcrumb navigation:
//!
//! - Acts (Module)
//!   - Sections belonging to that act (Namespace)
//! - Roles (Variable)
//! - Parameters (Constant)
//! - Materials (Object)
//!
//! Sections not assigned to any act appear as top-level Namespace symbols.

use crate::convert;
use rite_model::{ActId, Ceremony};
use rite_resolver::SpanMap;
use std::collections::HashMap;
use tower_lsp_server::ls_types::{DocumentSymbol, Range, SymbolKind};

/// Build the document symbol tree for a ceremony.
pub fn document_symbols(span_map: &SpanMap, resolved: &Ceremony) -> Vec<DocumentSymbol> {
    let mut symbols: Vec<DocumentSymbol> = Vec::new();

    // Single pass over sections: group by act or collect as orphans.
    let mut sections_by_act: HashMap<&ActId, Vec<DocumentSymbol>> = HashMap::new();
    let mut orphan_sections: Vec<DocumentSymbol> = Vec::new();
    for (sec_id, sec) in resolved.sections.iter() {
        let sec_range = span_map
            .sections
            .get(sec_id)
            .map(|s| convert::point_range(convert::span_to_position(*s)))
            .unwrap_or_default();
        let sym = make_symbol(
            sec_id.as_str(),
            sec.name.as_deref(),
            SymbolKind::NAMESPACE,
            sec_range,
            None,
        );
        match &sec.act {
            Some(act_id) => sections_by_act.entry(act_id).or_default().push(sym),
            None => orphan_sections.push(sym),
        }
    }

    // Acts with their pre-grouped section children.
    for (act_id, act) in resolved.acts.iter() {
        let act_range = span_map
            .acts
            .get(act_id)
            .map(|s| convert::point_range(convert::span_to_position(*s)))
            .unwrap_or_default();
        let children = sections_by_act.remove(act_id);
        let detail = act.name.clone().or_else(|| act.description.clone());
        symbols.push(make_symbol(
            act_id.as_str(),
            detail.as_deref(),
            SymbolKind::MODULE,
            act_range,
            children,
        ));
    }

    // Sections not assigned to any act.
    symbols.extend(orphan_sections);

    // Roles.
    for (role_id, role) in resolved.roles.iter() {
        let range = span_map
            .roles
            .get(role_id)
            .map(|s| convert::point_range(convert::span_to_position(*s)))
            .unwrap_or_default();
        let detail = if role.name != role_id.as_str() {
            Some(role.name.as_str())
        } else {
            None
        };
        symbols.push(make_symbol(
            role_id.as_str(),
            detail,
            SymbolKind::VARIABLE,
            range,
            None,
        ));
    }

    // Parameters.
    for (param_id, param) in resolved.parameters.iter() {
        let range = span_map
            .params
            .get(param_id)
            .map(|s| convert::point_range(convert::span_to_position(*s)))
            .unwrap_or_default();
        symbols.push(make_symbol(
            param_id.as_str(),
            param.description.as_deref(),
            SymbolKind::CONSTANT,
            range,
            None,
        ));
    }

    // Materials.
    for (mat_id, mat) in resolved.materials.iter() {
        let range = span_map
            .materials
            .get(mat_id)
            .map(|s| convert::point_range(convert::span_to_position(*s)))
            .unwrap_or_default();
        symbols.push(make_symbol(
            mat_id.as_str(),
            mat.title.as_deref(),
            SymbolKind::OBJECT,
            range,
            None,
        ));
    }

    symbols
}

#[allow(deprecated)]
fn make_symbol(
    name: &str,
    detail: Option<&str>,
    kind: SymbolKind,
    range: Range,
    children: Option<Vec<DocumentSymbol>>,
) -> DocumentSymbol {
    DocumentSymbol {
        name: name.to_string(),
        detail: detail.map(str::to_string),
        kind,
        range,
        selection_range: range,
        children,
        tags: None,
        deprecated: None,
    }
}