rototo 0.1.0-alpha.3

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

use serde_json::Value as JsonValue;

use crate::diagnostics::{DocId, LintStage};

use super::super::engine::{LintContext, variable_values};
use super::super::index::*;
use super::super::project::json_from_toml_value;
use super::{RegisteredLintEntity, RegisteredLintField, SchemaLintField, ValueLintField};

pub(super) fn expanded_variable_toml_json(ctx: &LintContext, variable: &VariableNode) -> JsonValue {
    let mut toml = ctx
        .syntax
        .toml
        .get(&variable.doc)
        .map(|parsed| json_from_toml_value(parsed.root()))
        .unwrap_or_else(|| JsonValue::Object(serde_json::Map::new()));
    let mut values = serde_json::Map::new();
    for value in variable_values(ctx, variable) {
        values.insert(value.key.clone(), value.value.clone());
    }

    if let JsonValue::Object(object) = &mut toml {
        object.insert("values".to_owned(), JsonValue::Object(values));
    }
    toml
}

pub(super) fn parsed_toml_json(ctx: &LintContext, doc: DocId) -> JsonValue {
    ctx.syntax
        .toml
        .get(&doc)
        .map(|parsed| json_from_toml_value(parsed.root()))
        .unwrap_or(JsonValue::Null)
}

pub(super) fn selected_value_field(
    value: &JsonValue,
    field: Option<&RegisteredLintField>,
) -> JsonValue {
    match field {
        Some(RegisteredLintField::Value(ValueLintField::JsonPath(path))) => {
            json_value_at_path(value, path)
                .cloned()
                .unwrap_or(JsonValue::Null)
        }
        _ => value.clone(),
    }
}

pub(super) fn selected_schema_field(
    schema: &JsonValue,
    field: Option<&RegisteredLintField>,
) -> JsonValue {
    match field {
        Some(RegisteredLintField::Schema(SchemaLintField::JsonPath(path))) => {
            json_value_at_path(schema, path)
                .cloned()
                .unwrap_or(JsonValue::Null)
        }
        _ => schema.clone(),
    }
}

fn json_value_at_path<'a>(value: &'a JsonValue, path: &[String]) -> Option<&'a JsonValue> {
    let mut current = value;
    for segment in path {
        current = current.get(segment)?;
    }
    Some(current)
}

pub(super) fn lint_stage_label(stage: LintStage) -> &'static str {
    match stage {
        LintStage::Discover => "discover",
        LintStage::Parse => "parse",
        LintStage::Project => "project",
        LintStage::Register => "register",
        LintStage::Reference => "reference",
        LintStage::Value => "value",
        LintStage::Graph => "graph",
        LintStage::Policy => "policy",
    }
}

pub(super) fn registered_lint_entity_label(entity: RegisteredLintEntity) -> &'static str {
    match entity {
        RegisteredLintEntity::Workspace => "workspace",
        RegisteredLintEntity::Qualifier => "qualifier",
        RegisteredLintEntity::Variable => "variable",
        RegisteredLintEntity::Value => "value",
        RegisteredLintEntity::Schema => "schema",
    }
}