diagprint 0.8.1

A Rust diagnostics lifecycle framework for structured diagnostics, rendering, remediation, CI, editors, and telemetry.
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

use diagprint::{
    Applicability, DiagnosticErrorExt, DiagnosticMetadata, Reporter, Severity, Suggestion,
};
use std::{io, path::PathBuf};
use thiserror::Error;

#[derive(Debug, Error)]
enum ConfigError {
    #[error("failed to read configuration `{path}`")]
    Read {
        path: PathBuf,

        #[source]
        source: io::Error,
    },

    #[error("unsupported configuration profile `{profile}`")]
    UnsupportedProfile { profile: String },
}

impl DiagnosticMetadata for ConfigError {
    fn diagnostic_severity(&self) -> Severity {
        match self {
            Self::Read { .. } => Severity::Error,
            Self::UnsupportedProfile { .. } => Severity::Warning,
        }
    }

    fn diagnostic_code(&self) -> Option<String> {
        Some(
            match self {
                Self::Read { .. } => "CONFIG-READ",
                Self::UnsupportedProfile { .. } => "CONFIG-PROFILE",
            }
            .into(),
        )
    }

    fn diagnostic_help(&self) -> Option<String> {
        Some(match self {
            Self::Read { path, .. } => {
                format!("Verify that `{}` exists and is readable.", path.display())
            }

            Self::UnsupportedProfile { .. } => {
                "Use one of the application's supported profile names.".into()
            }
        })
    }

    fn diagnostic_notes(&self) -> Vec<String> {
        match self {
            Self::Read { .. } => vec!["Typed error metadata was supplied by ConfigError.".into()],

            Self::UnsupportedProfile { .. } => {
                vec![
                    "This diagnostic was enriched without parsing the error's \
                 formatted display text."
                        .into(),
                ]
            }
        }
    }

    fn diagnostic_suggestions(&self) -> Vec<Suggestion> {
        match self {
            Self::UnsupportedProfile { .. } => {
                vec![
                    Suggestion::new("Select a supported configuration profile")
                        .explanation(
                            "The requested profile is not recognized by the \
                         application.",
                        )
                        .applicability(Applicability::Manual),
                ]
            }

            Self::Read { .. } => Vec::new(),
        }
    }
}

fn main() -> diagprint::Result<()> {
    let reporter = Reporter::builder()
        .application("diagprint-thiserror")
        .width(88)
        .build()?;

    let read_error = ConfigError::Read {
        path: "/etc/cyberdeck/config.toml".into(),
        source: io::Error::new(io::ErrorKind::NotFound, "configuration file does not exist"),
    };

    let profile_error = ConfigError::UnsupportedProfile {
        profile: "quantum-overdrive".into(),
    };

    for error in [&read_error, &profile_error] {
        let diagnostic = error.to_diagprint(&reporter);
        reporter.emit(&diagnostic)?;
    }

    Ok(())
}