rototo 0.1.0-alpha.8

Control plane for runtime configuration of your application.
Documentation 
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

mod catalog;
mod evaluation_context;
mod fields;
mod governance;
mod layers;
mod lists;
mod manifest;
mod variable;

use super::index::{CustomLintFileNode, SemanticIndex};
use super::source::{DocumentKind, SourceStore};
use super::syntax::SyntaxIndex;

pub(super) use fields::json_from_toml_value;

pub(super) fn build_semantic_index(source: &SourceStore, syntax: &SyntaxIndex) -> SemanticIndex {
    let mut index = SemanticIndex::default();

    for document in source.documents.values() {
        match &document.kind {
            DocumentKind::Manifest => {
                let Some(toml) = syntax.toml.get(&document.id) else {
                    continue;
                };
                index.manifest = Some(manifest::project_manifest(document, toml));
            }
            DocumentKind::Variable { id } => {
                let Some(toml) = syntax.toml.get(&document.id) else {
                    continue;
                };
                index
                    .variables
                    .insert(id.clone(), variable::project_variable(document, toml, id));
            }
            DocumentKind::List { id } => {
                let Some(toml) = syntax.toml.get(&document.id) else {
                    continue;
                };
                index
                    .lists
                    .insert(id.clone(), lists::project_list(document, toml, id));
            }
            DocumentKind::Governance => {
                let Some(toml) = syntax.toml.get(&document.id) else {
                    continue;
                };
                index.governance = Some(governance::project_governance(document, toml));
            }
            DocumentKind::Layer { id } => {
                let Some(toml) = syntax.toml.get(&document.id) else {
                    continue;
                };
                index
                    .layers
                    .insert(id.clone(), layers::project_layer(document, toml, id));
            }
            DocumentKind::Catalog { id } => {
                index
                    .catalogs
                    .insert(id.clone(), catalog::project_catalog(document, syntax, id));
            }
            DocumentKind::CatalogEntry {
                catalog_id,
                entry_id,
            } => {
                let Some(toml) = syntax.toml.get(&document.id) else {
                    continue;
                };
                index
                    .catalog_entries
                    .entry(catalog_id.clone())
                    .or_default()
                    .insert(
                        entry_id.clone(),
                        catalog::project_catalog_entry(document, toml, catalog_id, entry_id),
                    );
            }
            DocumentKind::EvaluationContext { id } => {
                index.evaluation_contexts.insert(
                    id.clone(),
                    evaluation_context::project_evaluation_context(document, syntax, id),
                );
            }
            DocumentKind::EvaluationContextSample {
                evaluation_context_id,
                sample_id,
            } => {
                index
                    .evaluation_context_samples
                    .entry(evaluation_context_id.clone())
                    .or_default()
                    .insert(
                        sample_id.clone(),
                        evaluation_context::project_evaluation_context_sample(
                            document,
                            syntax,
                            evaluation_context_id,
                            sample_id,
                        ),
                    );
            }
            DocumentKind::CustomLint => {
                index.custom_lints.files.insert(
                    document.path.clone(),
                    CustomLintFileNode {
                        path: document.path.clone(),
                        doc: document.id,
                        location: document.document_location(),
                    },
                );
            }
        }
    }
    catalog::compile_catalog_validators(&mut index);
    index
}