easement 0.1.0

Architecture quality gate for polyglot codebases
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

use serde::Serialize;

use crate::baseline::Verdict;
use crate::check::{Key, Stats, Violation};
use crate::diff::Changes;

#[derive(Serialize)]
struct JsonReport<'a> {
    passed: bool,
    violations: &'a [Violation],
    stale: &'a [Key],
    legalized: usize,
    #[serde(skip_serializing_if = "Option::is_none")]
    diff: Option<DiffInfo<'a>>,
    stats: &'a Stats,
}

#[derive(Serialize)]
struct DiffInfo<'a> {
    base: &'a str,
    merge_base: &'a str,
}

pub fn json(verdict: &Verdict, stats: &Stats, changes: Option<&Changes>) -> String {
    let report = JsonReport {
        passed: verdict.passed(),
        violations: &verdict.new,
        stale: &verdict.stale,
        legalized: verdict.legalized,
        diff: changes.map(|c| DiffInfo {
            base: &c.base,
            merge_base: &c.merge_base,
        }),
        stats,
    };
    serde_json::to_string_pretty(&report).expect("report serializes")
}

pub fn text(verdict: &Verdict, stats: &Stats, changes: Option<&Changes>) -> String {
    let mut out = String::new();
    if let Some(c) = changes {
        let short = &c.merge_base[..c.merge_base.len().min(12)];
        out.push_str(&format!(
            "Checking lines changed since {} (merge-base {short})\n\n",
            c.base
        ));
    }
    for v in &verdict.new {
        out.push_str(&format!(
            "{}:{}: {} [{}]\n",
            v.file,
            v.line,
            v.message,
            v.rule.as_str()
        ));
        if let Some(because) = &v.because {
            out.push_str(&format!("  because: {because}\n"));
        }
    }
    if !verdict.stale.is_empty() {
        if !out.is_empty() {
            out.push('\n');
        }
        out.push_str("Stale baseline entries (fixed, run `easement baseline` to shrink it):\n");
        for k in &verdict.stale {
            let what = match k.rule {
                crate::check::RuleId::Cycle => format!("cycle among {}", k.from),
                crate::check::RuleId::Dependency | crate::check::RuleId::Privacy => {
                    format!("{}: {} -> {} ({})", k.file, k.from, k.to, k.target)
                }
                _ => format!("{}: {}", k.file, k.target),
            };
            out.push_str(&format!("  [{}] {what}\n", k.rule.as_str()));
        }
    }
    if !out.is_empty() {
        out.push('\n');
    }
    let status = if verdict.passed() { "passed" } else { "failed" };
    out.push_str(&format!(
        "easement {status}: {} violation(s), {} stale, {} legalized; {} files, {} internal deps",
        verdict.new.len(),
        verdict.stale.len(),
        verdict.legalized,
        stats.files,
        stats.internal_deps,
    ));
    if stats.suppressed > 0 {
        out.push_str(&format!(", {} suppressed", stats.suppressed));
    }
    if stats.unresolved_deps > 0 {
        out.push_str(&format!(", {} unresolved", stats.unresolved_deps));
    }
    if stats.unmapped_files > 0 {
        out.push_str(&format!(
            ", {} files outside components",
            stats.unmapped_files
        ));
    }
    out.push('\n');
    out
}