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

use proc_macro::TokenStream;
use quote::quote;
use std::sync::OnceLock;
use std::sync::{Arc, Mutex};
use syn;

struct TestInfo {
    fn_name: String,
    input: String,
}

static FUNCTION_NAMES: OnceLock<Arc<Mutex<Vec<TestInfo>>>> = OnceLock::new();

#[proc_macro_derive(FromContext)]
pub fn from_context(input: TokenStream) -> TokenStream {
    let ast = syn::parse_macro_input!(input as syn::DeriveInput);
    let name = &ast.ident;
    let name_str = name.to_string();

    let code = quote!(
        impl rtest::FromContext for #name {
            type Context = rtest::Context;

            fn from_context(context: &Self::Context) -> Option<rtest::Resource<Self>> {
                context.extract::<#name>()
            }

            fn into_context(context: &Self::Context, resource: rtest::Resource<#name>) {
                context.inject(resource)
            }

            fn get_resource_id() -> rtest::ResourceId {
                #name_str.to_string()
            }
        }
    );
    code.into()
}

#[proc_macro_attribute]
pub fn rtest(_attr: TokenStream, orig_input: TokenStream) -> TokenStream {
    {
        let mutex = FUNCTION_NAMES.get_or_init(|| Arc::new(Mutex::new(Vec::new())));
        let mut list = mutex.lock().unwrap();
        let input = orig_input.clone();
        let ast = syn::parse_macro_input!(input as syn::ItemFn);
        list.push(TestInfo {
            fn_name: ast.sig.ident.to_string(),
            input: orig_input.clone().to_string(),
        })
    }
    orig_input
}

#[proc_macro]
/// input must be the Context, Context must be clonable
pub fn run(input: TokenStream) -> TokenStream {
    use std::str::FromStr;
    let list: Vec<_> = {
        let mutex = FUNCTION_NAMES.get_or_init(|| Arc::new(Mutex::new(Vec::new())));
        mutex.lock().unwrap().drain(..).collect()
    };

    let input_struct = syn::parse_macro_input!(input as syn::Path);

    let mut commands = quote!();
    for l in list.into_iter() {
        let name = l.fn_name.to_string();
        let input = TokenStream::from_str(&l.input).unwrap();
        let ast = syn::parse_macro_input!(input as syn::ItemFn);
        let fn_ident = ast.sig.ident;
        let f = quote! {
            let c = #input_struct.clone();
            let (reference, inputs, outputs) = rtest::describe_handler(& #fn_ident);
            graph_config.add(#name, Box::new(move || {
                rtest::call_handler(c.clone(), &mut #fn_ident)
            }), reference, inputs, outputs, Vec::new());
        };
        commands = quote!(
            #commands
            #f
        );
    }

    let code = quote!(
        {
            use rtest::Graph;
            use rtest::Runner;
            use clap::Parser;
            let args = rtest::Args::parse();

            let mut graph_config = rtest::GraphConfig::default();
            #commands
            let graph = rtest::SimpleExecutionModel::with_config(graph_config);
            Runner::run(graph).print();
        }
    );

    return code.into();
}