union_impl 0.1.3

Implementation of the `union!` macro.
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

//!
//! `ActionGroup` represents two possible types of action: `Instant` and `Deferred`.
//! Any type could be any of `CommandGroup`.
//!

use syn::Expr;

use super::super::expr::{DefaultActionExpr, ProcessActionExpr};
use super::command_group::CommandGroup;

#[derive(Clone, Copy, PartialEq, Eq, Debug)]
pub enum ActionGroup {
    Instant(CommandGroup),
    Deferred(CommandGroup),
}

impl ActionGroup {
    ///
    /// Attempts to map expr to `ProcessActionExpr` with self type.
    /// Returns None if self isn't of `ProcessExpr` type
    ///
    pub fn map_to_process_action_expr(self, expr: Expr) -> Option<ProcessActionExpr> {
        match self {
            ActionGroup::Instant(group) => group
                .map_to_process_expr(expr)
                .map(ProcessActionExpr::Instant),
            ActionGroup::Deferred(group) => group
                .map_to_process_expr(expr)
                .map(ProcessActionExpr::Deferred),
        }
    }

    ///
    /// Attempts to map expr to `DefaultActionExpr` with self type.
    /// Returns None if self isn't of `DefaultExpr` type
    ///
    pub fn map_to_default_action_expr(self, expr: Expr) -> Option<DefaultActionExpr> {
        match self {
            ActionGroup::Instant(group) => group
                .map_to_default_expr(expr)
                .map(DefaultActionExpr::Instant),
            ActionGroup::Deferred(group) => group
                .map_to_default_expr(expr)
                .map(DefaultActionExpr::Deferred),
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::expr_chain::expr::{DefaultExpr, ProcessExpr};

    #[test]
    fn it_tests_action_group_impl_process_expr() {
        let expr: ::syn::Expr = ::syn::parse2(::quote::quote! { |v| v + 1 }).unwrap();
        let group = CommandGroup::Then;

        let action_group = ActionGroup::Instant(group.clone());

        assert_eq!(
            action_group
                .map_to_process_action_expr(expr.clone())
                .unwrap(),
            ProcessActionExpr::Instant(ProcessExpr::Then(expr.clone()))
        );

        assert!(action_group
            .map_to_default_action_expr(expr.clone())
            .is_none());

        let action_group = ActionGroup::Deferred(group.clone());

        assert_eq!(
            action_group
                .map_to_process_action_expr(expr.clone())
                .unwrap(),
            ProcessActionExpr::Deferred(ProcessExpr::Then(expr.clone()))
        );
        assert!(action_group
            .map_to_default_action_expr(expr.clone())
            .is_none());
    }

    #[test]
    fn it_tests_action_group_impl_default_expr() {
        let expr: ::syn::Expr = ::syn::parse2(::quote::quote! { |v| v + 1 }).unwrap();
        let group = CommandGroup::Or;

        let action_group = ActionGroup::Instant(group.clone());

        assert_eq!(
            action_group
                .map_to_default_action_expr(expr.clone())
                .unwrap(),
            DefaultActionExpr::Instant(DefaultExpr::Or(expr.clone()))
        );
        assert_eq!(action_group.map_to_process_action_expr(expr.clone()), None);

        let action_group = ActionGroup::Deferred(group.clone());

        assert_eq!(
            action_group
                .map_to_default_action_expr(expr.clone())
                .unwrap(),
            DefaultActionExpr::Deferred(DefaultExpr::Or(expr.clone()))
        );
        assert_eq!(action_group.map_to_process_action_expr(expr.clone()), None);

        let group = CommandGroup::OrElse;

        let action_group = ActionGroup::Instant(group.clone());

        assert_eq!(
            action_group
                .map_to_default_action_expr(expr.clone())
                .unwrap(),
            DefaultActionExpr::Instant(DefaultExpr::OrElse(expr.clone()))
        );
        assert_eq!(action_group.map_to_process_action_expr(expr.clone()), None);

        let action_group = ActionGroup::Deferred(group.clone());

        assert_eq!(
            action_group
                .map_to_default_action_expr(expr.clone())
                .unwrap(),
            DefaultActionExpr::Deferred(DefaultExpr::OrElse(expr.clone()))
        );
        assert_eq!(action_group.map_to_process_action_expr(expr.clone()), None);
    }
}