vertigo-macro 0.11.4

Reactive Real-DOM library with SSR for Rust - macros
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

use proc_macro::TokenStream;
use proc_macro2::TokenStream as TokenStream2;
use quote::quote;
use syn::{Expr, Meta, parse_macro_input, spanned::Spanned};

/// Converts pseudo-javascript expression to DomAccess chain.
pub(crate) fn js_expression(input: TokenStream) -> TokenStream {
    let input = parse_macro_input!(input as Expr);

    // Extract possible #[node_ref] as a base
    let base = extract_base(&input);

    // Generate the output code
    let output = generate_calls(&input, base.is_some());

    let base = base.unwrap_or_else(|| quote! { vertigo::get_driver() });

    TokenStream::from(quote! {
        #base
            .dom_access()
            #output
            .fetch()
    })
}

/// Recursively generate consecutive calls to DomAccess methods based on pseudo-javascript expression.
fn generate_calls(expr: &Expr, have_base: bool) -> proc_macro2::TokenStream {
    match expr {
        Expr::MethodCall(method_call) => {
            let receiver = &method_call.receiver;
            let method = &method_call.method;
            let args = &method_call.args.iter().collect::<Vec<_>>();

            // If the receiver is another method call, property, or path, generate calls recursively
            let receiver_calls = generate_calls(receiver, have_base);

            quote! {
                #receiver_calls.call(stringify!(#method), vec![#((#args).into()),*])
            }
        }
        Expr::Field(field) => {
            let field_name = &field.member;
            let parent_calls = generate_calls(&field.base, have_base);
            quote! {
                #parent_calls.get(stringify!(#field_name))
            }
        }
        Expr::Path(path) => {
            // Handle root before a property ( document.property )
            // or a property after a node reference ( #node_ref.firstChild )
            let path = &path.path;
            let method = if have_base {
                quote! { get }
            } else {
                quote! { root }
            };
            quote! {
                .#method(stringify!(#path))
            }
        }
        Expr::Call(call) => {
            // Handle bare function (add `window` as a root if no base (no node_ref))
            let func = &call.func;
            let args = &call.args.iter().collect::<Vec<_>>();

            let root = (!have_base).then_some(quote! { .root("window") });
            quote! {
                #root
                .call(stringify!(#func), vec![#((#args).into()),*])
            }
        }
        Expr::Group(group) => {
            // Just unwrap group - this happens for node references ( #node_ref.[group] )
            generate_calls(&group.expr, have_base)
        }
        _ => {
            emit_error!(
                expr.span(),
                "Expected an expression resulting in a field, call or method call, got {:#?}",
                expr
            );
            quote! {}
        }
    }
}

// Extracting base is the same for every type.
fn extract_base(input: &Expr) -> Option<TokenStream2> {
    let attrs = match &input {
        Expr::MethodCall(call) => &call.attrs,
        Expr::Field(field) => &field.attrs,
        Expr::Call(call) => &call.attrs,
        Expr::Path(path) => &path.attrs,
        Expr::Group(group) => &group.attrs,
        _ => {
            emit_warning!(input.span(), "Unsupported base {:?}", input);
            return None;
        }
    };

    if let Some(attr) = attrs.first() {
        match &attr.meta {
            Meta::Path(p) => {
                return Some(quote! {
                    #p
                });
            }
            _ => emit_warning!(attr.span(), "Invalid ref, should be #[DomElementRef]"),
        }
    }

    None
}