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
117
118
119
120
121
122

use crate::diagnostics::{RototoRuleId, SemanticTarget};

use super::super::engine::LintContext;
use super::super::index::ProjectField;
use super::super::stages::push_project_diagnostic;

/// rototo-recognized ids appear in TOML table headers and CEL expressions
/// (`variables.premium_users`), where a hyphen parses as subtraction. Every id
/// is lowercase snake_case, with `/` separating namespace segments.
pub(super) fn lint_id_naming(ctx: &mut LintContext) {
    let mut diagnostics = Vec::new();

    let mut check = |id: &str,
                     target: SemanticTarget,
                     location: crate::diagnostics::DiagnosticLocation,
                     kind: &str| {
        if !id_is_snake_case(id) {
            // Deleted and update markers compose through extends and are
            // consumed when layers flatten; one surviving into lint has no
            // base package.
            let is_marker_id = (kind == "catalog entry"
                && (id.ends_with(".deleted") || id.ends_with(".update")))
                || (kind == "variable" && id.ends_with(".update"));
            let message = if is_marker_id {
                format!(
                    "{kind} deleted and update markers apply to a base package through extends; \
                     this package has no base entry for them to compose with: {id}"
                )
            } else {
                format!("{kind} id must be snake_case: {id}")
            };
            push_project_diagnostic(
                &mut diagnostics,
                RototoRuleId::IdNotSnakeCase,
                target,
                location,
                message,
            );
        }
    };

    for variable in ctx.index.variables.values() {
        check(
            &variable.id,
            variable.target(),
            variable.location.clone(),
            "variable",
        );
    }
    for declaration in ctx.index.lists.values() {
        check(
            &declaration.id,
            declaration.target(),
            declaration.location.clone(),
            "list",
        );
    }
    for layer in ctx.index.layers.values() {
        check(&layer.id, layer.target(), layer.location.clone(), "layer");
        for allocation in &layer.allocations {
            if let ProjectField::Present(id) = &allocation.id {
                check(&id.value, layer.target(), id.location.clone(), "allocation");
            }
            for arm in &allocation.arms {
                if let ProjectField::Present(name) = &arm.name {
                    check(&name.value, layer.target(), name.location.clone(), "arm");
                }
            }
        }
    }
    for catalog in ctx.index.catalogs.values() {
        check(
            &catalog.id,
            catalog.target(),
            catalog.location.clone(),
            "catalog",
        );
    }
    for entries in ctx.index.catalog_entries.values() {
        for entry in entries.values() {
            check(
                &entry.key,
                entry.target(),
                entry.location.clone(),
                "catalog entry",
            );
        }
    }
    for evaluation_context in ctx.index.evaluation_contexts.values() {
        check(
            &evaluation_context.id,
            evaluation_context.target(),
            evaluation_context.location.clone(),
            "evaluation context",
        );
    }
    for samples in ctx.index.evaluation_context_samples.values() {
        for sample in samples.values() {
            check(
                &sample.key,
                sample.target(),
                sample.location.clone(),
                "evaluation context sample",
            );
        }
    }

    ctx.diagnostics.extend(diagnostics);
}

fn id_is_snake_case(id: &str) -> bool {
    !id.is_empty()
        && id.split('/').all(|segment| {
            !segment.is_empty()
                && segment.split('_').all(|part| {
                    !part.is_empty()
                        && part
                            .chars()
                            .all(|ch| ch.is_ascii_lowercase() || ch.is_ascii_digit())
                })
        })
}