zerum 0.1.0

Deterministic-first Python code governance: native checks (ZR001–ZR010), CLI, and SARIF/JSON reporters
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

use crate::core::ast_util::collect_function_metrics;
use crate::core::{Category, Check, CheckContext, Issue, Severity};

const DEFAULT_MAX_DEPTH: usize = 3;

pub struct NestedConditionals;

impl Check for NestedConditionals {
    fn id(&self) -> &'static str {
        "ZR004"
    }

    fn name(&self) -> &'static str {
        "nested-conditionals"
    }

    fn category(&self) -> Category {
        Category::Design
    }

    fn severity(&self) -> Severity {
        Severity::Medium
    }

    fn explanation(&self) -> &'static str {
        "Deeply nested conditionals increase cognitive load and hide the happy path."
    }

    fn remediation(&self) -> &'static str {
        "Flatten with guard clauses, extract nested blocks into named functions, or restructure control flow."
    }

    fn run(&self, ctx: &CheckContext) -> Vec<Issue> {
        if !ctx.config.is_check_enabled(self.id()) {
            return Vec::new();
        }
        let max = ctx
            .config
            .check_config(self.id())
            .max_depth
            .unwrap_or(DEFAULT_MAX_DEPTH);

        collect_function_metrics(ctx.parsed)
            .into_iter()
            .filter(|m| m.max_conditional_depth > max)
            .map(|m| {
                Issue::from_check(
                    self,
                    format!(
                        "function `{}` has conditional nesting depth {} (max {})",
                        m.name, m.max_conditional_depth, max
                    ),
                    ctx.file_path(),
                    m.line,
                    m.column,
                )
            })
            .collect()
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::config::Config;
    use crate::parser::{PythonParser, RustPythonParser};
    use std::path::Path;

    #[test]
    fn flags_deep_nesting() {
        let source = r#"
def deep():
    if a:
        if b:
            if c:
                if d:
                    pass
"#;
        let path = Path::new("t.py");
        let parsed = RustPythonParser.parse_file(source, path).unwrap();
        let config = Config::default();
        let ctx = CheckContext {
            path,
            source,
            parsed: &parsed,
            config: &config,
        };
        let issues = NestedConditionals.run(&ctx);
        assert_eq!(issues.len(), 1);
        assert_eq!(issues[0].id, "ZR004");
    }

    #[test]
    fn async_function_depth_counted() {
        let source = r#"
async def deep():
    if a:
        if b:
            if c:
                if d:
                    pass
"#;
        let path = Path::new("t.py");
        let parsed = RustPythonParser.parse_file(source, path).unwrap();
        let config = Config::default();
        let ctx = CheckContext {
            path,
            source,
            parsed: &parsed,
            config: &config,
        };
        assert_eq!(NestedConditionals.run(&ctx).len(), 1);
    }
}