heddle-cli-render 0.15.7

Heddle's terminal presentation layer.
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
115
116
117
118
119

// SPDX-License-Identifier: Apache-2.0
use anyhow::Result;
use verbs::FsckReport;

use crate::cli::{render::write_stdout, style};

pub fn fsck_json(report: &FsckReport) -> Result<()> {
    let mut text = serde_json::to_string(report)?;
    text.push('\n');
    write_stdout(&text)
}

pub fn fsck_text(report: &FsckReport) -> Result<()> {
    write_stdout(&format_fsck_text(report))
}

fn format_fsck_text(report: &FsckReport) -> String {
    let mut text = String::new();
    if report.valid {
        let counted = style::count(report.objects_checked, "object");
        text.push_str(&format!(
            "{} repository is valid ({counted} checked)\n",
            style::ok_marker(),
        ));
        if report.git_projection_checked {
            text.push_str(&format!(
                "  {}\n",
                style::field("Git projection", "mapping, notes, and checkout checked")
            ));
        }
    } else {
        text.push_str(&format!(
            "{} repository has {}\n",
            style::error_marker(),
            style::count(report.errors.len(), "integrity error")
        ));
        for error in &report.errors {
            if let Some(obj) = &error.object {
                text.push_str(&format!(
                    "  {} {} {}\n",
                    style::error(&format!("[{}]", error.kind)),
                    error.message,
                    style::dim(&format!("({obj})"))
                ));
            } else {
                text.push_str(&format!(
                    "  {} {}\n",
                    style::error(&format!("[{}]", error.kind)),
                    error.message
                ));
            }
        }
    }
    if let Some(target) = &report.repair_target {
        let status = if report.repaired {
            "repaired"
        } else {
            "no changes"
        };
        text.push_str(&format!(
            "  {}\n",
            style::field("Repair", &format!("{target}: {status}"))
        ));
        for repair in &report.repairs {
            if repair.count > 0 || repair.repaired {
                text.push_str(&format!(
                    "    {} {} ({})\n",
                    repair.name, repair.detail, repair.count
                ));
            }
        }
    }
    if let Some(provenance) = &report.provenance {
        text.push_str(&format!(
            "  {}\n",
            style::field("Provenance registry", &provenance.registry_status)
        ));
        for state in &provenance.states {
            let short = state
                .state_id
                .strip_prefix("hs-")
                .unwrap_or(&state.state_id);
            let short = &short[..short.len().min(12)];
            text.push_str(&format!(
                "    {short} {:<24} {}\n",
                state.display_status(),
                state.detail
            ));
        }
    }
    for warning in &report.warnings {
        text.push_str(&format!("{} {}\n", style::warn_marker(), warning));
    }
    text
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn text_renderer_consumes_the_typed_fsck_report() {
        let report = FsckReport {
            valid: true,
            errors: Vec::new(),
            warnings: vec!["legacy object retained".to_string()],
            objects_checked: 2,
            git_projection_checked: false,
            provenance: None,
            repair_target: None,
            repaired: false,
            repairs: Vec::new(),
        };

        let text = format_fsck_text(&report);
        assert!(text.contains("repository is valid (2 objects checked)"));
        assert!(text.contains("legacy object retained"));
    }
}