pretty-error-debug 0.3.2

If the process ends with an `Error`, write out the `Error` message and chain.
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

extern crate alloc;

mod pretty_error_debug {
    pub(super) use crate::*;
}

use core::fmt;

use crate::{Display, Error, Wrapper};

#[derive(Debug, Clone, Copy)]
enum RootError {
    Reasons,
}

impl fmt::Display for RootError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            RootError::Reasons => write!(f, "Reasons"),
        }
    }
}

impl Error for RootError {}

#[derive(Debug, Clone, Copy)]
enum InnerError {
    Cause { root: RootError },
}

impl fmt::Display for InnerError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            InnerError::Cause { root } => write!(f, "Failed because of {:?}", root),
        }
    }
}

impl Error for InnerError {
    fn source(&self) -> Option<&(dyn Error + 'static)> {
        match self {
            InnerError::Cause { root } => Some(root),
        }
    }
}

impl From<RootError> for InnerError {
    fn from(root: RootError) -> Self {
        InnerError::Cause { root }
    }
}

#[derive(pretty_error_debug::Debug, Clone, Copy)]
enum OuterError {
    Inner(InnerError),
}

impl fmt::Display for OuterError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            OuterError::Inner(_) => write!(f, "Got an InnerError"),
        }
    }
}

impl Error for OuterError {
    fn source(&self) -> Option<&(dyn Error + 'static)> {
        match self {
            OuterError::Inner(cause) => Some(cause),
        }
    }
}

impl From<InnerError> for OuterError {
    fn from(cause: InnerError) -> Self {
        OuterError::Inner(cause)
    }
}

#[derive(Debug, Clone, Copy)]
enum SimpleOuterError {
    Inner(InnerError),
}

impl fmt::Display for SimpleOuterError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            SimpleOuterError::Inner(_) => write!(f, "Got an InnerError"),
        }
    }
}

impl Error for SimpleOuterError {
    fn source(&self) -> Option<&(dyn Error + 'static)> {
        match self {
            SimpleOuterError::Inner(cause) => Some(cause),
        }
    }
}

impl From<InnerError> for SimpleOuterError {
    fn from(cause: InnerError) -> Self {
        SimpleOuterError::Inner(cause)
    }
}

fn root() -> Result<(), RootError> {
    Err(RootError::Reasons)
}

fn inner() -> Result<(), InnerError> {
    root().map_err(InnerError::from)
}

fn outer() -> Result<(), OuterError> {
    inner().map_err(OuterError::from)
}

fn simple_outer() -> Result<(), SimpleOuterError> {
    inner().map_err(SimpleOuterError::Inner)
}

const EXPECTED: &str = "\
Got an InnerError

Caused by:
    1: Failed because of Reasons
    2: Reasons\
";

#[test]
fn test_derive() {
    let outcome = alloc::format!("{:?}", outer().unwrap_err());
    assert_eq!(EXPECTED, &outcome);
}

#[test]
fn test_wrapper() {
    let outcome = alloc::format!("{:?}", Wrapper::from(simple_outer().unwrap_err()));
    assert_eq!(EXPECTED, &outcome);
}

#[test]
fn test_display() {
    let outcome = alloc::format!("{}", Display(&simple_outer().unwrap_err()));
    assert_eq!(EXPECTED, &outcome);
}