sofie-check 0.2.0

Structure checks (comment density, god types) and the `sofie check` rules over the app model.
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

use std::path::Path;

use sofie_engine::ActionPost;
use sofie_model::{App, InputDeclaration};

use super::{Finding, Rule};
use crate::screens::{Screen, Screens};

/// An `<Action>` posts only its `with` fields, so they must be what the posted route's input reads.
pub(super) fn check_actions(app: &App, screens: &Screens) -> Vec<Finding> {
    let files = app
        .modules
        .iter()
        .flat_map(|module| &module.areas)
        .flat_map(|area| {
            let overrides = area.overrides.iter().map(|replacement| &replacement.file);
            area.screens.iter().chain(overrides)
        });
    let mut findings = Vec::new();
    for file in files {
        let Ok(Screen {
            actions: Ok(actions),
            ..
        }) = screens.screen(file)
        else {
            continue;
        };
        for action in actions {
            if let Some(input) = posted_input(app, &action.post) {
                findings.extend(check_action(file, action, input));
            }
        }
    }
    findings
}

fn posted_input<'app>(app: &'app App, post: &str) -> Option<&'app InputDeclaration> {
    let site = app.posted_route(post)?;
    let code = &site.module.code;
    code.input_of(code.function(&site.route.handler)?)
}

fn check_action(file: &Path, action: &ActionPost, input: &InputDeclaration) -> Vec<Finding> {
    let declares = |name: &str| input.fields.iter().any(|field| field.name == name);
    let unknown = action
        .fields
        .iter()
        .filter(|name| !declares(name))
        .map(|name| unknown_field(file, action, input, name));
    let missing = input
        .fields
        .iter()
        .filter(|field| field.ty.name != "Option" && !action.fields.contains(&field.name))
        .map(|field| missing_field(file, action, input, &field.name));
    unknown.chain(missing).collect()
}

fn unknown_field(
    file: &Path,
    action: &ActionPost,
    input: &InputDeclaration,
    name: &str,
) -> Finding {
    let fields: Vec<&str> = input
        .fields
        .iter()
        .map(|field| field.name.as_str())
        .collect();
    Finding {
        rule: Rule::ActionInput,
        file: file.to_path_buf(),
        line: action.line,
        message: format!(
            "the `Action` posting to `{}` sends `{name}`, but its input `{}` has no field \
             `{name}`, so the route would refuse every click",
            action.post, input.name
        ),
        fix: format!(
            "post only fields `{}` declares: {}",
            input.name,
            fields.join(", ")
        ),
    }
}

fn missing_field(
    file: &Path,
    action: &ActionPost,
    input: &InputDeclaration,
    name: &str,
) -> Finding {
    Finding {
        rule: Rule::ActionInput,
        file: file.to_path_buf(),
        line: action.line,
        message: format!(
            "the `Action` posting to `{}` does not send `{name}`, which its input `{}` \
             requires, so the route would refuse every click",
            action.post, input.name
        ),
        fix: format!(
            "add `{name}` to the action's `with={{{{…}}}}`, or make the field an `Option`"
        ),
    }
}