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
96
97

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

use super::is_attribute_named;

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

    for attr in attrs {
        if !is_attribute_named(attr, "host") {
            clean_attrs.push(attr.clone());
            continue;
        }

        match attr.parse_args::<LitStr>() {
            Ok(pattern) => {
                if host.pattern.is_some() {
                    errors.push(syn::Error::new_spanned(
                        attr,
                        "controller impl blocks can use at most one #[host] attribute",
                    ));
                } else {
                    host.pattern = Some(pattern);
                }
            }
            Err(_) => errors.push(syn::Error::new_spanned(
                attr,
                "#[host] requires one string literal argument",
            )),
        }
    }

    (clean_attrs, host, errors)
}

pub(in crate::controller) fn take_route_host_attrs(
    attrs: &[Attribute],
) -> (Vec<Attribute>, Option<HostSpec>, Vec<syn::Error>) {
    let mut clean_attrs = Vec::new();
    let mut spec = None;
    let mut errors = Vec::new();

    for attr in attrs {
        if !is_attribute_named(attr, "host") {
            clean_attrs.push(attr.clone());
            continue;
        }

        match attr.parse_args::<LitStr>() {
            Ok(pattern) => {
                if spec.is_some() {
                    errors.push(syn::Error::new_spanned(
                        attr,
                        "route methods can use at most one #[host] attribute",
                    ));
                } else {
                    spec = Some(HostSpec { pattern });
                }
            }
            Err(_) => errors.push(syn::Error::new_spanned(
                attr,
                "#[host] requires one string literal argument",
            )),
        }
    }

    (clean_attrs, spec, errors)
}

#[derive(Default)]
pub(in crate::controller) struct ControllerHostAttrs {
    pattern: Option<LitStr>,
}

impl ControllerHostAttrs {
    pub(in crate::controller) fn tokens(&self) -> Vec<proc_macro2::TokenStream> {
        self.pattern
            .iter()
            .map(|pattern| quote!(with_host(#pattern)))
            .collect()
    }
}

pub(in crate::controller) struct HostSpec {
    pattern: LitStr,
}

impl HostSpec {
    pub(in crate::controller) fn token(&self) -> proc_macro2::TokenStream {
        let pattern = &self.pattern;
        quote!(with_host(#pattern))
    }
}