evitable 0.2.0

Custom error types with context and derive
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

extern crate evitable;

use evitable::*;
use std::fmt;

#[derive(Debug, PartialEq, Eq)]
pub(crate) struct IncrementWhenCloned(u8);

impl Clone for IncrementWhenCloned {
  fn clone(&self) -> Self {
    IncrementWhenCloned(self.0 + 1)
  }
}

impl Copy for IncrementWhenCloned {}

impl fmt::Display for IncrementWhenCloned {
  fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    fmt::Display::fmt(&self.0, f)
  }
}

mod clone {
  use super::*;

  #[derive(ErrorContext)]
  #[evitable(description("Some test: {}", cloned))]
  pub(super) struct Test {
    #[evitable(include_in_kind, clone)]
    cloned: IncrementWhenCloned,
  }

  #[test]
  pub fn error_context_cloned() {
    let err = Test {
      cloned: IncrementWhenCloned(0),
    };

    let kind = err.kind();
    assert_eq!(
      kind,
      evitable_test::ErrorKind::Test {
        cloned: IncrementWhenCloned(1)
      }
    );
  }

  #[test]
  pub fn display() {
    let err = Test {
      cloned: IncrementWhenCloned(0),
    };

    let display_str = format!("{}", err);
    assert_eq!("Some test: 0", display_str);
  }
}

mod copy {
  use super::*;

  #[derive(ErrorContext)]
  #[evitable(description("Other test: {}", copied))]
  pub(super) struct Test {
    #[evitable(include_in_kind)]
    copied: IncrementWhenCloned,
  }

  #[test]
  pub fn error_context_copied() {
    let err = Test {
      copied: IncrementWhenCloned(0),
    };

    let kind = err.kind();
    assert_eq!(
      kind,
      evitable_test::ErrorKind::Test {
        copied: IncrementWhenCloned(0)
      }
    );
  }
}