cargo-grip4rust 0.1.4

A cargo subcommand for measuring Rust testability
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

// Copyright 2026 Umberto Gotti <umberto.gotti@umbertogotti.dev>
// Licensed under the MIT License
// SPDX-License-Identifier: MIT

use std::io::{self, Write};

use anyhow::Result;

use crate::grip_report::GripReport;
use crate::module_stats::ModuleStats;
use crate::traits::reporter::Reporter;

#[derive(Debug, Clone)]
pub struct StdoutReporter {
    json: bool,
}

impl StdoutReporter {
    #[must_use]
    pub fn new(json: bool) -> Self {
        Self { json }
    }
}

impl Reporter for StdoutReporter {
    fn render(&self, report: &GripReport) -> Result<String> {
        if self.json {
            Ok(serde_json::to_string_pretty(report)?)
        } else {
            Ok(self.render_human(report))
        }
    }

    fn write(&self, report: &GripReport) -> Result<()> {
        let out = self.render(report)?;
        io::stdout().write_all(out.as_bytes())?;
        io::stdout().write_all(b"\n")?;
        Ok(())
    }
}

impl StdoutReporter {
    fn render_human(&self, report: &GripReport) -> String {
        let mut lines = Vec::new();
        let target = &report.target;
        lines.push(format!(
            "cargo-grip4rust {} -- {}\n══════════════════════════════════════════════════════\n",
            report.version, target,
        ));

        let overall = &report.overall;
        lines.push(format!(
            "Overall grip score:    {} / 100",
            overall.grip_score
        ));
        lines.push(format!(
            "Public surface:        {} items",
            overall.public_items
        ));
        lines.push(format!(
            "Total functions:       {}",
            overall.total_functions
        ));
        lines.push(format!(
            "Probably pure:         {} / {}  ({:.1}%)",
            overall.pure_functions,
            overall.total_functions,
            overall.pure_ratio * 100.0
        ));

        lines.push("\nPer module:".to_string());
        for module in &report.modules {
            lines.push(self.render_module_line(module));
        }

        if !report.offenders.is_empty() {
            lines.push(format!(
                "\nOffenders (score < {}):",
                report.offender_threshold
            ));
            for offender in &report.offenders {
                lines.push(format!(
                    "  {:<30}  grip: {:>3}  ❌",
                    offender.path, offender.grip_score,
                ));
            }
        }

        lines.join("\n")
    }

    fn render_module_line(&self, module: &ModuleStats) -> String {
        let marker = self.module_marker(module.grip_score);
        format!(
            "  {:<30}  grip: {:>3}   pure: {:>5.1}%   pub: {:>3}  {}",
            module.path,
            module.grip_score,
            module.pure_ratio * 100.0,
            module.public_items,
            marker,
        )
    }

    fn module_marker(&self, score: u32) -> &'static str {
        if score < 40 {
            "❌"
        } else if score < 70 {
            "⚠️"
        } else {
            ""
        }
    }
}