ferrflow 7.4.1

Universal semantic versioning for monorepos and classic repos
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
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137

use anyhow::Result;
use colored::Colorize;
use serde::Serialize;

#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize)]
#[serde(rename_all = "lowercase")]
pub enum Status {
    Ok,
    Info,
    Warn,
    Error,
}

impl Status {
    fn glyph(self) -> colored::ColoredString {
        match self {
            Status::Ok => "✓".green(),
            Status::Info => "·".dimmed(),
            Status::Warn => "⚠".yellow(),
            Status::Error => "✗".red(),
        }
    }
}

#[derive(Debug, Serialize)]
pub struct Check {
    pub name: String,
    pub status: Status,
    pub detail: Option<String>,
}

impl Check {
    pub fn new(name: impl Into<String>, status: Status, detail: Option<String>) -> Self {
        Self {
            name: name.into(),
            status,
            detail,
        }
    }

    pub fn ok(name: impl Into<String>, detail: Option<String>) -> Self {
        Self::new(name, Status::Ok, detail)
    }

    pub fn info(name: impl Into<String>, detail: Option<String>) -> Self {
        Self::new(name, Status::Info, detail)
    }

    pub fn warn(name: impl Into<String>, detail: Option<String>) -> Self {
        Self::new(name, Status::Warn, detail)
    }

    pub fn error(name: impl Into<String>, detail: Option<String>) -> Self {
        Self::new(name, Status::Error, detail)
    }
}

#[derive(Debug, Serialize)]
pub struct Section {
    pub title: String,
    pub checks: Vec<Check>,
}

impl Section {
    pub fn new(title: impl Into<String>, checks: Vec<Check>) -> Self {
        Self {
            title: title.into(),
            checks,
        }
    }
}

#[derive(Debug, Serialize)]
pub struct Report {
    pub status: Status,
    pub exit_code: i32,
    pub sections: Vec<Section>,
}

impl Report {
    pub fn build(sections: Vec<Section>) -> Self {
        let mut errors = 0usize;
        let mut warnings = 0usize;
        for section in &sections {
            for check in &section.checks {
                match check.status {
                    Status::Error => errors += 1,
                    Status::Warn => warnings += 1,
                    Status::Ok | Status::Info => {}
                }
            }
        }
        let (status, exit_code) = if errors > 0 {
            (Status::Error, 2)
        } else if warnings > 0 {
            (Status::Warn, 1)
        } else {
            (Status::Ok, 0)
        };
        Self {
            status,
            exit_code,
            sections,
        }
    }

    pub fn to_json(&self) -> Result<String> {
        Ok(serde_json::to_string_pretty(self)?)
    }

    pub fn print_human(&self) {
        tracing::info!("");
        tracing::info!("{}", "ferrflow doctor".bold());

        for section in &self.sections {
            tracing::info!("");
            tracing::info!("{}", section.title.bold());
            for check in &section.checks {
                match &check.detail {
                    Some(detail) => {
                        tracing::info!("  {} {}: {}", check.status.glyph(), check.name, detail)
                    }
                    None => tracing::info!("  {} {}", check.status.glyph(), check.name),
                }
            }
        }

        tracing::info!("");
        let summary = match self.status {
            Status::Error => "problems found — see the errors above".red().bold(),
            Status::Warn => "ready, with warnings".yellow().bold(),
            Status::Ok | Status::Info => "all checks passed".green().bold(),
        };
        tracing::info!("  {summary}");
        tracing::info!("");
    }
}