sword-macros 0.3.0

Structured web framework built on top of tokio ecosystem, providing powerful features for building robust web applications.
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

use proc_macro2::{Span, TokenStream};
use quote::quote;
use syn::{Fields, Ident, Type};

use super::parse::HttpErrorConfig;
use crate::errors;

pub struct HttpErrorCodegen;

impl HttpErrorCodegen {
    pub fn generate_from_arm(
        enum_name: &Ident,
        variant_name: &Ident,
        fields: &Fields,
        config: &HttpErrorConfig,
    ) -> TokenStream {
        if config.transparent {
            return quote! {
                #enum_name::#variant_name(inner) => ::sword::web::JsonResponse::from(inner),
            };
        }

        let pattern = errors::generate_pattern(enum_name, variant_name, fields);
        let tracing_stmt = Self::generate_tracing_stmt(variant_name, config, fields);
        let builder = Self::generate_json_builder(config);

        quote! {
            #pattern => {
                #tracing_stmt
                #builder
            },
        }
    }

    pub fn generate_json_builder(config: &HttpErrorConfig) -> TokenStream {
        let status_code = config.code.as_ref().unwrap().as_u16();

        let message_expr = errors::generate_message_expr(&config.message, || {
            let default_message = config.default_message();
            quote! { #default_message }
        });

        let mut builder = quote! {
            ::sword::web::JsonResponse::status(#status_code).message(#message_expr)
        };

        if let Some(field_name) = &config.error_field {
            let field_ident = Ident::new(field_name, proc_macro2::Span::call_site());
            builder = quote! { #builder.error(&#field_ident) };
        }

        if let Some(field_name) = &config.errors_field {
            let field_ident = Ident::new(field_name, proc_macro2::Span::call_site());
            builder = quote! { #builder.errors(&#field_ident) };
        }

        builder
    }

    pub fn generate_tracing_stmt(
        variant_name: &Ident,
        config: &HttpErrorConfig,
        fields: &Fields,
    ) -> TokenStream {
        let status_code = config.code.as_ref().unwrap().as_u16();

        errors::generate_tracing_stmt(
            variant_name,
            &config.tracing_level,
            fields,
            &Ident::new("status_code", Span::call_site()),
            quote! { #status_code },
            "HTTP error response",
        )
    }

    pub fn generate_variant_fn(variant_name: &Ident, fields: &Fields) -> TokenStream {
        let Fields::Named(named) = fields else {
            return quote! {};
        };

        let fn_name = variant_name;

        let params = named.named.iter().map(|field| {
            let name = &field.ident;
            let ty = &field.ty;

            if Self::is_string_type(ty) {
                quote! { #name: impl Into<String> }
            } else {
                quote! { #name: #ty }
            }
        });

        let field_assignments = named.named.iter().map(|field| {
            let name = &field.ident;
            let ty = &field.ty;

            if Self::is_string_type(ty) {
                quote! { #name: #name.into() }
            } else {
                quote! { #name }
            }
        });

        quote! {
            #[allow(non_snake_case)]
            pub fn #fn_name(#(#params),*) -> Self {
                Self::#variant_name {
                    #(#field_assignments),*
                }
            }
        }
    }

    fn is_string_type(ty: &Type) -> bool {
        if let Type::Path(type_path) = ty
            && let Some(segment) = type_path.path.segments.last()
        {
            return segment.ident == "String";
        }
        false
    }
}