maple_derive 0.1.0

Derive macros for maple
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
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156

//! # maple_derive
//!
//! This crate provides a custom derive macro for implementing the `Node` trait in the `maple` game engine.
//!
//! ## Usage
//!
//! To use, annotate your struct like this:
//!
//! ```rust
//! use maple::{
//!     Node,
//!     components::{NodeTransform, EventReceiver},
//!     context::Scene
//! };
//!
//! #[derive(Node, Clone)]
//! struct MyNode {
//!     #[transform]
//!     transform: NodeTransform,
//!
//!     #[children]
//!     children: Scene,
//!
//!     #[events]
//!     events: EventReceiver,
//! }
//! ```

use proc_macro::TokenStream;
use quote::quote;
use syn::{Data, DeriveInput, Fields, parse_macro_input};

/// Derives the `Node` trait for a struct with fields for transform, children, and events.
///
/// ## Example
///
/// ```rust
/// use maple::{
///     Node,
///     components::{NodeTransform, EventReceiver},
///     context::Scene
/// };
///
/// #[derive(Node, Clone)]
/// struct MyNode {
///     #[transform]
///     transform: NodeTransform,
///
///     #[children]
///     children: Scene,
///
///     #[events]
///     events: EventReceiver,
/// }
/// ```
#[proc_macro_derive(Node, attributes(transform, children, events))]
pub fn derive_node(input: TokenStream) -> TokenStream {
    let input = parse_macro_input!(input as DeriveInput);

    let struct_name = &input.ident;

    let fields = match &input.data {
        Data::Struct(data_struct) => match &data_struct.fields {
            Fields::Named(fields_named) => &fields_named.named,
            _ => panic!("Node can only be derived for structs with named fields"),
        },
        _ => panic!("Node can only be derived for structs"),
    };

    let mut transform_field = None;
    let mut children_field = None;
    let mut events_field = None;

    for field in fields {
        for attr in &field.attrs {
            if attr.path().is_ident("transform") {
                transform_field = Some(field.ident.clone().unwrap());
            } else if attr.path().is_ident("children") {
                children_field = Some(field.ident.clone().unwrap());
            } else if attr.path().is_ident("events") {
                events_field = Some(field.ident.clone().unwrap());
            }
        }
    }

    if transform_field.is_none() || children_field.is_none() || events_field.is_none() {
        let mut errors = Vec::new();

        if transform_field.is_none() {
            errors.push(syn::Error::new_spanned(
                struct_name,
                "Missing field marked with #[transform]\n\
        Example:\n\
        #[transform]\n\
        transform: NodeTransform,",
            ));
        }

        if children_field.is_none() {
            errors.push(syn::Error::new_spanned(
                struct_name,
                "Missing field marked with #[children]\n\
        Example:\n\
        #[children]\n\
        children: Scene,",
            ));
        }

        if events_field.is_none() {
            errors.push(syn::Error::new_spanned(
                struct_name,
                "Missing field marked with #[events]\n\
        Example:\n\
        #[events]\n\
        events: EventReceiver,",
            ));
        }

        let combined = errors
            .into_iter()
            .map(|e| e.to_compile_error())
            .collect::<proc_macro2::TokenStream>();

        return TokenStream::from(combined);
    }

    let transform = transform_field.unwrap();
    let children = children_field.unwrap();
    let events = events_field.unwrap();

    let expanded = quote! {

        impl ::maple::nodes::Node for #struct_name
            where
                #struct_name: Clone,
            {
            fn get_transform(&mut self) -> &mut ::maple::components::NodeTransform {
                &mut self.#transform
            }

            fn get_children(&self) -> &::maple::context::Scene {
                &self.#children
            }

            fn get_events(&mut self) -> &mut ::maple::components::EventReceiver {
                &mut self.#events
            }

            fn get_children_mut(&mut self) -> &mut ::maple::context::Scene {
                &mut self.#children
            }
        }
    };

    TokenStream::from(expanded)
}