librelic 0.0.14

Package management library for Arch Linux
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
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198

use crate::error::ComponentError;
use skellige::{fungus::errors::*, prelude::git};
use std::{error::Error as StdError, fmt, io};

/// `Result<T>` provides a simplified result type with a common error type
pub type RelicResult<T> = std::result::Result<T, RelicError>;

// An error indicating that something went wrong with an arch linux operation
#[derive(Debug)]
pub enum RelicError {
    // An error from the component module
    Component(ComponentError),

    // std::io::Error from lower down
    Io(io::Error),

    /// An error indicating that the given package was not found.
    PackageNotFound(String),

    /// An error indicating that the given repo was not found.
    RepoNotFound(String),

    /// An error from the fungus crate
    Fungus(FuError),

    // An error from the serde_yaml crate
    SerdeYaml(serde_yaml::Error),

    /// An error from the skellige crate
    Skellige(git::Error),
}
impl RelicError {
    /// Return an error indicating that the given package was not found.
    pub fn package_not_found<T: AsRef<str>>(pkg: T) -> RelicError {
        RelicError::PackageNotFound(pkg.as_ref().to_string())
    }

    /// Return an error indicating that the given repo was not found.
    pub fn repo_not_found<T: AsRef<str>>(repo: T) -> RelicError {
        RelicError::RepoNotFound(repo.as_ref().to_string())
    }

    /// Implemented directly on the `Error` type to reduce casting required
    pub fn is<T: StdError+'static>(&self) -> bool {
        self.as_ref().is::<T>()
    }

    /// Implemented directly on the `Error` type to reduce casting required
    pub fn downcast_ref<T: StdError+'static>(&self) -> Option<&T> {
        self.as_ref().downcast_ref::<T>()
    }

    /// Implemented directly on the `Error` type to reduce casting required
    pub fn downcast_mut<T: StdError+'static>(&mut self) -> Option<&mut T> {
        self.as_mut().downcast_mut::<T>()
    }

    /// Implemented directly on the `Error` type to reduce casting required
    /// which allows for using as_ref to get the correct pass through.
    pub fn source(&self) -> Option<&(dyn StdError+'static)> {
        self.as_ref().source()
    }
}
impl StdError for RelicError {}

impl fmt::Display for RelicError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            RelicError::Component(ref err) => write!(f, "{}", err),
            RelicError::Io(ref err) => write!(f, "{}", err),
            RelicError::PackageNotFound(ref pkg) => write!(f, "failed to find package: {}", pkg),
            RelicError::RepoNotFound(ref repo) => write!(f, "failed to find repo: {}", repo),
            RelicError::Fungus(ref err) => write!(f, "{}", err),
            RelicError::SerdeYaml(ref err) => write!(f, "{}", err),
            RelicError::Skellige(ref err) => write!(f, "{}", err),
        }
    }
}

impl AsRef<dyn StdError> for RelicError {
    fn as_ref(&self) -> &(dyn StdError+'static) {
        match *self {
            RelicError::Component(ref err) => err,
            RelicError::Io(ref err) => err,
            RelicError::PackageNotFound(_) => self,
            RelicError::RepoNotFound(_) => self,
            // Call as_ref on inner to make transparent
            RelicError::Fungus(ref err) => err.as_ref(),
            RelicError::SerdeYaml(ref err) => err as &(dyn StdError+'static),
            RelicError::Skellige(ref err) => err.as_ref(),
        }
    }
}

impl AsMut<dyn StdError> for RelicError {
    fn as_mut(&mut self) -> &mut (dyn StdError+'static) {
        match *self {
            RelicError::Component(ref mut err) => err,
            RelicError::Io(ref mut err) => err,
            RelicError::PackageNotFound(_) => self,
            RelicError::RepoNotFound(_) => self,
            // Call as_ref on inner to make transparent
            RelicError::Fungus(ref mut err) => err.as_mut(),
            RelicError::SerdeYaml(ref mut err) => err as &mut (dyn StdError+'static),
            RelicError::Skellige(ref mut err) => err.as_mut(),
        }
    }
}

impl From<ComponentError> for RelicError {
    fn from(err: ComponentError) -> RelicError {
        RelicError::Component(err)
    }
}

impl From<io::Error> for RelicError {
    fn from(err: io::Error) -> RelicError {
        RelicError::Io(err)
    }
}

impl From<FuError> for RelicError {
    fn from(err: FuError) -> RelicError {
        RelicError::Fungus(err)
    }
}

impl From<git::Error> for RelicError {
    fn from(err: git::Error) -> RelicError {
        RelicError::Skellige(err)
    }
}

impl From<serde_yaml::Error> for RelicError {
    fn from(err: serde_yaml::Error) -> RelicError {
        RelicError::SerdeYaml(err)
    }
}

#[cfg(test)]
mod tests {
    use crate::prelude::*;

    #[test]
    fn test_errors() {
        // PackageNotFound(String),
        let mut err = RelicError::PackageNotFound("foo".to_string());
        assert_eq!(RelicError::package_not_found("foo").to_string(), err.to_string());
        assert_eq!("failed to find package: foo", err.to_string());
        assert_eq!("failed to find package: foo", err.as_ref().to_string());
        assert_eq!("failed to find package: foo", err.as_mut().to_string());
        assert!(err.is::<RelicError>());
        assert!(err.downcast_ref::<RelicError>().is_some());
        assert!(err.downcast_mut::<RelicError>().is_some());
        assert!(err.source().is_none());

        // RepoNotFound(String),
        let mut err = RelicError::RepoNotFound("foo".to_string());
        assert_eq!(RelicError::repo_not_found("foo").to_string(), err.to_string());
        assert_eq!("failed to find repo: foo", err.to_string());
        assert_eq!("failed to find repo: foo", err.as_ref().to_string());
        assert_eq!("failed to find repo: foo", err.as_mut().to_string());
        assert!(err.is::<RelicError>());
        assert!(err.downcast_ref::<RelicError>().is_some());
        assert!(err.downcast_mut::<RelicError>().is_some());
        assert!(err.source().is_none());

        // Fungus(FuError),
        let mut err = RelicError::from(FuError::from(FileError::FailedToExtractString));
        assert_eq!("failed to extract string from file", err.to_string());
        assert_eq!("failed to extract string from file", err.as_ref().to_string());
        assert_eq!("failed to extract string from file", err.as_mut().to_string());
        assert!(err.is::<FileError>());
        assert!(err.downcast_ref::<FileError>().is_some());
        assert!(err.downcast_mut::<FileError>().is_some());
        assert!(err.source().is_none());

        // Skellige(git::Error), - transparent
        let mut err = RelicError::from(git::Error::from(FuError::from(FileError::FailedToExtractString)));
        assert_eq!("failed to extract string from file", err.to_string());
        assert_eq!("failed to extract string from file", err.as_ref().to_string());
        assert_eq!("failed to extract string from file", err.as_mut().to_string());
        assert!(err.is::<FileError>());
        assert!(err.downcast_ref::<FileError>().is_some());
        assert!(err.downcast_mut::<FileError>().is_some());
        assert!(err.source().is_none());

        // Skellige(git::Error), - transparent
        let mut err = git::Error::from(git2::Error::new(git2::ErrorCode::Ambiguous, git2::ErrorClass::Checkout, "foo"));
        assert_eq!("foo; class=Checkout (20); code=Ambiguous (-5)", err.to_string());
        assert_eq!("foo; class=Checkout (20); code=Ambiguous (-5)", err.as_ref().to_string());
        assert_eq!("foo; class=Checkout (20); code=Ambiguous (-5)", err.as_mut().to_string());
        assert!(err.is::<git2::Error>());
        assert!(err.downcast_ref::<git2::Error>().is_some());
        assert!(err.downcast_mut::<git2::Error>().is_some());
        assert!(err.source().is_none());
    }
}