gloo_macros 0.1.0

Macros for the Supergloo library, providing path-based routing and other utilities.
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


use proc_macro::TokenStream;
use quote::quote;
use syn::{parse_macro_input, ItemFn};

#[proc_macro_attribute]
pub fn gloo_handler(attr: TokenStream, item: TokenStream) -> TokenStream {
    let method = if attr.is_empty() {
        quote! { get }
    } else {
        let lit = syn::parse_macro_input!(attr as syn::LitStr);
        let m = lit.value().to_lowercase();
        let method = match m.to_string().as_str() {
            "get" => quote! { get },
            "post" => quote! { post },
            "put" => quote! { put },
            "delete" => quote! { delete },
            "patch" => quote! { patch },
            "head" => quote! { head },
            "options" => quote! { options },
            _ => panic!("Invalid HTTP method"),
        };

        method

    };
    
    let input_item = item.clone();
    let input = parse_macro_input!(input_item as ItemFn);
    let fn_ident = &input.sig.ident;

    let fn_name_string = fn_ident.to_string();
        
    let fn_name = syn::LitStr::new(&fn_name_string, fn_ident.span());
    
    
    let expanded = quote! {

        #input


        inventory::submit! {
            GlooHandler {
                path: module_path!(),
                    // .replace("::", "/")
                    // .to_string(),
                router: || axum::routing::#method(#fn_ident),
                fn_name: #fn_name,
            }
        }
    };
    expanded.into()
}


#[proc_macro]
pub fn gloo_routes(_input: TokenStream) -> TokenStream {

    let expanded = quote! {
        {
            let mut router = Router::new();
            for handler in inventory::iter::<GlooHandler> {


                let mut path = handler.path.split("::").collect::<Vec<_>>();


                for i in 0..path.len() {
                    if path[i] == "routes" {
                        path.remove(i);
                        break;
                    } else {
                        path[i] = ""
                    }
                }


                let mut path = path.join("/").replace("::", "/");

                if handler.fn_name != "base" {
                    path = format!("{}/{}", path, handler.fn_name);
                }

                if !path.starts_with("/") {
                    path = format!("/{}", path);
                }


                dbg!(&path);


                router = router.route(&path, (handler.router)());
            }
            router
        }
    };
    expanded.into()
}