prost-protovalidate-build 0.4.0

Build-time code generator for zero-cost Protocol Buffer validation using buf.validate rules
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

//! Enum rule code generation.

use proc_macro2::TokenStream;
use quote::quote;

use prost_protovalidate_types::EnumRules;

/// Generate enum validation checks.
///
/// `defined_values` contains the `i32` numbers of every value declared in
/// the enum descriptor. When `rules.defined_only` is true a membership
/// check against this set is emitted.
pub(crate) fn generate(
    rules: &EnumRules,
    value_access: &TokenStream,
    proto_name: &str,
    defined_values: &[i32],
) -> Vec<TokenStream> {
    let mut checks = Vec::new();

    // Const (prost represents enum fields as i32)
    if let Some(c) = rules.r#const {
        let msg = format!("must equal {c}");
        checks.push(quote! {
            if #value_access != #c {
                violations.push(::prost_protovalidate::Violation::new(
                    #proto_name, "enum.const", #msg,
                ));
            }
        });
    }

    // defined_only: value must be one of the declared enum numbers
    if rules.defined_only == Some(true) && !defined_values.is_empty() {
        checks.push(quote! {
            if ![#(#defined_values),*].contains(&#value_access) {
                violations.push(::prost_protovalidate::Violation::new(
                    #proto_name, "enum.defined_only", "value must be one of the defined enum values",
                ));
            }
        });
    }

    // In — sort to match the deterministic runtime format.
    if !rules.r#in.is_empty() {
        let mut sorted: Vec<i32> = rules.r#in.clone();
        sorted.sort_unstable();
        let vals = sorted;
        checks.push(quote! {
            if ![#(#vals),*].contains(&#value_access) {
                violations.push(::prost_protovalidate::Violation::new(
                    #proto_name, "enum.in", format!("must be in list {:?}", &[#(#vals),*]),
                ));
            }
        });
    }

    // Not-in — same sorted format.
    if !rules.not_in.is_empty() {
        let mut sorted: Vec<i32> = rules.not_in.clone();
        sorted.sort_unstable();
        let vals = sorted;
        checks.push(quote! {
            if [#(#vals),*].contains(&#value_access) {
                violations.push(::prost_protovalidate::Violation::new(
                    #proto_name, "enum.not_in", format!("must not be in list {:?}", &[#(#vals),*]),
                ));
            }
        });
    }

    checks
}