hegeltest-macros 0.2.2

Procedural macros for Hegel.
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

use proc_macro2::TokenStream;
use quote::quote;
use syn::{Attribute, ImplItem, ItemImpl};

fn is_rule(a: &Attribute) -> bool {
    a.path().is_ident("rule")
}

fn is_invariant(a: &Attribute) -> bool {
    a.path().is_ident("invariant")
}

pub fn expand_state_machine(mut block: ItemImpl) -> TokenStream {
    let mut rule_names = Vec::new();
    let mut invariant_names = Vec::new();

    for item in &mut block.items {
        if let ImplItem::Fn(method) = item {
            if method.attrs.iter().any(&is_rule) {
                rule_names.push(method.sig.ident.clone());
                method.attrs.retain(|a| !is_rule(a));
            }
            if method.attrs.iter().any(&is_invariant) {
                invariant_names.push(method.sig.ident.clone());
                method.attrs.retain(|a| !is_invariant(a));
            }
        }
    }

    let block_type = &block.self_ty;

    let rule_name_strings: Vec<String> = rule_names.iter().map(|id| id.to_string()).collect();
    let invariant_name_strings: Vec<String> =
        invariant_names.iter().map(|id| id.to_string()).collect();

    quote! {
        #block
        impl ::hegel::stateful::StateMachine for #block_type {
            fn rules(&self) -> Vec<::hegel::stateful::Rule<Self>> {
                vec![ #( ::hegel::stateful::Rule::new(#rule_name_strings, Self::#rule_names) ),* ]
            }
            fn invariants(&self) -> Vec<::hegel::stateful::Invariant<Self>> {
                vec![ #( ::hegel::stateful::Invariant::new(#invariant_name_strings, Self::#invariant_names) ),* ]
            }
        }
    }
}