mindset 0.1.1

A pure functional state machine library built on Stillwater's Effect system
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

//! Macros for ergonomic state machine construction.

/// Generate State trait implementation for simple enums.
///
/// # Example
///
/// ```
/// use mindset::state_enum;
///
/// state_enum! {
///     pub enum WorkflowState {
///         Start,
///         Processing,
///         Done,
///         Failed,
///     }
///     final: [Done, Failed]
///     error: [Failed]
/// }
/// ```
#[macro_export]
macro_rules! state_enum {
    (
        $(#[$meta:meta])*
        $vis:vis enum $name:ident {
            $(
                $(#[$variant_meta:meta])*
                $variant:ident
            ),* $(,)?
        }

        $(final: [$($final:ident),* $(,)?])?
        $(error: [$($error:ident),* $(,)?])?
    ) => {
        $(#[$meta])*
        #[derive(Clone, PartialEq, Debug, serde::Serialize, serde::Deserialize)]
        $vis enum $name {
            $(
                $(#[$variant_meta])*
                $variant
            ),*
        }

        impl $crate::core::State for $name {
            fn name(&self) -> &str {
                match self {
                    $(Self::$variant => stringify!($variant)),*
                }
            }

            fn is_final(&self) -> bool {
                match self {
                    $($(Self::$final => true,)*)?
                    _ => false,
                }
            }

            fn is_error(&self) -> bool {
                match self {
                    $($(Self::$error => true,)*)?
                    _ => false,
                }
            }
        }
    };
}

#[cfg(test)]
mod tests {
    use crate::core::State;

    state_enum! {
        enum TestState {
            Initial,
            Processing,
            Complete,
            Failed,
        }
        final: [Complete, Failed]
        error: [Failed]
    }

    #[test]
    fn state_enum_macro_generates_trait() {
        let state = TestState::Initial;
        assert_eq!(state.name(), "Initial");
        assert!(!state.is_final());
        assert!(!state.is_error());

        let complete = TestState::Complete;
        assert!(complete.is_final());
        assert!(!complete.is_error());

        let failed = TestState::Failed;
        assert!(failed.is_final());
        assert!(failed.is_error());
    }

    #[test]
    fn state_enum_supports_visibility() {
        // The macro should work with pub visibility
        state_enum! {
            pub enum PublicState {
                A,
                B,
            }
            final: [B]
        }

        let _state = PublicState::A;
    }

    #[test]
    fn state_enum_works_without_final_error() {
        state_enum! {
            enum MinimalState {
                One,
                Two,
            }
        }

        let state = MinimalState::One;
        assert!(!state.is_final());
        assert!(!state.is_error());
    }
}