tower-web-macros 0.3.5

Macros for tower-web
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

use resource::{Arg, Attributes, Signature, TyTree};

use proc_macro2::TokenStream;
use syn;

/// Represents a resource route
#[derive(Debug)]
pub(crate) struct Route {
    pub index: usize,

    sig: Signature,

    pub attributes: Attributes,
}

impl Route {
    pub fn new(index: usize, sig: Signature, attributes: Attributes) -> Self {
        Route {
            index,
            sig,
            attributes,
        }
    }

    pub fn ident(&self) -> &syn::Ident {
        self.sig.ident()
    }

    pub fn args(&self) -> &[Arg] {
        self.sig.args()
    }

    pub fn is_async(&self) -> bool {
        self.sig.is_async()
    }

    pub fn template(&self) -> Option<&str> {
        self.attributes.template()
    }

    /// Route builder fn call to add the route definition.
    pub fn build_route(&self, destination: TokenStream) -> TokenStream {
        let method = self.attributes.method_expr();
        let path = self.attributes.path_expr();

        quote! {
            .insert({
                __tw::routing::Route::new(#destination)
                    .method(#method)
                    .path(#path)
            })
        }
    }

    pub fn dispatch_fn(&self) -> TokenStream {
        TyTree::new(self.args())
            .extract_args()
    }

    pub fn dispatch(&self) -> TokenStream {
        // Because the arguments *might* be closed over into a trait object that may or may not be
        // send, the values must be extracted eagerly.
        //
        // To do this, the data is extracted from the futures into a tuple. The tuple is closed
        // over, which no longer has the problem of being `Send`.

        let args_outer = self.sig.args().iter().map(|arg| {
            let index = syn::Index::from(arg.index);
            quote! { __tw::extract::ExtractFuture::extract(args.#index) }
        });

        let args_inner = self.sig.args().iter().map(|arg| {
            let index = syn::Index::from(arg.index);
            quote! { args.#index }
        });

        let body = self.sig.dispatch(
            quote!(self.inner),
            args_inner);

        quote! {
            let args = args.into_inner();
            let args = (#(#args_outer,)*);
            #body
        }
    }

    pub fn handler_args_ty(&self) -> TokenStream {
        TyTree::new(self.args())
            .extract_args_ty()
    }

    /// The response future type
    pub fn future_ty(&self) -> TokenStream {
        self.sig.future_ty()
    }
}