10个版本

0.3.1	2022年7月28日
0.3.0	2022年4月7日
0.2.0	2021年6月1日
0.1.6	2021年2月24日
0.1.5	2021年1月26日

#1079 in 解析器实现

167 每月下载量

MIT 许可证

96KB
2K SLoC

validr

validr = "0.3.1"

Validr 允许您在反序列化后修改您的有效负载，然后使用您提供的规则对其进行验证。

用法

#[macro_use]
use validr::*;
use serde::Deserialize;
use actix_web::{web, HttpResponse, ResponseError};


#[derive(Clone, Deserialize, Debug)]
struct TestObj {
    pub name: Option<String>,
    pub email: Option<String>,
    pub age: Option<u8>
}

impl Validation for TestObj {
    fn modifiers(&self) -> Vec<Modifier<Self>> {
        vec![
            modifier_trim!(name),
            modifier_capitalize!(name),
            modifier_lowercase!(email),
        ]
    }

    fn rules(&self) -> Vec<Rule<Self>> {
        vec![
            rule_required!(name),
            rule_required!(email),
            rule_email!(email),
        ]
    }
}

async fn test_actix_route_handler(test: web::Json<TestObj>) -> HttpResponse {
    match test.into_inner().validate() {
        Ok(item) => {
            println!("This is your data validated and modified: {:?}", item);
            HttpResponse::Ok().body("Validation passed!")
        },
        Err(e) => e.error_response(),
    }
}

验证规则

有一些预定义的规则以宏的形式提供给您，以简化验证过程。

必需

对于 Option<T: ToString + Clone> 会检查字段是否存在对于 String 会检查它是否为空。

#[macro_use]
use validr::*;
#[derive(serde::Deserialize, Clone)]
struct Test {
    field_name_on_self: Option<String>,
}

impl Validation for Test {
    fn rules(&self) -> Vec<Rule<Self>> {
        vec![rule_required!(field_name_on_self)]
    }
}

接受

此规则适用于 Option<bool>，其中检查字段是否存在且为 true，并且它适用于 bool，其中检查它是否为 true。

#[macro_use]
use validr::*;
#[derive(serde::Deserialize, Clone)]
struct Test {
    field_name_on_self: Option<bool>,
}

impl Validation for Test {
    fn rules(&self) -> Vec<Rule<Self>> {
        vec![rule_accepted!(field_name_on_self)]
    }
}

电子邮件

对于 Option<T: ToString + Clone> 会检查字段是否存在且为有效的电子邮件对于 String 会检查它是否为有效的电子邮件。

#[macro_use]
use validr::*;
#[derive(serde::Deserialize, Clone)]
struct Test {
    field_name_on_self: Option<String>,
}

impl Validation for Test {
    fn rules(&self) -> Vec<Rule<Self>> {
        vec![rule_email!(field_name_on_self)]
    }
}

URL

对于 Option<T: ToString + Clone> 会检查字段是否存在且为有效的 URL 对于 String 会检查它是否为有效的 URL。

#[macro_use] use validr::*; #[derive(serde::Deserialize, Clone)] struct Test { field_name_on_self: Option<String>, } impl Validation for Test { fn rules(&self) -> Vec<Rule<Self>> { vec![rule_url!(field_name_on_self)] } } 电话对于 Option<T: ToString + Clone>，它会检查字段是否存在且是有效的电话号码；对于 String，它会检查是否是有效的电话号码。 #[macro_use] use validr::*; #[derive(serde::Deserialize, Clone)] struct Test { field_name_on_self: Option<String>, } impl Validation for Test { fn rules(&self) -> Vec<Rule<Self>> { vec![rule_phone!(field_name_on_self)] } } 非控制字符对于 Option<T: ToString + Clone>，它会检查字段是否存在且没有控制字符；对于 String，它会检查字段是否有控制字符。 #[macro_use] use validr::*; #[derive(serde::Deserialize, Clone)] struct Test { field_name_on_self: Option<String>, } impl Validation for Test { fn rules(&self) -> Vec<Rule<Self>> { vec![rule_non_control_character!(field_name_on_self)] } } IP 地址对于 Option<T: ToString + Clone>，它会检查字段是否存在且是有效的 IP 地址；对于 String，它会检查是否是有效的 IP 地址。 #[macro_use] use validr::*; #[derive(serde::Deserialize, Clone)] struct Test { field_name_on_self: Option<String>, } impl Validation for Test { fn rules(&self) -> Vec<Rule<Self>> { vec![rule_ip!(field_name_on_self)] } } IP V4 对于 Option<T: ToString + Clone>，它会检查字段是否存在且是有效的 IP V4 地址；对于 String，它会检查是否是有效的 IP V4 地址。 #[macro_use] use validr::*; #[derive(serde::Deserialize, Clone)] struct Test { field_name_on_self: Option<String>, } impl Validation for Test { fn rules(&self) -> Vec<Rule<Self>> { vec![rule_ip_v4!(field_name_on_self)] } } IP V6 对于 Option<T: ToString + Clone>，它会检查字段是否存在且是有效的 IP V6 地址；对于 String，它会检查是否是有效的 IP V6 地址。 #[macro_use] use validr::*; #[derive(serde::Deserialize, Clone)] struct Test { field_name_on_self: Option<String>, } impl Validation for Test { fn rules(&self) -> Vec<Rule<Self>> { vec![rule_ip_v6!(field_name_on_self)] } } 信用卡对于 Option<T: ToString + Clone>，它会检查字段是否存在且是有效的信用卡号码；对于 String，它会检查是否是有效的信用卡号码。 #[macro_use] use validr::*; #[derive(serde::Deserialize, Clone)] struct Test { field_name_on_self: Option<String>, } impl Validation for Test { fn rules(&self) -> Vec<Rule<Self>> { vec![rule_credit_card!(field_name_on_self)] } } 包含对于 Option<T: ToString + Clone>，它会检查字段是否存在且包含指定的 needle；对于 String，它会检查是否包含指定的 needle。 #[macro_use] use validr::*; #[derive(serde::Deserialize, Clone)] struct Test { field_name_on_self: Option<String>, } impl Validation for Test { fn rules(&self) -> Vec<Rule<Self>> { vec![rule_contains!(field_name_on_self, "needle".to_string())] } } 等于验证两个给定的字段名是否相等。 #[macro_use] use validr::*; #[derive(serde::Deserialize, Clone)] struct Test { field_name_on_self: Option<String>, field_name_to_compare_to_on_self: Option<String>, } impl Validation for Test { fn rules(&self) -> Vec<Rule<Self>> { vec![rule_equalt_to!(field_name_on_self, field_name_to_compare_to_on_self)] } } 不等于验证两个给定的字段名是否不相等。 #[macro_use] use validr::*; #[derive(serde::Deserialize, Clone)] struct Test { field_name_on_self: Option<String>, field_name_to_compare_to_on_self: Option<String>, } impl Validation for Test { fn rules(&self) -> Vec<Rule<Self>> { vec![rule_not_equalt_to!(field_name_on_self, field_name_to_compare_to_on_self)] } } 在对于 Option<T: ToString + Clone>，它会检查字段是否存在并将它的值与值列表的值进行匹配；对于 String，它会检查是否在值列表中。 #[macro_use] use validr::*; #[derive(serde::Deserialize, Clone)] struct Test { field_name_on_self: Option<String>, } impl Validation for Test { fn rules(&self) -> Vec<Rule<Self>> { vec![ rule_in!(field_name_on_self, vec![ "allowed_value".to_string(), "another_allowed_value".to_string() ]), ] } } 长度最小对于 Option<T: ToString + Clone>，它将检查字段是否存在并且具有 min 个字符数对于 String，它将检查它是否具有 min 个字符数 #[macro_use] use validr::*; #[derive(serde::Deserialize, Clone)] struct Test { field_name_on_self: Option<String>, } impl Validation for Test { fn rules(&self) -> Vec<Rule<Self>> { vec![rule_length_min!(field_name_on_self, 2)] } } 长度最大对于 Option<T: ToString + Clone>，它将检查字段是否存在并且具有 max 个字符数对于 String，它将检查它是否具有 max 个字符数 #[macro_use] use validr::*; #[derive(serde::Deserialize, Clone)] struct Test { field_name_on_self: Option<String>, } impl Validation for Test { fn rules(&self) -> Vec<Rule<Self>> { vec![rule_length_max!(field_name_on_self, 15)] } } 长度相等对于 Option<T: ToString + Clone>，它将检查字段是否存在并且具有 eq 个字符数对于 String，它将检查它是否具有 eq 个字符数 #[macro_use] use validr::*; #[derive(serde::Deserialize, Clone)] struct Test { field_name_on_self: Option<String>, } impl Validation for Test { fn rules(&self) -> Vec<Rule<Self>> { vec![rule_length_eq!(field_name_on_self, 10)] } } 长度不等对于 Option<T: ToString + Clone>，它将检查字段是否存在并且具有 ne 个字符数对于 String，它将检查它是否具有 ne 个字符数 #[macro_use] use validr::*; #[derive(serde::Deserialize, Clone)] struct Test { field_name_on_self: Option<String>, } impl Validation for Test { fn rules(&self) -> Vec<Rule<Self>> { vec![rule_length_ne!(field_name_on_self, 11)] } } 范围对于 Option<T: Into<f64> + PartialOrd + Clone>，它将检查值是否存在并且处于给定范围内。对于 T: Into<f64>，它将检查值是否在给定范围内 #[macro_use] use validr::*; #[derive(serde::Deserialize, Clone)] struct Test { field_name_on_self: Option<u8>, } impl Validation for Test { fn rules(&self) -> Vec<Rule<Self>> { vec![rule_range!(field_name_on_self, Some(10), Some(15))] } } 自定义验证规则您可以通过不使用提供的宏来生成自己的 Rule::new() 定义来实现自定义验证规则 #[macro_use] use validr::{Validation, error::ValidationError, Rule}; #[derive(serde::Deserialize, Clone)] struct Test { field_name: String, } impl Validation for Test { fn rules(&self) -> Vec<Rule<Self>> { vec![ Rule::new("field_name", |obj: &Self, error: &mut ValidationError| { if obj.field_name != "some_validation_rule".to_string() { error.add("my_custom_error_code"); } }), ] } } 字段修饰符在运行验证规则之前，您可以修改输入数据以按所需方式格式化。包含了一些修饰符，但您当然可以创建一个自定义修饰符以执行任何您想要的操作。修剪对于 Option<String> 它将检查是否存在某个值，并将在该值上运行修剪。对于 String，它将简单地修剪它 #[macro_use] use validr::*; #[derive(serde::Deserialize, Clone)] struct Test { field_name_on_self: Option<String>, } impl Validation for Test { fn modifiers(&self) -> Vec<Modifier<Self>> { vec![modifier_trim!(field_name_on_self)] } } 小写对于 Option<String> 它将检查是否存在某个值，并将在该值上运行小写转换。对于 String，它将简单地将其转换为小写 #[macro_use] use validr::*; #[derive(serde::Deserialize, Clone)] struct Test { field_name_on_self: Option<String>, } impl Validation for Test { fn modifiers(&self) -> Vec<Modifier<Self>> { vec![modifier_lowercase!(field_name_on_self)] } } 大写

对于Option<String>，它将检查是否存在某个值，并对该值运行大写转换。对于String，它将简单地转换为大写。


#[macro_use]
use validr::*;
#[derive(serde::Deserialize, Clone)]
struct Test {
    field_name_on_self: Option<String>,
}

impl Validation for Test {
    fn modifiers(&self) -> Vec<Modifier<Self>> {
        vec![modifier_uppercase!(field_name_on_self)]
    }
}

大写化
对于Option<String>，它将检查是否存在某个值，并对该值运行大写化。对于String，它将简单地转换为大写。

大写化会将字符串的第一个字符转换为大写，其余字符转为小写
#[macro_use]
use validr::*;
#[derive(serde::Deserialize, Clone)]
struct Test {
    field_name_on_self: Option<String>,
}

impl Validation for Test {
    fn modifiers(&self) -> Vec<Modifier<Self>> {
        vec![modifier_capitalize!(field_name_on_self)]
    }
}

自定义修饰符
实现自定义修饰符类似于自定义验证规则，你需要提供一个自定义实现Modifier::new()
#[macro_use]
use validr::*;
#[derive(serde::Deserialize, Clone)]
struct Test {
    field_name_on_self: Option<String>,
}

impl Validation for Test {
    fn modifiers(&self) -> Vec<Modifier<Self>> {
        vec![
            Modifier::new("field_name_on_self", |obj: &mut Self| {
                obj.field_name_on_self = Some("new_value".to_string());
            }),
        ]
    }
}

许可
许可协议为以下之一

Apache License，版本 2.0，(LICENSE-APACHE 或 https://apache.ac.cn/licenses/LICENSE-2.0)
MIT 许可证 (LICENSE-MIT 或 https://open-source.org.cn/licenses/MIT)

任选其一。
贡献
除非你明确声明，否则根据 Apache-2.0 许可证定义的，你有意提交的任何贡献，都应作为上述双重许可，没有附加条款或条件。



依赖项

33–45MB


~573K SLoC



actix-web 4.0

card-validate


futures-util


idna 0.2

lazy_static


phonenumber


regex


serde+serde_derive

serde_json


unic-ucd-common


url