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

mod diagnostics;
mod discover;
mod graph;
mod parse;
mod policy;
mod project;
mod reference;
mod register;
mod value;

use crate::diagnostics::LintStage;
use crate::error::Result;

use super::custom::run_registered_custom_lints;
use super::engine::LintContext;

pub(super) use diagnostics::push_stage_diagnostic;
pub(super) use graph::push_graph_diagnostic;
pub(super) use project::push_project_diagnostic;
pub(super) use reference::push_reference_diagnostic;
pub(super) use register::push_register_diagnostic;
pub(super) use value::push_value_diagnostic;

const CHECKED_STAGES: [LintStage; 5] = [
    LintStage::Project,
    LintStage::Reference,
    LintStage::Value,
    LintStage::Graph,
    LintStage::Policy,
];

pub(super) async fn run_pipeline(ctx: &mut LintContext) -> Result<()> {
    run_until(ctx, LintStage::Policy).await
}

pub(super) async fn run_until(ctx: &mut LintContext, stop_after: LintStage) -> Result<()> {
    discover::run(ctx).await?;
    if stop_after == LintStage::Discover {
        return Ok(());
    }

    parse::run(ctx);
    if stop_after == LintStage::Parse {
        return Ok(());
    }

    project::build_projection(ctx);
    register::run(ctx).await;
    if stop_after == LintStage::Register {
        return Ok(());
    }

    for stage in CHECKED_STAGES {
        run_builtin_stage(ctx, stage);
        run_custom_stage(ctx, stage).await;
        if stop_after == stage {
            return Ok(());
        }
    }

    Ok(())
}

fn run_builtin_stage(ctx: &mut LintContext, stage: LintStage) {
    match stage {
        LintStage::Project => project::run_builtin(ctx),
        LintStage::Reference => reference::run_builtin(ctx),
        LintStage::Value => value::run_builtin(ctx),
        LintStage::Graph => graph::run_builtin(ctx),
        LintStage::Policy => policy::run_builtin(ctx),
        LintStage::Discover | LintStage::Parse | LintStage::Register => {}
    }
}

async fn run_custom_stage(ctx: &mut LintContext, stage: LintStage) {
    match stage {
        LintStage::Project
        | LintStage::Reference
        | LintStage::Value
        | LintStage::Graph
        | LintStage::Policy => run_registered_custom_lints(ctx, stage).await,
        LintStage::Discover | LintStage::Parse | LintStage::Register => {}
    }
}