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

use crate::code::Code;
use crate::report::entry::Entry;
use colored::ColoredString;
use std::fmt::{Display, Formatter};

/// A command-line report.
///
/// # Display
///
/// ```text
/// severity[id]: message
/// entries
/// ```
#[must_use]
#[derive(Clone, Ord, PartialOrd, Eq, PartialEq, Hash, Debug)]
pub struct Report {
    code: Code,
    entries: Vec<Entry>,
}

impl From<Code> for Report {
    fn from(code: Code) -> Self {
        Self {
            code,
            entries: Vec::new(),
        }
    }
}

impl Report {
    //! Properties

    /// Gets the code.
    pub fn code(&self) -> &Code {
        &self.code
    }

    /// Gets the entries.
    #[must_use]
    pub fn entries(&self) -> impl ExactSizeIterator<Item = &[ColoredString]> {
        self.entries.iter().map(|entry| entry.strings.as_slice())
    }
}

impl Report {
    //! Entries

    /// Adds the `entry`.
    pub fn add_entry<E>(&mut self, entry: E)
    where
        E: Into<Vec<ColoredString>>,
    {
        self.entries.push(Entry::from(entry.into()));
    }

    /// Adds the `entry`.
    pub fn with_entry<E>(mut self, entry: E) -> Self
    where
        E: Into<Vec<ColoredString>>,
    {
        self.add_entry(entry);
        self
    }
}

impl Display for Report {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.code)?;
        for entry in &self.entries {
            writeln!(f)?;
            write!(f, "{}", entry)?;
        }
        Ok(())
    }
}

impl std::error::Error for Report {}

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

    #[test]
    fn display() {
        let code: Code = Code::error("E123", "the error message");
        let report: Report = Report::from(code).with_entry(vec!["entry".normal()]);

        let result: String = report.to_string();
        let expected: String = [
            "error".bright_red(),
            "[".bright_red(),
            "E123".bright_red(),
            "]: ".bright_red(),
            "the error message".bright_white().bold(),
            "\n".normal(),
            "entry".normal(),
        ]
        .iter()
        .map(|s| s.to_string())
        .collect();

        assert_eq!(result, expected);
    }
}