anyerr 0.1.1

Dynamic error library with rich error wrapping and context support
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

use crate::context::{AbstractContext, Context};
use crate::converter::Convertable;
use crate::core::AnyError;
use crate::kind::Kind;
use crate::overlay::error::IntermediateAnyError;
use crate::overlay::{Applicable, Intermediate, Overlay};

impl<T, C, K> Overlay for Result<T, AnyError<C, K>>
where
    C: AbstractContext,
    K: Kind,
{
    type Output = Result<T, AnyError<C, K>>;

    type Intermediate = Result<T, IntermediateAnyError<C, K>>;
}

impl<T, C, K> Intermediate for Result<T, IntermediateAnyError<C, K>>
where
    C: AbstractContext,
    K: Kind,
{
    type Output = Result<T, AnyError<C, K>>;

    fn build(self) -> Self::Output {
        self.map_err(Into::into)
    }
}

impl<T, C, K> Applicable<Result<T, AnyError<C, K>>> for String
where
    C: AbstractContext,
    K: Kind,
{
    type Output = Result<T, IntermediateAnyError<C, K>>;

    /// Delegates the parameters to [`AnyError`]'s implementation.
    fn apply(self, target: Result<T, AnyError<C, K>>) -> Self::Output {
        target.map_err(|err| err.overlay(self))
    }
}

impl<T, C, K> Applicable<Result<T, AnyError<C, K>>> for &str
where
    C: AbstractContext,
    K: Kind,
{
    type Output = Result<T, IntermediateAnyError<C, K>>;

    /// Delegates the parameters to [`AnyError`]'s implementation.
    fn apply(self, target: Result<T, AnyError<C, K>>) -> Self::Output {
        target.map_err(|err| err.overlay(self))
    }
}

impl<T, C, K, S> Applicable<Result<T, AnyError<C, K>>> for (S, K)
where
    C: AbstractContext,
    K: Kind,
    S: Into<String>,
{
    type Output = Result<T, IntermediateAnyError<C, K>>;

    /// Delegates the parameters to [`AnyError`]'s implementation.
    fn apply(self, target: Result<T, AnyError<C, K>>) -> Self::Output {
        target.map_err(|err| err.overlay(self))
    }
}

impl<T, C, K, Q, R> Applicable<Result<T, IntermediateAnyError<C, K>>> for (Q, R)
where
    C: Context,
    K: Kind,
    Q: Into<C::Key>,
    R: Convertable<C::Converter, C::Value>,
{
    type Output = Result<T, IntermediateAnyError<C, K>>;

    /// Delegates the parameters to [`IntermediateAnyError`]'s implementation.
    fn apply(self, target: Result<T, IntermediateAnyError<C, K>>) -> Self::Output {
        target.map_err(|err| err.context(self.0, self.1))
    }
}

#[cfg(test)]
mod tests {
    use std::error::Error;

    use crate::context::LiteralKeyStringMapContext;
    use crate::kind::DefaultErrorKind;

    use super::*;

    type ErrKind = DefaultErrorKind;
    type DefaultAnyError = AnyError<LiteralKeyStringMapContext, ErrKind>;

    #[test]
    fn result_overlay_succeeds_when_message_is_given() {
        let source = Err::<(), _>(DefaultAnyError::minimal("source error"));
        let res = source.overlay(String::from("wrapper error")).build();
        let err = res.unwrap_err();
        assert_eq!(err.to_string(), "wrapper error");
        assert_eq!(err.source().unwrap().to_string(), "source error");

        let source = Err::<(), _>(DefaultAnyError::minimal("source error"));
        let res = source.overlay("wrapper error").build();
        let err = res.unwrap_err();
        assert_eq!(err.to_string(), "wrapper error");
        assert_eq!(err.source().unwrap().to_string(), "source error");
    }

    #[test]
    fn result_overlay_succeeds_when_message_and_kind_are_given() {
        let source = Err::<(), _>(DefaultAnyError::minimal("source error"));
        let res = source
            .overlay(("wrapper error", ErrKind::ValueValidation))
            .build();
        let err = res.unwrap_err();
        assert_eq!(err.to_string(), "wrapper error");
        assert_eq!(err.kind(), ErrKind::ValueValidation);
        assert_eq!(err.source().unwrap().to_string(), "source error");
    }

    #[test]
    fn result_overlay_succeeds_when_result_is_ok() {
        let source = Ok::<i32, DefaultAnyError>(1);
        let res = source.overlay("no error").build();
        assert_eq!(res.unwrap(), 1);
    }

    #[test]
    fn intermediate_result_context_succeeds() {
        let source = Err::<(), _>(DefaultAnyError::minimal("source error"));
        let res = source
            .overlay(String::from("wrapper error"))
            .context("i32", 1)
            .context("&str", "value")
            .build();
        let err = res.unwrap_err();
        assert_eq!(err.to_string(), "wrapper error");
        assert_eq!(err.get("i32"), Some("1"));
        assert_eq!(err.get("&str"), Some("\"value\""));
    }
}