Start implementing range support for NonZero types

validator_derive/src/asserts.rs

@@ -19,7 +19,7 @@ static CUSTOM_ARG_ALLOWED_COPY_TYPES: [&str; 14] = [
     "f64",
 ];
 
-pub static NUMBER_TYPES: [&str; 38] = [
+pub static NUMBER_TYPES: [&str; 71] = [
     "usize",
     "u8",
     "u16",
@@ -34,6 +34,17 @@ pub static NUMBER_TYPES: [&str; 38] = [
     "i128",
     "f32",
     "f64",
+    "NonZeroU8",
+    "NonZeroU16",
+    "NonZeroU32",
+    "NonZeroU64",
+    "NonZeroU128",
+    "NonZeroIsize",
+    "NonZeroI8",
+    "NonZeroI16",
+    "NonZeroI32",
+    "NonZeroI64",
+    "NonZeroI128",
     "Option<usize>",
     "Option<u8>",
     "Option<u16>",
@@ -46,6 +57,17 @@ pub static NUMBER_TYPES: [&str; 38] = [
     "Option<i64>",
     "Option<f32>",
     "Option<f64>",
+    "Option<NonZeroU8>",
+    "Option<NonZeroU16>",
+    "Option<NonZeroU32>",
+    "Option<NonZeroU64>",
+    "Option<NonZeroU128>",
+    "Option<NonZeroIsize>",
+    "Option<NonZeroI8>",
+    "Option<NonZeroI16>",
+    "Option<NonZeroI32>",
+    "Option<NonZeroI64>",
+    "Option<NonZeroI128>",
     "Option<Option<usize>>",
     "Option<Option<u8>>",
     "Option<Option<u16>>",
@@ -58,6 +80,17 @@ pub static NUMBER_TYPES: [&str; 38] = [
     "Option<Option<i64>>",
     "Option<Option<f32>>",
     "Option<Option<f64>>",
+    "Option<Option<NonZeroU8>>",
+    "Option<Option<NonZeroU16>>",
+    "Option<Option<NonZeroU32>>",
+    "Option<Option<NonZeroU64>>",
+    "Option<Option<NonZeroU128>>",
+    "Option<Option<NonZeroIsize>>",
+    "Option<Option<NonZeroI8>>",
+    "Option<Option<NonZeroI16>>",
+    "Option<Option<NonZeroI32>>",
+    "Option<Option<NonZeroI64>>",
+    "Option<Option<NonZeroI128>>",
 ];
 
 pub fn assert_string_type(name: &str, type_name: &str, field_type: &syn::Type) {

validator_derive/src/quoting.rs

@@ -31,11 +31,19 @@ impl FieldQuoter {
         let ident = &self.ident;
 
         if self._type.starts_with("Option<") {
-            quote!(#ident)
+            if !self._type.contains("NonZero") {
+                quote!(#ident)
+            } else {
+                quote!(#ident.get())
+            }
         } else if COW_TYPE.is_match(self._type.as_ref()) {
             quote!(self.#ident.as_ref())
         } else if self._type.starts_with('&') || NUMBER_TYPES.contains(&self._type.as_ref()) {
-            quote!(self.#ident)
+            if !self._type.contains("NonZero") {
+                quote!(self.#ident)
+            } else {
+                quote!(self.#ident.get())
+            }
         } else {
             quote!(&self.#ident)
         }

validator_derive_tests/tests/range.rs

@@ -1,3 +1,5 @@
+use std::num::NonZeroU64;
+
 use validator::{Validate, ValidationErrors};
 
 const MAX_CONST: usize = 10;
@@ -23,6 +25,19 @@ fn can_validate_range_ok() {
     assert!(s.validate().is_ok());
 }
 
+#[test]
+fn can_validate_range_non_zero_ok() {
+    #[derive(Debug, Validate)]
+    struct TestStruct {
+        #[validate(range(min = 5, max = 10))]
+        val: NonZeroU64,
+    }
+
+    let s = TestStruct { val: NonZeroU64::new(6).unwrap() };
+
+    assert!(s.validate().is_ok());
+}
+
 #[test]
 fn can_validate_only_min_ok() {
     #[derive(Debug, Validate)]

validator_derive_tests/tests/run-pass/range.rs

@@ -1,5 +1,7 @@
 use validator::Validate;
 
+use std::num::{NonZeroI32, NonZeroI64, NonZeroU32, NonZeroU64};
+
 #[derive(Validate)]
 struct Test {
     #[validate(range(min = 1, max = 2.2))]
@@ -24,6 +26,18 @@ struct Test {
     s10: Option<u8>,
     #[validate(range(max = 18.0))]
     s11: Option<u8>,
+    #[validate(range(min = 18, max = 22))]
+    s12: NonZeroI32,
+    #[validate(range(min = 18, max = 22))]
+    s13: NonZeroU32,
+    #[validate(range(min = 18.1, max = 22))]
+    s14: NonZeroI32,
+    #[validate(range(min = 18.1, max = 22))]
+    s15: NonZeroU32,
+    #[validate(range(min = 18, max = 22))]
+    s16: Option<NonZeroI64>,
+    #[validate(range(min = 18, max = 22))]
+    s17: Option<NonZeroU64>,
 }
 
 fn main() {}