diff --git a/validator/Cargo.toml b/validator/Cargo.toml index 152655d7..a61f5eda 100644 --- a/validator/Cargo.toml +++ b/validator/Cargo.toml @@ -14,7 +14,6 @@ rust-version = { workspace = true } [dependencies] url = "2" regex = { version = "1", default-features = false, features = ["std"] } -once_cell = "1.18.0" idna = "1" serde = "1" serde_derive = "1" @@ -26,4 +25,4 @@ indexmap = { version = "2.0.0", features = ["serde"], optional = true } [features] card = ["card-validate"] derive = ["validator_derive"] -derive_nightly_features = ["derive","validator_derive/nightly_features"] \ No newline at end of file +derive_nightly_features = ["derive", "validator_derive/nightly_features"] diff --git a/validator/src/validation/contains.rs b/validator/src/validation/contains.rs index b6cfd5f5..a63350f1 100644 --- a/validator/src/validation/contains.rs +++ b/validator/src/validation/contains.rs @@ -34,7 +34,7 @@ where } } -impl<'cow, T> ValidateContains for Cow<'cow, T> +impl ValidateContains for Cow<'_, T> where T: ToOwned + ?Sized, for<'a> &'a T: ValidateContains, @@ -44,7 +44,7 @@ where } } -impl<'a> ValidateContains for &'a str { +impl ValidateContains for &str { fn validate_contains(&self, needle: &str) -> bool { self.contains(needle) } diff --git a/validator/src/validation/email.rs b/validator/src/validation/email.rs index 0f121f68..7e71caf9 100644 --- a/validator/src/validation/email.rs +++ b/validator/src/validation/email.rs @@ -1,23 +1,22 @@ use idna::domain_to_ascii; -use once_cell::sync::Lazy; use regex::Regex; -use std::borrow::Cow; +use std::{borrow::Cow, sync::LazyLock}; use crate::ValidateIp; // Regex from the specs // https://html.spec.whatwg.org/multipage/forms.html#valid-e-mail-address // It will mark esoteric email addresses like quoted string as invalid -static EMAIL_USER_RE: Lazy = - Lazy::new(|| Regex::new(r"^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+\z").unwrap()); -static EMAIL_DOMAIN_RE: Lazy = Lazy::new(|| { +static EMAIL_USER_RE: LazyLock = + LazyLock::new(|| Regex::new(r"^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+\z").unwrap()); +static EMAIL_DOMAIN_RE: LazyLock = LazyLock::new(|| { Regex::new( r"^[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$" ).unwrap() }); // literal form, ipv4 or ipv6 address (SMTP 4.1.3) -static EMAIL_LITERAL_RE: Lazy = - Lazy::new(|| Regex::new(r"\[([a-fA-F0-9:\.]+)\]\z").unwrap()); +static EMAIL_LITERAL_RE: LazyLock = + LazyLock::new(|| Regex::new(r"\[([a-fA-F0-9:\.]+)\]\z").unwrap()); /// Checks if the domain is a valid domain and if not, check whether it's an IP #[must_use] @@ -109,7 +108,7 @@ where } } -impl<'a> ValidateEmail for &'a str { +impl ValidateEmail for &str { fn as_email_string(&self) -> Option> { Some(Cow::from(*self)) } @@ -209,9 +208,9 @@ mod tests { fn test_validate_email_rfc5321() { // 65 character local part let test = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa@mail.com"; - assert_eq!(test.validate_email(), false); + assert!(!test.validate_email()); // 256 character domain part let test = "a@aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.com"; - assert_eq!(test.validate_email(), false); + assert!(!test.validate_email()); } } diff --git a/validator/src/validation/ip.rs b/validator/src/validation/ip.rs index 3c6e10b9..625c6458 100644 --- a/validator/src/validation/ip.rs +++ b/validator/src/validation/ip.rs @@ -15,11 +15,11 @@ where T: ToString, { fn validate_ipv4(&self) -> bool { - IpAddr::from_str(&self.to_string()).map_or(false, |i| i.is_ipv4()) + IpAddr::from_str(&self.to_string()).is_ok_and(|i| i.is_ipv4()) } fn validate_ipv6(&self) -> bool { - IpAddr::from_str(&self.to_string()).map_or(false, |i| i.is_ipv6()) + IpAddr::from_str(&self.to_string()).is_ok_and(|i| i.is_ipv6()) } fn validate_ip(&self) -> bool { diff --git a/validator/src/validation/regex.rs b/validator/src/validation/regex.rs index fc030b60..0a311ca9 100644 --- a/validator/src/validation/regex.rs +++ b/validator/src/validation/regex.rs @@ -86,7 +86,7 @@ where } } -impl<'cow, T> ValidateRegex for Cow<'cow, T> +impl ValidateRegex for Cow<'_, T> where T: ToOwned + ?Sized, for<'a> &'a T: ValidateRegex, diff --git a/validator_derive/Cargo.toml b/validator_derive/Cargo.toml index 718ed850..36497043 100644 --- a/validator_derive/Cargo.toml +++ b/validator_derive/Cargo.toml @@ -20,7 +20,6 @@ quote = "1" proc-macro2 = "1" proc-macro-error2 = "2" darling = { version = "0.20", features = ["suggestions"] } -once_cell = "1.18.0" [features] -nightly_features = ["proc-macro-error2/nightly"] \ No newline at end of file +nightly_features = ["proc-macro-error2/nightly"] diff --git a/validator_derive/src/lib.rs b/validator_derive/src/lib.rs index 95e85508..44a896e2 100644 --- a/validator_derive/src/lib.rs +++ b/validator_derive/src/lib.rs @@ -263,37 +263,28 @@ impl ValidationData { if let Some(context) = &self.context { // Check if context lifetime is not `'v_a` for segment in &context.segments { - match &segment.arguments { - PathArguments::AngleBracketed(args) => { - for arg in &args.args { - match arg { - syn::GenericArgument::Lifetime(lt) => { - if lt.ident != "v_a" { - abort! { - lt.ident, "Invalid argument reference"; - note = "The lifetime `'{}` is not supported.", lt.ident; - help = "Please use the validator lifetime `'v_a`"; - } - } + if let PathArguments::AngleBracketed(args) = &segment.arguments { + for arg in &args.args { + if let syn::GenericArgument::Lifetime(lt) = arg { + if lt.ident != "v_a" { + abort! { + lt.ident, "Invalid argument reference"; + note = "The lifetime `'{}` is not supported.", lt.ident; + help = "Please use the validator lifetime `'v_a`"; } - _ => (), } } } - _ => (), } } } - match &self.data { - Data::Struct(fields) => { - let original_fields: Vec<&Field> = - fields.fields.iter().map(|f| &f.original).collect(); - for f in &fields.fields { - f.parsed.validate(&self.ident, &original_fields, &f.original); - } + if let Data::Struct(fields) = &self.data { + let original_fields: Vec<&Field> = + fields.fields.iter().map(|f| &f.original).collect(); + for f in &fields.fields { + f.parsed.validate(&self.ident, &original_fields, &f.original); } - _ => (), } Ok(self) diff --git a/validator_derive/src/types.rs b/validator_derive/src/types.rs index 8832fca2..54cbcf1b 100644 --- a/validator_derive/src/types.rs +++ b/validator_derive/src/types.rs @@ -1,4 +1,4 @@ -use once_cell::sync::Lazy; +use std::sync::LazyLock; use darling::util::Override; use darling::{FromField, FromMeta}; @@ -12,7 +12,7 @@ use crate::utils::{get_attr, CrateName}; static OPTIONS_TYPE: [&str; 3] = ["Option|", "std|option|Option|", "core|option|Option|"]; -pub(crate) static NUMBER_TYPES: Lazy> = Lazy::new(|| { +pub(crate) static NUMBER_TYPES: LazyLock> = LazyLock::new(|| { let number_types = [ quote!(usize), quote!(u8), @@ -154,7 +154,7 @@ impl ValidateField { fn find_option(mut count: u8, ty: &syn::Type) -> u8 { if let syn::Type::Path(p) = ty { let idents_of_path = - p.path.segments.iter().into_iter().fold(String::new(), |mut acc, v| { + p.path.segments.iter().fold(String::new(), |mut acc, v| { acc.push_str(&v.ident.to_string()); acc.push('|'); acc diff --git a/validator_derive_tests/Cargo.toml b/validator_derive_tests/Cargo.toml index ced9fdc4..619c4204 100644 --- a/validator_derive_tests/Cargo.toml +++ b/validator_derive_tests/Cargo.toml @@ -20,7 +20,6 @@ serde = { version = "1.0", features = ["derive"] } serde_json = "1.0" trybuild = "1.0" regex = "1" -once_cell = "1.18.0" [dependencies] indexmap = { version = "2", features = ["serde"], optional = true } diff --git a/validator_derive_tests/tests/complex.rs b/validator_derive_tests/tests/complex.rs index 33e9e8f9..a7996c16 100644 --- a/validator_derive_tests/tests/complex.rs +++ b/validator_derive_tests/tests/complex.rs @@ -1,6 +1,5 @@ -use std::{borrow::Cow, collections::HashMap}; +use std::{borrow::Cow, collections::HashMap, sync::LazyLock}; -use once_cell::sync::Lazy; use regex::Regex; use serde::Deserialize; @@ -73,7 +72,7 @@ fn is_fine_with_many_valid_validations() { #[test] fn test_can_validate_option_fields_with_lifetime() { - static RE2: Lazy = Lazy::new(|| Regex::new(r"^[a-z]{2}$").unwrap()); + static RE2: LazyLock = LazyLock::new(|| Regex::new(r"^[a-z]{2}$").unwrap()); #[derive(Debug, Validate)] struct PutStruct<'a> { @@ -117,7 +116,7 @@ fn test_can_validate_option_fields_with_lifetime() { #[test] fn test_can_validate_option_fields_without_lifetime() { - static RE2: Lazy = Lazy::new(|| Regex::new(r"^[a-z]{2}$").unwrap()); + static RE2: LazyLock = LazyLock::new(|| Regex::new(r"^[a-z]{2}$").unwrap()); #[derive(Debug, Validate)] struct PutStruct { diff --git a/validator_derive_tests/tests/regex.rs b/validator_derive_tests/tests/regex.rs index bfef4077..df3a2875 100644 --- a/validator_derive_tests/tests/regex.rs +++ b/validator_derive_tests/tests/regex.rs @@ -1,11 +1,10 @@ -use once_cell::sync::Lazy; use std::cell::OnceCell; use std::sync::{LazyLock, Mutex, OnceLock}; use regex::Regex; use validator::Validate; -static RE2: Lazy = Lazy::new(|| Regex::new(r"^[a-z]{2}$").unwrap()); +static RE2: LazyLock = LazyLock::new(|| Regex::new(r"^[a-z]{2}$").unwrap()); static REGEX_ONCE_LOCK: OnceLock = OnceLock::new(); static REGEX_MUTEX_ONCE_CELL: Mutex> = Mutex::new(OnceCell::new()); diff --git a/validator_derive_tests/tests/run-pass/regex.rs b/validator_derive_tests/tests/run-pass/regex.rs index 6d014551..529f1a57 100644 --- a/validator_derive_tests/tests/run-pass/regex.rs +++ b/validator_derive_tests/tests/run-pass/regex.rs @@ -1,12 +1,8 @@ - -use once_cell::sync::Lazy; use regex::Regex; +use std::sync::LazyLock; use validator::Validate; -static RE2: Lazy = Lazy::new(|| { - Regex::new(r"^[a-z]{2}$").unwrap() -}); - +static RE2: LazyLock = LazyLock::new(|| Regex::new(r"^[a-z]{2}$").unwrap()); #[derive(Validate)] struct Test {