tier-derive 0.1.17

Derive macros for tier Rust configuration metadata
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

use quote::quote;
use syn::LitStr;

use super::attr::{
    ContainerPathListSpec, ContainerPathSpec, ContainerValidationCheck, TierContainerAttrs,
};

pub(crate) fn container_check_tokens(attrs: &TierContainerAttrs) -> Vec<proc_macro2::TokenStream> {
    attrs
        .checks
        .iter()
        .map(|check| match check {
            ContainerValidationCheck::AtLeastOneOf(paths) => {
                let paths = container_paths_tokens(paths);
                quote! {
                    metadata.push_check(::tier::ValidationCheck::AtLeastOneOf {
                        paths: #paths,
                    });
                }
            }
            ContainerValidationCheck::ExactlyOneOf(paths) => {
                let paths = container_paths_tokens(paths);
                quote! {
                    metadata.push_check(::tier::ValidationCheck::ExactlyOneOf {
                        paths: #paths,
                    });
                }
            }
            ContainerValidationCheck::MutuallyExclusive(paths) => {
                let paths = container_paths_tokens(paths);
                quote! {
                    metadata.push_check(::tier::ValidationCheck::MutuallyExclusive {
                        paths: #paths,
                    });
                }
            }
            ContainerValidationCheck::RequiredWith { path, requires } => {
                let path = container_path_tokens(path);
                let requires = container_paths_tokens(requires);
                quote! {
                    metadata.push_check(::tier::ValidationCheck::RequiredWith {
                        path: #path,
                        requires: #requires,
                    });
                }
            }
            ContainerValidationCheck::RequiredIf {
                path,
                equals,
                requires,
            } => {
                let path = container_path_tokens(path);
                let requires = container_paths_tokens(requires);
                quote! {
                    metadata.push_check(::tier::ValidationCheck::RequiredIf {
                        path: #path,
                        equals: ::tier::ValidationValue::from(#equals),
                        requires: #requires,
                    });
                }
            }
        })
        .collect()
}

fn container_path_tokens(path: &ContainerPathSpec) -> proc_macro2::TokenStream {
    match path {
        ContainerPathSpec::String(path) => {
            let path = LitStr::new(path, proc_macro2::Span::call_site());
            quote! { ::std::string::String::from(#path) }
        }
        ContainerPathSpec::Expr(path) => quote! { ::std::string::String::from(#path) },
    }
}

fn container_paths_tokens(paths: &ContainerPathListSpec) -> proc_macro2::TokenStream {
    match paths {
        ContainerPathListSpec::Strings(paths) => {
            let paths = paths
                .iter()
                .map(|path| LitStr::new(path, proc_macro2::Span::call_site()))
                .collect::<Vec<_>>();
            quote! { ::std::vec![#(::std::string::String::from(#paths)),*] }
        }
        ContainerPathListSpec::Exprs(paths) => {
            quote! { ::std::vec![#(::std::string::String::from(#paths)),*] }
        }
    }
}