orion-server 1.5.1

Turn business logic into live REST/Kafka services, declared as JSON
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

//! The rules, one file per group. `ALL` is the registry, in the order rules
//! run and are listed; a rule not in it does not exist.

pub mod correctness;
pub mod duplication;
pub mod perf;
pub mod style;

use super::Rule;

pub static ALL: &[&dyn Rule] = &[
    &correctness::WorkflowNeverMatches,
    &correctness::TaskNeverRuns,
    &correctness::UnreachableStep,
    &correctness::UnconditionalCallCycle,
    &correctness::PayloadVar,
    &correctness::MappingOverwritten,
    &correctness::MetadataVarUndeclared,
    &correctness::SecretUndeclared,
    &perf::ParseResultOverwritten,
    &perf::RedundantStepCondition,
    &perf::GroupConditionRepeated,
    &duplication::FragmentAvailable,
    &duplication::RepeatedTaskSequence,
    &duplication::RepeatedValue,
    &style::TerminalOnLastStep,
];

/// Walk a JSON value with the path of every node, in the `a.b[2].c`
/// notation every finding uses.
pub(super) fn walk_values<'a>(
    value: &'a serde_json::Value,
    path: &str,
    f: &mut impl FnMut(&str, &'a serde_json::Value),
) {
    f(path, value);
    match value {
        serde_json::Value::Object(map) => {
            for (k, v) in map {
                let at = if path.is_empty() {
                    k.clone()
                } else {
                    format!("{path}.{k}")
                };
                walk_values(v, &at, f);
            }
        }
        serde_json::Value::Array(items) => {
            for (i, v) in items.iter().enumerate() {
                walk_values(v, &format!("{path}[{i}]"), f);
            }
        }
        _ => {}
    }
}

/// `a`, `b` and `c` → "`a`, `b` and `c`".
pub(super) fn list_ids(ids: &[&str]) -> String {
    match ids {
        [] => String::new(),
        [one] => format!("`{one}`"),
        [head @ .., last] => format!(
            "{} and `{last}`",
            head.iter()
                .map(|i| format!("`{i}`"))
                .collect::<Vec<_>>()
                .join(", ")
        ),
    }
}