fairjax 0.1.0

Fair join pattern matching
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

use crate::compile::case::action::Action;
use crate::compile::matchers::Setup;
use crate::compile::sections::{action::ActionSectionCodeGen, setup::SetupSectionCodeGen};
use crate::parse::context::Context;
use crate::traits::Definition;
use proc_macro2::{Span, TokenStream};
use quote::quote;
use syn::Ident;

pub trait TopLevelCodeGen {
    fn generate<A: ActionSectionCodeGen, D: SetupSectionCodeGen>(
        def: &dyn Definition,
    ) -> TokenStream;
}

pub struct TopLevel;

impl TopLevel {}

impl TopLevelCodeGen for TopLevel {
    fn generate<A: ActionSectionCodeGen, D: SetupSectionCodeGen>(
        def: &dyn Definition,
    ) -> TokenStream {
        let Context {
            incoming_message,
            mailbox,
            ..
        } = def.context();

        let result_name = "result";
        let result_ident = Ident::new(result_name, Span::call_site());
        let action_section = A::generate::<Action>(def.cases(), result_name);
        let setup_section = D::generate::<Setup>(def);

        quote! {
            // Run init once
            if !#mailbox.is_initialized() {
                // Check if user modified mailbox
                if #mailbox.is_modified() {
                    panic!("Mailbox was modified prior to initialization");
                }

                // Declare all matchers
                #setup_section

                // Finalize init
                #mailbox.init();
            }

            // Run action if match was found
            if let Some(#result_ident) = #mailbox.process(#incoming_message) {
                #action_section
            }

            // Return unit type
            ()
        }
    }
}

// #[cfg(test)]
// mod tests {
//     use super::*;
//     use proc_macro_utils::assert_tokens;

//     struct DefDI;

//     impl Definition for DefDI {
//         fn context(&self) -> Context {
//             unimplemented!()
//         }
//         fn cases(&self) -> Vec<Box<dyn Case>> {
//             Vec::new()
//         }
//     }

//     struct Act;

//     impl ActionSectionCodeGen for Act {
//         fn generate(cases: Vec<Box<dyn Case>>) -> TokenStream {
//             TokenStream::from(quote!(actionblock))
//         }
//     }

//     #[test]
//     fn test_top_level_generate() {
//         let result = TopLevel::generate::<Act>(DefDI);

//         assert_tokens!(result, { actionblock });
//     }
// }