recourse-cli 0.0.1-rc.1

Cargo CLI for governing Recourse diagnostic catalogs
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

//! Explicit filesystem and artifact failures from command execution.

use std::{
    error::Error,
    fmt::{self, Display, Formatter},
    io,
    path::PathBuf,
};

use recourse::catalog::{ArtifactParseError, LockParseError, LockWriteError};

#[derive(Debug)]
pub(crate) enum CommandError {
    Read {
        path: PathBuf,
        source: io::Error,
    },
    ParseArtifact {
        path: PathBuf,
        source: ArtifactParseError,
    },
    ParseLock {
        path: PathBuf,
        source: LockParseError,
    },
    EncodeLock(LockWriteError),
    Write {
        path: PathBuf,
        source: io::Error,
    },
    InvalidManifest {
        path: PathBuf,
        entry: String,
    },
    Json(serde_json::Error),
}

impl Display for CommandError {
    fn fmt(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
        match self {
            Self::Read { path, source } => {
                write!(formatter, "read `{}`: {source}", path.display())
            }
            Self::ParseArtifact { path, source } => {
                write!(formatter, "parse catalog `{}`: {source}", path.display())
            }
            Self::ParseLock { path, source } => {
                write!(formatter, "parse lock `{}`: {source}", path.display())
            }
            Self::EncodeLock(source) => write!(formatter, "encode catalog lock: {source}"),
            Self::Write { path, source } => {
                write!(formatter, "write `{}`: {source}", path.display())
            }
            Self::InvalidManifest { path, entry } => write!(
                formatter,
                "generated-doc manifest `{}` contains unsafe path `{entry}`",
                path.display()
            ),
            Self::Json(source) => write!(formatter, "encode JSON output: {source}"),
        }
    }
}

impl Error for CommandError {
    fn source(&self) -> Option<&(dyn Error + 'static)> {
        match self {
            Self::Read { source, .. } | Self::Write { source, .. } => Some(source),
            Self::ParseArtifact { source, .. } => Some(source),
            Self::ParseLock { source, .. } => Some(source),
            Self::EncodeLock(source) => Some(source),
            Self::Json(source) => Some(source),
            Self::InvalidManifest { .. } => None,
        }
    }
}

impl CommandError {
    pub(crate) fn stdout(source: io::Error) -> Self {
        Self::Write {
            path: "<stdout>".into(),
            source,
        }
    }
}

impl From<serde_json::Error> for CommandError {
    fn from(source: serde_json::Error) -> Self {
        Self::Json(source)
    }
}