uf-valence-codegen 0.1.2

Valence schema codegen (caller-supplied roots)
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
127
128
129
130
131

//! Setter-time validation snippets merged into mutable builder methods.

use proc_macro2::TokenStream;
use quote::{format_ident, quote};
use syn::{Ident, LitStr};

fn validation_tokens_for_rule(field_ident: &Ident, validation: &str) -> TokenStream {
    match validation {
        "email" => quote! {
            valence::validation::validate_email(&#field_ident)
                .map_err(valence::Error::Validation)?;
        },
        "phone" => quote! {
            valence::validation::validate_phone(&#field_ident)
                .map_err(valence::Error::Validation)?;
        },
        "non_empty" => quote! {
            valence::validation::validate_non_empty(&#field_ident)
                .map_err(valence::Error::Validation)?;
        },
        "non_negative" => quote! {
            valence::validation::validate_non_negative(&#field_ident)
                .map_err(valence::Error::Validation)?;
        },
        "positive" => quote! {
            valence::validation::validate_positive(&#field_ident)
                .map_err(valence::Error::Validation)?;
        },
        v if v.starts_with("min_length:") => {
            let len: usize = v
                .strip_prefix("min_length:")
                .and_then(|s| s.parse().ok())
                .unwrap_or(0);
            quote! {
                valence::validation::validate_min_length(&#field_ident, #len)
                    .map_err(valence::Error::Validation)?;
            }
        }
        v if v.starts_with("max_length:") => {
            let len: usize = v
                .strip_prefix("max_length:")
                .and_then(|s| s.parse().ok())
                .unwrap_or(0);
            quote! {
                valence::validation::validate_max_length(&#field_ident, #len)
                    .map_err(valence::Error::Validation)?;
            }
        }
        v if v.starts_with("min:") => {
            let min: i64 = v
                .strip_prefix("min:")
                .and_then(|s| s.parse().ok())
                .unwrap_or(0);
            quote! {
                valence::validation::validate_min(&#field_ident, #min)
                    .map_err(valence::Error::Validation)?;
            }
        }
        v if v.starts_with("max:") => {
            let max: i64 = v
                .strip_prefix("max:")
                .and_then(|s| s.parse().ok())
                .unwrap_or(0);
            quote! {
                valence::validation::validate_max(&#field_ident, #max)
                    .map_err(valence::Error::Validation)?;
            }
        }
        v if v.starts_with("range:") => range_validation_tokens(field_ident, v),
        v if v.starts_with("enum:") => enum_validation_tokens(field_ident, v),
        v if v.starts_with("pattern:") => {
            let pattern = v.strip_prefix("pattern:").unwrap_or("");
            let pattern_lit = LitStr::new(pattern, proc_macro2::Span::call_site());
            quote! {
                valence::validation::validate_pattern(&#field_ident, #pattern_lit)
                    .map_err(valence::Error::Validation)?;
            }
        }
        v if v.starts_with("fn:") => {
            let fn_name = v.strip_prefix("fn:").unwrap_or("");
            let fn_ident = format_ident!("{}", fn_name);
            quote! {
                #fn_ident(&#field_ident)
                    .map_err(valence::Error::Validation)?;
            }
        }
        _ => TokenStream::new(),
    }
}

fn range_validation_tokens(field_ident: &Ident, v: &str) -> TokenStream {
    let parts: Vec<&str> = v.strip_prefix("range:").unwrap_or("").split(':').collect();
    if parts.len() != 2 {
        return TokenStream::new();
    }
    let (Ok(min), Ok(max)) = (parts[0].parse::<i64>(), parts[1].parse::<i64>()) else {
        return TokenStream::new();
    };
    quote! {
        valence::validation::validate_range(&#field_ident, #min, #max)
            .map_err(valence::Error::Validation)?;
    }
}

fn enum_validation_tokens(field_ident: &Ident, v: &str) -> TokenStream {
    let values: Vec<&str> = v.strip_prefix("enum:").unwrap_or("").split(',').collect();
    let values_lit: Vec<LitStr> = values
        .iter()
        .map(|s| LitStr::new(s, proc_macro2::Span::call_site()))
        .collect();
    quote! {
        valence::validation::validate_enum(&#field_ident, &[#(#values_lit),*])
            .map_err(valence::Error::Validation)?;
    }
}

pub fn generate_validation_code(field_name: &str, validations: &[String]) -> TokenStream {
    let field_ident = format_ident!("{}", field_name);
    let mut validation_checks = Vec::new();

    for validation in validations {
        let validation_code = validation_tokens_for_rule(&field_ident, validation.as_str());
        if !validation_code.is_empty() {
            validation_checks.push(validation_code);
        }
    }

    quote! {
        #(#validation_checks)*
    }
}