ngyn_macros 0.0.1

Modular backend framework for web applications
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

extern crate proc_macro;
use proc_macro::TokenStream;
use quote::quote;
use syn::{parse_macro_input, DeriveInput};

use crate::utils::handle_macro::handle_macro;

struct ModuleArgs {
    controllers: Vec<syn::Path>,
}

pub fn module_macro(args: TokenStream, input: TokenStream) -> TokenStream {
    let input = parse_macro_input!(input as DeriveInput);
    let (ident, _, _) = handle_macro(input);

    // Parse the attributes to get the controller types
    let args = {
        let input_str = args.to_string();

        let controllers = if input_str.starts_with('[') && input_str.ends_with(']') {
            let controllers: Vec<syn::Path> =
                if !input_str[1..input_str.len() - 1].trim().is_empty() {
                    input_str[1..input_str.len() - 1]
                        .split(',')
                        .map(|s| s.trim().to_string())
                        .map(|s| syn::parse_str(&s).unwrap())
                        .collect()
                } else {
                    vec![]
                };

            Some(controllers)
        } else if input_str.is_empty() {
            Some(vec![])
        } else {
            panic!("invalid path")
        };

        ModuleArgs {
            controllers: controllers.unwrap(),
        }
    };

    let add_controllers: Vec<_> = args
        .controllers
        .iter()
        .map(|controller| {
            quote! {
                let controller: #controller = #controller::new();
                controllers.push(std::sync::Arc::new(controller));
            }
        })
        .collect();

    let keys = args.controllers.iter().map(|controller| {
        let segments = &controller.segments;
        let name = &segments.last().unwrap().ident;
        quote! { #name }
    });

    let fields: Vec<_> = keys
        .clone()
        .zip(args.controllers.iter())
        .map(|(key, controller)| {
            quote! {
                #key: #controller
            }
        })
        .collect();

    let expanded = quote! {
        #[ngyn::dependency]
        pub struct #ident {
            #(#fields),*
        }

        impl ngyn::NgynModule for #ident {
            /// Creates a new `#ident` with the specified components.
            ///
            /// # Examples
            ///
            /// ```
            /// let module = #ident::new();
            /// ```
            fn new() -> Self {
                #ident {
                    #(#keys: ngyn::NgynProvider.provide()),*
                }
            }

            /// Returns the controllers of the module.
            ///
            /// # Examples
            ///
            /// ```
            /// let module = #ident::new();
            /// let controllers = module.get_controllers();
            /// ```
            fn get_controllers(&self) -> Vec<std::sync::Arc<dyn ngyn::NgynController>> {
                let mut controllers: Vec<std::sync::Arc<dyn ngyn::NgynController>> = vec![];
                #(#add_controllers)*
                controllers
            }
        }
    };
    TokenStream::from(expanded)
}