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