mika 0.0.0

A framework for building wasm front-end web application in Rust
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

#[macro_export]
macro_rules! handler {
    ($state:ident . $($idents:ident).+ (_)) => {{
        let cloned_state = $state.clone();
        move |arg| cloned_state.$($idents).+(arg)
    }};
    ($state:ident . $($idents:ident).+ (_, $($tt:tt)+)) => {{
        let cloned_state = $state.clone();
        move |arg| cloned_state.$($idents).+(arg, $($tt)+)
    }};
    ($state:ident . $($idents:ident).+ ($($tt:tt)*)) => {{
        let cloned_state = $state.clone();
        move |_| cloned_state.$($idents).+($($tt)*)
    }};
}

#[macro_export]
macro_rules! update {
    ($state:ident, $first:ident$(::$idents:ident)*) => {{
        let cloned_state = $state.clone();
        move |_| cloned_state.update($first$(::$idents)*)
    }};
    ($state:ident, $first:ident$(::$idents:ident)*(_)) => {{
        let cloned_state = $state.clone();
        move |arg| cloned_state.update($first$(::$idents)*(arg))
    }};
    ($state:ident, $first:ident$(::$idents:ident)*(_, $($tt:tt)+)) => {{
        let cloned_state = $state.clone();
        move |arg| cloned_state.update($first$(::$idents)*(arg, $($tt)+))
    }};
    ($state:ident, $first:ident$(::$idents:ident)*($($tt:tt)+)) => {{
        let cloned_state = $state.clone();
        move |_| cloned_state.update($first$(::$idents)*($($tt)+))
    }};
}

#[macro_export]
macro_rules! create_app_handle {
    ($TypeName:ident) => {
        #[wasm_bindgen]
        pub struct AppHandle {
            _app: App<$TypeName>,
        }

        #[wasm_bindgen]
        impl AppHandle {
            #[wasm_bindgen(constructor)]
            pub fn new() -> Self {
                Self {
                    _app: App::start_in_body($TypeName::new())
                }
            }
        }
    };
}

#[cfg(test)]
mod test {
    enum Msg {
        N42,
        Double(i32),
        Add(i32,i32),
        Sum(i32,i32,i32),
    }
    #[derive(Clone)]
    struct Test;
    impl Test {
        fn n42(&self) -> i32 {
            42
        }
        fn double(&self, me: i32)  -> i32 {
            me * 2
        }
        fn add(&self, a: i32, b: i32)  -> i32 {
            a + b
        }
        fn sum(&self, a: i32, b: i32, c: i32) -> i32 {
            a + b + c
        }
        fn update(&self, m: Msg) -> i32 {
            match m {
                Msg::N42 => 42,
                Msg::Double(value) => value*2,
                Msg::Add(v1, v2) => v1 + v2,
                Msg::Sum(v1,v2,v3) => v1 + v2 + v3,
            }
        }
    }

    #[test]
    fn handler_no_arg() {
        assert_eq!(42, handler!(Test.n42())(()));
    }

    #[test]
    fn handler_with_arg() {
        assert_eq!(84, handler!(Test.double(42))(()));
        assert_eq!(84, handler!(Test.add(42,42))(()));
        assert_eq!(85, handler!(Test.sum(42,42,1))(()));
    }

    #[test]
    fn handler_optional_arg_only() {
        assert_eq!(84, handler!(Test.double(_))(42));
    }

    #[test]
    fn handler_optional_arg_and_other() {
        assert_eq!(84, handler!(Test.add(_,42))(42));
        assert_eq!(85, handler!(Test.sum(_,42,1))(42));
    }

    #[test]
    fn update() {
        assert_eq!(42, update!(Test, Msg::N42)(()));
        assert_eq!(84, update!(Test, Msg::Double(42))(()));
        assert_eq!(84, update!(Test, Msg::Add(42,42))(()));
        assert_eq!(80, update!(Test, Msg::Sum(42,42,-4))(()));
    }

    #[test]
    fn update_with_optional_arg() {
        assert_eq!(84, update!(Test, Msg::Double(_))(42));
        assert_eq!(84, update!(Test, Msg::Add(_,42))(42));
        assert_eq!(80, update!(Test, Msg::Sum(_,42,42))(-4));
    }
}