floxide-macros 3.2.2

A directed graph workflow system in Rust
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

use proc_macro::TokenStream;
use quote::quote;
use syn::{braced, parse_macro_input, Token};

pub fn node(item: TokenStream) -> TokenStream {
    use quote::quote;
    use syn::parse::{Parse, ParseStream};
    use syn::{braced, parse_macro_input, Ident, Token, Type, Visibility};

    struct NodeDef {
        vis: Visibility,
        name: Ident,
        fields: Vec<(Ident, Type)>,
        ctx_ty: Type,
        input_ty: Type,
        output_ty: Type,
        ctx_arg: Ident,
        input_arg: Ident,
        body: syn::Block,
    }
    impl Parse for NodeDef {
        fn parse(input: ParseStream) -> syn::Result<Self> {
            let vis: Visibility = input.parse()?;
            input.parse::<Token![struct]>()?;
            let name: Ident = input.parse()?;
            let content;
            braced!(content in input);
            let mut fields = Vec::new();
            while !content.is_empty() {
                let f: Ident = content.parse()?;
                content.parse::<Token![:]>()?;
                let ty: Type = content.parse()?;
                if content.peek(Token![,]) {
                    content.parse::<Token![,]>()?;
                }
                fields.push((f, ty));
            }
            input.parse::<Token![;]>()?;
            // context = MyCtx;
            // parse `context = Type;`
            let ctx_kw: Ident = input.parse()?;
            if ctx_kw != "context" {
                return Err(input.error("expected `context = Type;`"));
            }
            input.parse::<Token![=]>()?;
            let ctx_ty: Type = input.parse()?;
            input.parse::<Token![;]>()?;
            // input = InputType;
            // parse `input = Type;`
            let in_kw: Ident = input.parse()?;
            if in_kw != "input" {
                return Err(input.error("expected `input = Type;`"));
            }
            input.parse::<Token![=]>()?;
            let input_ty: Type = input.parse()?;
            input.parse::<Token![;]>()?;
            // output = OutputType;
            // parse `output = Type;`
            let out_kw: Ident = input.parse()?;
            if out_kw != "output" {
                return Err(input.error("expected `output = Type;`"));
            }
            input.parse::<Token![=]>()?;
            let output_ty: Type = input.parse()?;
            input.parse::<Token![;]>()?;
            // closure args
            input.parse::<Token![|]>()?;
            let ctx_arg: Ident = input.parse()?;
            input.parse::<Token![,]>()?;
            let input_arg: Ident = input.parse()?;
            input.parse::<Token![|]>()?;
            let body: syn::Block = input.parse()?;
            Ok(NodeDef {
                vis,
                name,
                fields,
                ctx_ty,
                input_ty,
                output_ty,
                ctx_arg,
                input_arg,
                body,
            })
        }
    }
    let NodeDef {
        vis,
        name,
        fields,
        ctx_ty,
        input_ty,
        output_ty,
        ctx_arg,
        input_arg,
        body,
    } = parse_macro_input!(item as NodeDef);
    let field_defs = fields.iter().map(|(f, ty)| quote! { pub #f: #ty });
    let struct_def = quote! { #[derive(Clone, Debug)] #vis struct #name { #(#field_defs),* } };
    let expanded = quote! {
        #struct_def
        #[::async_trait::async_trait]
        impl ::floxide::Node<#ctx_ty> for #name
        where
            #ctx_ty: Clone + Send + Sync
        {
            type Input = #input_ty;
            type Output = #output_ty;

            async fn process(
                &self,
                #ctx_arg: &#ctx_ty,
                #input_arg: #input_ty
            ) -> Result<::floxide::Transition<#output_ty>, ::floxide::FloxideError>
            {
                let #ctx_arg = #ctx_arg;
                let #input_arg = #input_arg;
                #body
            }
        }
    };
    TokenStream::from(expanded)
}