devise_core/
validator.rs

1use crate::{Result, Field, Fields, Variant, Struct, Enum, Input};
2
3type FnOutput = ();
4
5pub trait Validator {
6    trait_method!(validate_input: Input<'_>, input_default);
7    trait_method!(validate_struct: Struct<'_>, struct_default);
8    trait_method!(validate_enum: Enum<'_>, enum_default);
9    trait_method!(validate_variant: Variant<'_>, variant_default);
10    trait_method!(validate_fields: Fields<'_>, fields_default);
11    trait_method!(validate_field: Field<'_>, field_default);
12}
13
14impl<V: Validator + ?Sized> Validator for &mut V {
15    trait_forward!(<V as Validator>::validate_input: Input<'_>);
16    trait_forward!(<V as Validator>::validate_struct: Struct<'_>);
17    trait_forward!(<V as Validator>::validate_enum: Enum<'_>);
18    trait_forward!(<V as Validator>::validate_variant: Variant<'_>);
19    trait_forward!(<V as Validator>::validate_fields: Fields<'_>);
20    trait_forward!(<V as Validator>::validate_field: Field<'_>);
21}
22
23#[derive(Default)]
24pub struct ValidatorBuild {
25    input_validator: function!(Input<'_>),
26    struct_validator: function!(Struct<'_>),
27    enum_validator: function!(Enum<'_>),
28    variant_validator: function!(Variant<'_>),
29    fields_validator: function!(Fields<'_>),
30    field_validator: function!(Field<'_>),
31}
32
33impl ValidatorBuild {
34    pub fn new() -> Self {
35        ValidatorBuild::default()
36    }
37
38    try_builder!(input_validate: Input<'_>, input_validator);
39    try_builder!(struct_validate: Struct<'_>, struct_validator);
40    try_builder!(enum_validate: Enum<'_>, enum_validator);
41    try_builder!(variant_validate: Variant<'_>, variant_validator);
42    try_builder!(fields_validate: Fields<'_>, fields_validator);
43    try_builder!(field_validate: Field<'_>, field_validator);
44}
45
46impl Validator for ValidatorBuild {
47    builder_def_fwd!(validate_input: Input<'_>, input_validator, input_default);
48    builder_def_fwd!(validate_struct: Struct<'_>, struct_validator, struct_default);
49    builder_def_fwd!(validate_enum: Enum<'_>, enum_validator, enum_default);
50    builder_def_fwd!(validate_variant: Variant<'_>, variant_validator, variant_default);
51    builder_def_fwd!(validate_fields: Fields<'_>, fields_validator, fields_default);
52    builder_def_fwd!(validate_field: Field<'_>, field_validator, field_default);
53}
54
55pub fn input_default<V: Validator>(mut validator: V, value: Input<'_>) -> Result<()> {
56    match value {
57        Input::Struct(v) => validator.validate_struct(v),
58        Input::Enum(v) => validator.validate_enum(v),
59        Input::Union(_) => unimplemented!("union validation is unimplemented")
60    }
61}
62
63pub fn enum_default<V: Validator>(mut validator: V, value: Enum) -> Result<()> {
64    for v in value.variants() {
65        validator.validate_variant(v)?;
66    }
67
68    Ok(())
69}
70
71pub fn struct_default<V: Validator>(mut validator: V, value: Struct) -> Result<()> {
72    validator.validate_fields(value.fields())
73}
74
75pub fn variant_default<V: Validator>(mut validator: V, value: Variant) -> Result<()> {
76    validator.validate_fields(value.fields())
77}
78
79pub fn fields_default<V: Validator>(mut validator: V, value: Fields) -> Result<()> {
80    for f in value.iter() {
81        validator.validate_field(f)?;
82    }
83
84    Ok(())
85}
86
87pub fn field_default<V: Validator>(_: V, _: Field) -> Result<()> {
88    Ok(())
89}