tackt-macros 0.1.0

HTTP router
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

use proc_macro2::TokenStream;
use syn::spanned::Spanned;
use syn::Error;
use syn::FnArg;
use syn::ItemFn;
use syn::Result;

use crate::spec::Spec;
use crate::structure::expand_impl;
use crate::structure::expand_struct;

pub(crate) fn route(spec: TokenStream, item: TokenStream) -> Result<TokenStream> {
    let spec = syn::parse2::<Spec>(spec)?;
    let item = syn::parse2::<ItemFn>(item)?;

    if item.sig.inputs.len() < spec.num_param() + 1 {
        return Err(Error::new(
            item.sig.paren_token.span,
            "insufficient number of argument",
        ));
    }

    let skip = item.sig.inputs.len() - spec.num_param();
    item.sig
        .inputs
        .iter()
        .skip(skip)
        .try_for_each(|arg| match arg {
            FnArg::Receiver(arg) => {
                Err(Error::new(arg.span(), "receiver cannot become route param"))
            }
            FnArg::Typed(arg) => match arg.pat.as_ref() {
                syn::Pat::Ident(..) => Ok(()),
                _ => Err(Error::new(arg.pat.span(), "argument must be an identifier")),
            },
        })?;

    for param in spec.iter_param() {
        if !item.sig.inputs.iter().skip(skip).any(|arg| match arg {
            FnArg::Typed(pat) => match pat.pat.as_ref() {
                syn::Pat::Ident(pat) => &pat.ident == param,
                _ => false,
            },
            _ => false,
        }) {
            return Err(Error::new(
                param.span(),
                format!(r#""{}" does not exists in function argument"#, param),
            ));
        }
    }

    let struct_ = expand_struct(&item, skip)?;
    let impl_ = expand_impl(&struct_, &spec)?;
    let fn_ = expand_fn(&item, &spec, skip);

    Ok(quote::quote! {
        #struct_

        #impl_

        #fn_
    })
}

fn expand_fn(item: &ItemFn, spec: &Spec, skip: usize) -> TokenStream {
    let attrs = &item.attrs;
    let vis = &item.vis;
    let constness = &item.sig.constness;
    let asyncness = &item.sig.asyncness;
    let unsafety = &item.sig.unsafety;
    let name = &item.sig.ident;
    let generics = &item.sig.generics;

    let output = &item.sig.output;
    let where_ = &item.sig.generics.where_clause;
    let block = &item.block;

    let reserved_inputs = item.sig.inputs.iter().take(skip);
    let params = spec.iter_param();

    quote::quote! {
        #(#attrs)*
        #vis #constness #asyncness #unsafety fn #name #generics (
            #(#reserved_inputs)*,
            #name { #(#params),* }: #name,
        ) #output
        #where_
        #block
    }
}