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
|
//! Error reporting API.
use std::error::Error;
use std::fmt;
/// Result of a cargo command.
pub type CargoResult<T> = Result<T, CargoError>;
/// For programmatically processing failures.
#[derive(Debug, Copy, Clone, PartialEq, Eq)]
pub enum ErrorKind {
/// Spawning the cargo subommand failed.
InvalidCommand,
/// The cargo subcommand returned an error.
CommandFailed,
/// Parsing the cargo subcommand's output failed.
InvalidOutput,
}
impl fmt::Display for ErrorKind {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match *self {
ErrorKind::InvalidOutput => write!(f, "Spawning the cargo subommand failed."),
ErrorKind::CommandFailed => write!(f, "The cargo subcommand returned an error."),
ErrorKind::InvalidCommand => write!(f, "Parsing the cargo subcommand's output failed."),
}
}
}
/// Cargo command failure information.
#[derive(Debug)]
pub struct CargoError {
kind: ErrorKind,
context: Option<String>,
cause: Option<Box<dyn Error + Send + Sync + 'static>>,
}
impl CargoError {
pub(crate) fn new(kind: ErrorKind) -> Self {
Self {
kind,
context: None,
cause: None,
}
}
pub(crate) fn set_context<S>(mut self, context: S) -> Self
where
S: Into<String>,
{
let context = context.into();
self.context = Some(context);
self
}
pub(crate) fn set_cause<E>(mut self, cause: E) -> Self
where
E: Error + Send + Sync + 'static,
{
let cause = Box::new(cause);
self.cause = Some(cause);
self
}
/// For programmatically processing failures.
pub fn kind(&self) -> ErrorKind {
self.kind
}
}
impl Error for CargoError {
fn cause(&self) -> Option<&dyn Error> {
self.cause.as_ref().map(|c| {
let c: &dyn Error = c.as_ref();
c
})
}
}
impl fmt::Display for CargoError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
writeln!(f, "Cargo command failed: {}", self.kind)?;
if let Some(ref context) = self.context {
writeln!(f, "{}", context)?;
}
if let Some(ref cause) = self.cause {
writeln!(f, "Cause: {}", cause)?;
}
Ok(())
}
}
|
