serde_valid_derive 0.16.0-alpha

JSON Schema based validation tool using with serde.
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

use crate::serde::rename::RenameMap;
use crate::types::{Field, SingleIdentPath};
use crate::validate::array::{
    extract_array_max_items_validator, extract_array_min_items_validator,
};
use crate::validate::common::{CustomMessageToken, MetaNameValueValidation};
use crate::validate::numeric::{
    extract_numeric_exclusive_maximum_validator, extract_numeric_exclusive_minimum_validator,
    extract_numeric_maximum_validator, extract_numeric_minimum_validator,
    extract_numeric_multiple_of_validator,
};
use crate::validate::object::{
    extract_object_max_properties_validator, extract_object_min_properties_validator,
};
use crate::validate::string::{
    extract_string_max_length_validator, extract_string_min_length_validator,
    extract_string_pattern_validator,
};
use crate::validate::Validator;
use std::str::FromStr;

pub fn extract_validator_from_nested_meta_name_value(
    field: &impl Field,
    _attribute: &syn::Attribute,
    syn::MetaNameValue {
        path: validation_name,
        lit: validation_value,
        ..
    }: &syn::MetaNameValue,
    custom_message: CustomMessageToken,
    rename_map: &RenameMap,
) -> Result<Validator, crate::Errors> {
    let validation_name_ident = SingleIdentPath::new(validation_name).ident();
    match MetaNameValueValidation::from_str(&validation_name_ident.to_string()) {
        Ok(MetaNameValueValidation::Minimum) => {
            extract_numeric_minimum_validator(field, validation_value, custom_message, rename_map)
        }
        Ok(MetaNameValueValidation::Maximum) => {
            extract_numeric_maximum_validator(field, validation_value, custom_message, rename_map)
        }
        Ok(MetaNameValueValidation::ExclusiveMinimum) => {
            extract_numeric_exclusive_minimum_validator(
                field,
                validation_value,
                custom_message,
                rename_map,
            )
        }
        Ok(MetaNameValueValidation::ExclusiveMaximum) => {
            extract_numeric_exclusive_maximum_validator(
                field,
                validation_value,
                custom_message,
                rename_map,
            )
        }
        Ok(MetaNameValueValidation::MinLength) => {
            extract_string_min_length_validator(field, validation_value, custom_message, rename_map)
        }
        Ok(MetaNameValueValidation::MaxLength) => {
            extract_string_max_length_validator(field, validation_value, custom_message, rename_map)
        }
        Ok(MetaNameValueValidation::MinItems) => {
            extract_array_min_items_validator(field, validation_value, custom_message, rename_map)
        }
        Ok(MetaNameValueValidation::MaxItems) => {
            extract_array_max_items_validator(field, validation_value, custom_message, rename_map)
        }
        Ok(MetaNameValueValidation::MinProperties) => extract_object_min_properties_validator(
            field,
            validation_value,
            custom_message,
            rename_map,
        ),
        Ok(MetaNameValueValidation::MaxProperties) => extract_object_max_properties_validator(
            field,
            validation_value,
            custom_message,
            rename_map,
        ),
        Ok(MetaNameValueValidation::MultipleOf) => extract_numeric_multiple_of_validator(
            field,
            validation_value,
            custom_message,
            rename_map,
        ),
        Ok(MetaNameValueValidation::Pattern) => {
            extract_string_pattern_validator(field, validation_value, custom_message, rename_map)
        }
        Err(unknown) => Err(vec![crate::Error::validate_unknown_type(
            validation_name,
            &unknown,
            &MetaNameValueValidation::iter()
                .map(|x| x.name())
                .collect::<Vec<_>>(),
        )]),
    }
}