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 解析器实现

Download history 53/week @ 2024-03-24 34/week @ 2024-03-31 54/week @ 2024-04-07 33/week @ 2024-04-14 63/week @ 2024-04-21 48/week @ 2024-04-28 73/week @ 2024-05-05 46/week @ 2024-05-12 36/week @ 2024-05-19 30/week @ 2024-05-26 48/week @ 2024-06-02 75/week @ 2024-06-09 58/week @ 2024-06-16 9/week @ 2024-06-23 42/week @ 2024-06-30 48/week @ 2024-07-07

167 每月下载量

MIT 许可证

96KB
2K SLoC

Crates.io

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-2.0 许可证定义的,你有意提交的任何贡献,都应作为上述双重许可,没有附加条款或条件。

依赖项

33–45MB
~573K SLoC