errorx-macros 0.0.1

macros for the errorx crate.
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
121
122
123
124
125
126

use quote::{format_ident, quote};

pub fn render(input: &syn::DeriveInput, data: &syn::DataEnum) -> proc_macro2::TokenStream {
    let name = &input.ident;
    let variants = data
        .variants
        .iter()
        .map(|variant| {
            let span = proc_macro2::Span::mixed_site();
            let variant_ident = &variant.ident;
            let variant_attr = &variant
                .attrs
                .iter()
                .find(|attribute| attribute.path().is_ident("error"));

            let variant_params = match variant_attr {
                None => None,
                Some(attr) => match attr.parse_args::<crate::Params>() {
                    Err(err) => return err.to_compile_error(),
                    Ok(v) => Some(v),
                },
            };

            let (is_empty, variant_fields_inner, variant_fields_outer) = match &variant.fields {
                syn::Fields::Unit => (true, quote!(), quote!()),
                syn::Fields::Named(fields) => {
                    let inner = fields
                        .named
                        .iter()
                        .map(|field| {
                            let field_ident = &field.ident;
                            quote!(#field_ident)
                        })
                        .collect::<Vec<_>>();

                    (
                        inner.is_empty(),
                        quote!(#(#inner = #inner, )*),
                        quote!({ #(#inner, )* }),
                    )
                }
                syn::Fields::Unnamed(fields) => {
                    let inner = fields
                        .unnamed
                        .iter()
                        .enumerate()
                        .map(|(i, _)| {
                            let field_ident = format_ident!("p{}", i);
                            quote!(#field_ident)
                        })
                        .collect::<Vec<_>>();

                    (
                        inner.is_empty(),
                        quote!(#(#inner, )*),
                        quote!((#(#inner, )*)),
                    )
                }
            };

            let variant_error_name = match &variant_params {
                None => quote!(stringify!(#variant_ident)),
                Some(p) => match &p.name {
                    None => quote!(stringify!(#variant_ident)),
                    Some(v) => quote!(&#v),
                },
            };

            let variant_error_code = match &variant_params {
                None => quote!(None),
                Some(p) => match &p.code {
                    None => quote!(None),
                    Some(v) => quote!(Some(#v)),
                },
            };

            let variant_error_message = match &variant_params {
                None => quote!(Option::<String>::None),
                Some(p) => match &p.message {
                    None => quote!(Option::<String>::None),
                    Some(v) => {
                        let literal = syn::LitStr::new(v, span);

                        if is_empty {
                            quote!(Some(format!(#literal)));
                        }

                        quote!(Some(format!(#literal, #variant_fields_inner)))
                    }
                },
            };

            let variant_error = quote! {
                let mut builder = ::errorx::Error::new()
                    .with_path(&String::from(module_path!()))
                    .with_name(#variant_error_name);

                if let Some(code) = #variant_error_code {
                    builder = builder.with_code(code);
                }

                if let Some(message) = #variant_error_message {
                    builder = builder.with_message_string(message.clone());
                }

                builder.build()
            };

            quote! {
                Self::#variant_ident #variant_fields_outer => {
                    #variant_error
                }
            }
        })
        .collect::<Vec<_>>();

    return quote! {
        impl ::errorx::ToError for #name {
            fn to_error(&self) -> ::errorx::Error {
                return match self {
                    #(#variants,)*
                };
            }
        }
    };
}