Skip to main content

pray_core/
error.rs

1use std::fmt::{self, Display, Formatter};
2use std::io;
3
4pub type PrayResult<T> = Result<T, PrayError>;
5
6#[derive(Debug)]
7pub enum PrayError {
8    Parse { kind: &'static str, message: String },
9    Manifest(String),
10    Resolution(String),
11    Integrity(String),
12    Render(String),
13    Verify(String),
14    Network(String),
15    Usage(String),
16    Unsupported(String),
17    Io(io::Error),
18}
19
20impl PrayError {
21    pub fn exit_code(&self) -> i32 {
22        match self {
23            Self::Parse { .. } => 2,
24            Self::Manifest(_) => 1,
25            Self::Resolution(_) => 3,
26            Self::Integrity(_) => 4,
27            Self::Render(_) => 5,
28            Self::Verify(_) => 6,
29            Self::Network(_) => 7,
30            Self::Usage(_) => 2,
31            Self::Unsupported(_) => 8,
32            Self::Io(_) => 1,
33        }
34    }
35}
36
37impl Display for PrayError {
38    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
39        match self {
40            Self::Parse { kind, message } => write!(f, "{} parse error: {}", kind, message),
41            Self::Manifest(message) => write!(f, "manifest error: {}", message),
42            Self::Resolution(message) => write!(f, "resolution error: {}", message),
43            Self::Integrity(message) => write!(f, "integrity error: {}", message),
44            Self::Render(message) => write!(f, "render error: {}", message),
45            Self::Verify(message) => write!(f, "verify error: {}", message),
46            Self::Network(message) => write!(f, "network error: {}", message),
47            Self::Usage(message) => write!(f, "usage error: {}", message),
48            Self::Unsupported(message) => write!(f, "unsupported feature: {}", message),
49            Self::Io(error) => write!(f, "I/O error: {error}"),
50        }
51    }
52}
53
54impl std::error::Error for PrayError {}
55
56impl From<io::Error> for PrayError {
57    fn from(error: io::Error) -> Self {
58        Self::Io(error)
59    }
60}
61
62#[cfg(feature = "auth")]
63impl From<rusqlite::Error> for PrayError {
64    fn from(error: rusqlite::Error) -> Self {
65        Self::Resolution(error.to_string())
66    }
67}