clerr 0.11.0

This library aids in command-line error reporting.
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

use crate::Severity;
use crate::Severity::{Error, Info, Warning};
use colored::{Color, Colorize};
use std::fmt::{Display, Formatter};

/// A command-line report code with a severity, identifier, and message.
///
/// # Display
///
/// ```text
/// severity[id]: message
/// ```
#[must_use]
#[derive(Clone, Ord, PartialOrd, Eq, PartialEq, Hash, Debug)]
pub struct Code {
    severity: Severity,
    id: String,
    message: String,
}

impl Code {
    //! Construction

    /// Creates a new command-line report code.
    pub fn new<S0, S1>(severity: Severity, id: S0, message: S1) -> Self
    where
        S0: Into<String>,
        S1: Into<String>,
    {
        Self {
            severity,
            id: id.into(),
            message: message.into(),
        }
    }

    /// Creates a new error code.
    pub fn error<S0, S1>(id: S0, message: S1) -> Self
    where
        S0: Into<String>,
        S1: Into<String>,
    {
        Self::new(Error, id, message)
    }

    /// Creates a new warning code.
    pub fn warning<S0, S1>(id: S0, message: S1) -> Self
    where
        S0: Into<String>,
        S1: Into<String>,
    {
        Self::new(Warning, id, message)
    }

    /// Creates a new info code.
    pub fn info<S0, S1>(id: S0, message: S1) -> Self
    where
        S0: Into<String>,
        S1: Into<String>,
    {
        Self::new(Info, id, message)
    }
}

impl Code {
    //! Properties

    /// Gets the severity.
    pub fn severity(&self) -> Severity {
        self.severity
    }

    /// Gets the identifier.
    #[must_use]
    pub fn id(&self) -> &str {
        self.id.as_str()
    }

    /// Gets the message.
    #[must_use]
    pub fn message(&self) -> &str {
        self.message.as_str()
    }
}

impl Display for Code {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        let color: Color = self.severity.color();
        write!(
            f,
            "{}{}{}{}{}",
            self.severity,
            "[".color(color),
            self.id.color(color),
            "]: ".color(color),
            self.message.bright_white().bold()
        )
    }
}

#[cfg(test)]
mod tests {
    use crate::Code;
    use colored::Colorize;

    #[test]
    fn display() {
        let code: Code = Code::error("E123", "the error message");
        let result: String = code.to_string();
        let expected: String = [
            "error".bright_red(),
            "[".bright_red(),
            "E123".bright_red(),
            "]: ".bright_red(),
            "the error message".bright_white().bold(),
        ]
        .iter()
        .map(|s| s.to_string())
        .collect();
        assert_eq!(result, expected);
    }
}