a3s-boot-macros 0.1.2

Attribute macros for a3s-boot
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

use quote::quote;
use syn::{Attribute, LitStr};

use crate::openapi::{
    ApiExtensionArgs, ApiExtraModelArgs, AttrKind as OpenApiAttrKind, RouteSpec as RouteOpenApiSpec,
};

pub(in crate::controller) fn take_controller_openapi_attrs(
    attrs: &[Attribute],
) -> (Vec<Attribute>, ControllerOpenApiAttrs, Vec<syn::Error>) {
    let mut clean_attrs = Vec::new();
    let mut openapi = ControllerOpenApiAttrs::default();
    let mut errors = Vec::new();

    for attr in attrs {
        let Some(kind) = OpenApiAttrKind::from_attribute(attr) else {
            clean_attrs.push(attr.clone());
            continue;
        };

        match kind {
            OpenApiAttrKind::Tag => match attr.parse_args::<LitStr>() {
                Ok(tag) => openapi.tags.push(tag),
                Err(error) => errors.push(error),
            },
            OpenApiAttrKind::ApiExtraModel => match attr.parse_args::<ApiExtraModelArgs>() {
                Ok(extra_model) => openapi.extra_models.push(extra_model),
                Err(error) => errors.push(error),
            },
            OpenApiAttrKind::ApiExtension => match attr.parse_args::<ApiExtensionArgs>() {
                Ok(extension) => openapi.extensions.push(extension),
                Err(error) => errors.push(error),
            },
            OpenApiAttrKind::HideFromOpenApi => {
                if let Err(error) = crate::expect_no_extractor_args(attr, "hide_from_openapi") {
                    errors.push(error);
                } else {
                    openapi.hidden = true;
                }
            }
            _ => errors.push(syn::Error::new_spanned(
                attr,
                "only #[tag(\"name\")], #[api_extra_model(...)], #[api_extension(...)], and #[hide_from_openapi] are supported on #[controller] impl blocks",
            )),
        }
    }

    (clean_attrs, openapi, errors)
}

pub(in crate::controller) fn take_route_openapi_attrs(
    attrs: &[Attribute],
) -> (Vec<Attribute>, Vec<RouteOpenApiSpec>, Vec<syn::Error>) {
    let mut clean_attrs = Vec::new();
    let mut specs = Vec::new();
    let mut errors = Vec::new();

    for attr in attrs {
        let Some(kind) = OpenApiAttrKind::from_attribute(attr) else {
            clean_attrs.push(attr.clone());
            continue;
        };

        match kind.parse_route_spec(attr) {
            Ok(spec) => specs.push(spec),
            Err(error) => errors.push(error),
        }
    }

    (clean_attrs, specs, errors)
}

#[derive(Default)]
pub(in crate::controller) struct ControllerOpenApiAttrs {
    tags: Vec<LitStr>,
    extra_models: Vec<ApiExtraModelArgs>,
    extensions: Vec<ApiExtensionArgs>,
    hidden: bool,
}

impl ControllerOpenApiAttrs {
    pub(in crate::controller) fn tokens(&self) -> Vec<proc_macro2::TokenStream> {
        let mut tokens = self
            .tags
            .iter()
            .map(|tag| quote!(with_tag(#tag)))
            .chain(self.extra_models.iter().map(ApiExtraModelArgs::tokens))
            .chain(self.extensions.iter().map(ApiExtensionArgs::tokens))
            .collect::<Vec<_>>();
        if self.hidden {
            tokens.push(quote!(hide_from_openapi()));
        }
        tokens
    }
}