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

extern crate proc_macro;
use generate::{generate_struct, generate_ws_struct};
use proc_macro::TokenStream;
use quote::{quote, ToTokens};
use syn::{parse_macro_input, AttributeArgs, ItemFn, Meta, NestedMeta};
mod generate;
mod utils;

#[proc_macro_attribute]
pub fn get(attr: TokenStream, item: TokenStream) -> TokenStream {
    let args = parse_macro_input!(attr as AttributeArgs);

    let mut internal = false;
    let mut ws = false;
    for arg in &args {
        if matches!(arg, NestedMeta::Meta(Meta::Path(p)) if p.is_ident("internal")) {
            internal = true;
        } else if matches!(arg, NestedMeta::Meta(Meta::Path(p)) if p.is_ident("ws")) {
            ws = true;
        }
    }

    let path = args[0].to_token_stream();
    let mut string = path.to_string();
    string = string[1..string.len() - 1].to_string();

    match syn::parse::<ItemFn>(item) {
        Ok(item_fn) => {
            let vis = item_fn.vis.clone();
            let ident = item_fn.sig.ident.clone();
            let def_struct = if ws {
                generate_ws_struct(internal, item_fn)
            } else {
                generate_struct(internal, item_fn)
            };
            let expanded = if ws {
                quote! {
                    #vis fn #ident() -> juri::RouteOrWSRoute {
                        #def_struct

                        juri::RouteOrWSRoute::WS(juri::WSRoute {
                            path: #string.to_string(),
                            handler: std::sync::Arc::new(#ident)
                        })
                    }
                }
            } else {
                quote! {
                    #vis fn #ident() -> juri::RouteOrWSRoute {
                        #def_struct

                        juri::RouteOrWSRoute::COMMON(juri::Route {
                            method: juri::HTTPMethod::GET,
                            path: #string.to_string(),
                            handler: std::sync::Arc::new(#ident)
                        })
                    }
                }
            };
            expanded.into()
        }
        Err(err) => err.into_compile_error().into(),
    }
}

#[proc_macro_attribute]
pub fn post(attr: TokenStream, item: TokenStream) -> TokenStream {
    let args = parse_macro_input!(attr as AttributeArgs);

    let mut internal = false;
    for arg in &args {
        if matches!(arg, NestedMeta::Meta(Meta::Path(p)) if p.is_ident("internal")) {
            internal = true;
        }
    }

    let path = args[0].to_token_stream();
    let mut string = path.to_string();
    string = string[1..string.len() - 1].to_string();

    match syn::parse::<ItemFn>(item) {
        Ok(item_fn) => {
            let vis = item_fn.vis.clone();
            let ident = item_fn.sig.ident.clone();
            let def_struct = generate_struct(internal, item_fn);
            let expanded = quote! {
                #vis fn #ident() -> juri::RouteOrWSRoute {
                    #def_struct

                    juri::RouteOrWSRoute::COMMON(juri::Route {
                        method: juri::HTTPMethod::POST,
                        path: #string.to_string(),
                        handler: std::sync::Arc::new(#ident)
                    })
                }
            };
            expanded.into()
        }
        Err(err) => err.into_compile_error().into(),
    }
}

#[proc_macro_attribute]
pub fn handler(attr: TokenStream, item: TokenStream) -> TokenStream {
    let args = parse_macro_input!(attr as AttributeArgs);

    let mut internal = false;
    for arg in &args {
        if matches!(arg, NestedMeta::Meta(Meta::Path(p)) if p.is_ident("internal")) {
            internal = true;
        }
    }

    match syn::parse::<ItemFn>(item) {
        Ok(item_fn) => generate_struct(internal, item_fn).into(),
        Err(err) => err.into_compile_error().into(),
    }
}