webforms_derive 0.2.1

Proc-Macro derive implementation for WebForms. Should not depend on this crate, should depend on webforms instead
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

//! All validation code goes here

use crate::validate::{ValidateField, ValidateType};
use proc_macro2::Span;
use quote::quote;
use syn;

pub(crate) fn write(info: &ValidateField, tokens: &mut proc_macro2::TokenStream) {
    let name = &info.field.ident;
    let mut stream = proc_macro2::TokenStream::new();
    for attr in &info.attrs {
        let field = match info.optional {
            true => quote! {
                opt
            },
            false => quote! {
                self.#name
            },
        };

        let refs = match info.optional {
            true => quote! {&},
            false => quote! {},
        };

        stream.extend(match attr {
            ValidateType::StringMin(min) => {
                quote! {
                    if #field.len() < #min {
                        v.push(ValidateError::InputTooShort { field: stringify!(#name), min: #min });
                    }
                }
            },
            ValidateType::StringMax(max) => {
                quote! {
                    if #field.len() > #max {
                        v.push(ValidateError::InputTooLong { field: stringify!(#name), max: #max });
                    }
                }
            },
            ValidateType::ValueMin(min) => {
                quote! {
                    if #field < #refs #min {
                        v.push(ValidateError::TooSmall { field: stringify!(#name), min: #min });
                    }
                }
            },
            ValidateType::ValueMax(max) => {
                quote! {
                    if #field > #refs #max {
                        v.push(ValidateError::TooLarge { field: stringify!(#name), max: #max });
                    }
                }
            },
            ValidateType::Regex(id) => {
                let rid = syn::Ident::new(&id, Span::call_site());
                quote! {
                    if !#rid.is_match(&#field) {
                        v.push(ValidateError::InvalidRegex { field: stringify!(#name) })
                    }
                }
            },
            ValidateType::Email(id) => {
                let rid = syn::Ident::new(&id, Span::call_site());
                quote! {
                    if !#rid.is_match(&#field) {
                        v.push(ValidateError::InvalidEmail { field: stringify!(#name) })
                    }
                }
            },
            ValidateType::Phone(id) => {
                let rid = syn::Ident::new(&id, Span::call_site());
                quote! {
                    if !#rid.is_match(&#field) {
                        v.push(ValidateError::InvalidPhoneNumber { field: stringify!(#name) })
                    }
                }
            },
            ValidateType::Match(ident) => {
                quote! {
                    if #field != self.#ident {
                        v.push(ValidateError::FieldMismatch { field: stringify!(#name) })
                    }
                }
            },
            ValidateType::CompiledRegex(ident) => {
                quote! {
                    if !#ident.is_match(&#field) {
                        v.push(ValidateError::InvalidRegex { field: stringify!(#name) })
                    }
                }
            }
        });
    }

    tokens.extend(match info.optional {
        true => quote! {
            match self.#name.as_ref() {
                Some(opt) => {#stream},
                None => {},
            }
        },
        false => stream,
    });
}