predawn-macro 0.9.0

Macros for predawn
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

mod controller;
mod method;
mod multi_request_media_type;
mod multi_response;
mod multi_response_media_type;
mod multipart;
mod schema_attr;
mod security_scheme;
mod serde_attr;
mod single_response;
mod tag;
mod to_parameters;
mod to_schema;
mod types;
mod util;

use from_attr::FromAttr;
use proc_macro::TokenStream;
use syn::{parse_macro_input, DeriveInput, ItemImpl};

#[proc_macro_attribute]
pub fn controller(attr: TokenStream, item: TokenStream) -> TokenStream {
    let attr = match controller::ControllerAttr::from_tokens(attr.into()) {
        Ok(attr) => attr,
        Err(e) => return e.to_compile_error().into(),
    };
    let item_impl = parse_macro_input!(item as ItemImpl);

    controller::generate(attr, item_impl)
        .unwrap_or_else(|e| e.to_compile_error())
        .into()
}

#[proc_macro_derive(ToSchema, attributes(schema))]
pub fn to_schema(input: TokenStream) -> TokenStream {
    let input = parse_macro_input!(input as DeriveInput);

    to_schema::generate(input)
        .unwrap_or_else(|e| e.to_compile_error())
        .into()
}

#[proc_macro_derive(ToParameters, attributes(schema))]
pub fn to_parameters(input: TokenStream) -> TokenStream {
    let input = parse_macro_input!(input as DeriveInput);

    to_parameters::generate(input)
        .unwrap_or_else(|e| e.to_compile_error())
        .into()
}

#[doc = include_str!("docs/multi_request_media_type.md")]
#[proc_macro_derive(MultiRequestMediaType, attributes(multi_request_media_type))]
pub fn multi_request_media_type(input: TokenStream) -> TokenStream {
    let input = parse_macro_input!(input as DeriveInput);

    multi_request_media_type::generate(input)
        .unwrap_or_else(|e| e.to_compile_error())
        .into()
}

#[doc = include_str!("docs/multi_response_media_type.md")]
#[proc_macro_derive(MultiResponseMediaType, attributes(multi_response_media_type))]
pub fn multi_response_media_type(input: TokenStream) -> TokenStream {
    let input = parse_macro_input!(input as DeriveInput);

    multi_response_media_type::generate(input)
        .unwrap_or_else(|e| e.to_compile_error())
        .into()
}

#[doc = include_str!("docs/single_response.md")]
#[proc_macro_derive(SingleResponse, attributes(single_response, header))]
pub fn single_response(input: TokenStream) -> TokenStream {
    let input = parse_macro_input!(input as DeriveInput);

    single_response::generate(input)
        .unwrap_or_else(|e| e.to_compile_error())
        .into()
}

#[doc = include_str!("docs/multi_response.md")]
#[proc_macro_derive(MultiResponse, attributes(multi_response, status))]
pub fn multi_response(input: TokenStream) -> TokenStream {
    let input = parse_macro_input!(input as DeriveInput);

    multi_response::generate(input)
        .unwrap_or_else(|e| e.to_compile_error())
        .into()
}

#[doc = include_str!("docs/multipart.md")]
#[proc_macro_derive(Multipart, attributes(schema))]
pub fn multipart(input: TokenStream) -> TokenStream {
    let input = parse_macro_input!(input as DeriveInput);

    multipart::generate(input)
        .unwrap_or_else(|e| e.to_compile_error())
        .into()
}

#[doc = include_str!("docs/tag.md")]
#[proc_macro_derive(Tag, attributes(tag))]
pub fn tag(input: TokenStream) -> TokenStream {
    let input = parse_macro_input!(input as DeriveInput);

    tag::generate(input)
        .unwrap_or_else(|e| e.to_compile_error())
        .into()
}

#[doc = include_str!("docs/security_scheme.md")]
#[proc_macro_derive(SecurityScheme, attributes(api_key, http))]
pub fn security_scheme(input: TokenStream) -> TokenStream {
    let input = parse_macro_input!(input as DeriveInput);

    security_scheme::generate(input)
        .unwrap_or_else(|e| e.to_compile_error())
        .into()
}