Merge pull request #132 from greyblake/arbitrary-string

Allow deriving Arbitrary for String types

Author: greyblake

CHANGELOG.md

@@ -4,6 +4,7 @@
 * Support integration with [`arbitrary`](https://crates.io/crates/arbitrary) crate (see `arbitrary` feature).
   * Support `Arbitrary` for integer types
   * Support `Arbitrary` for float types
+  * Support `Arbitrary` for string inner types
   * Support `Arbitrary` for any inner types
 * Ability to specify boundaries (`greater`, `greater_or_equal`, `less`, `less_or_equal`, `len_char_min`, `len_char_max`) with expressions or named constants.
 * Add `#[inline]` attribute to trivial functions

Cargo.lock

@@ -19,4 +19,5 @@ members = [
     "examples/serde_complex",
     "examples/string_bounded_len",
     "examples/string_regex_email",
+    "examples/string_arbitrary",
 ]

Cargo.toml

@@ -14,3 +14,4 @@ regex = "*"
 once_cell = "*"
 lazy_static = "*"
 ron = "0.8.1"
+arbitrary = "1.3.2"

dummy/Cargo.toml

@@ -0,0 +1,11 @@
+[package]
+name = "string_arbitrary"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+arbitrary = "1.3.2"
+arbtest = "0.3.1"
+nutype = { path = "../../nutype", features = ["arbitrary"] }

examples/string_arbitrary/Cargo.toml

@@ -0,0 +1,81 @@
+use arbitrary::Arbitrary;
+use arbtest::arbtest;
+use nutype::nutype;
+
+fn main() {
+    should_generate_arbitrary_string_without_validation_with_respect_to_sanitizers();
+    should_generate_arbitrary_string_with_trim_and_min_len_validation();
+    should_respect_not_empty_validation_with_trim();
+    should_respect_not_empty_validation_without_trim();
+    should_respect_len_char_max();
+    should_respec_both_len_boundaries();
+}
+
+fn should_generate_arbitrary_string_without_validation_with_respect_to_sanitizers() {
+    #[nutype(sanitize(lowercase), derive(Arbitrary, Debug))]
+    struct LowercaseString(String);
+
+    arbtest(|u| {
+        let s = LowercaseString::arbitrary(u)?.into_inner();
+        assert_eq!(s.to_lowercase(), s);
+        Ok(())
+    });
+}
+
+fn should_generate_arbitrary_string_with_trim_and_min_len_validation() {
+    #[nutype(sanitize(trim), validate(len_char_min = 3), derive(Arbitrary, Debug))]
+    struct Name(String);
+
+    arbtest(|u| {
+        let s = Name::arbitrary(u)?.into_inner();
+        assert_eq!(s.trim(), s);
+        assert!(s.chars().count() >= 3);
+        Ok(())
+    });
+}
+
+fn should_respect_not_empty_validation_with_trim() {
+    #[nutype(sanitize(trim), validate(not_empty), derive(Arbitrary, Debug))]
+    struct Title(String);
+
+    arbtest(|u| {
+        let s = Title::arbitrary(u)?.into_inner();
+        assert_eq!(s.trim(), s);
+        assert!(!s.is_empty());
+        Ok(())
+    });
+}
+
+fn should_respect_not_empty_validation_without_trim() {
+    #[nutype(validate(not_empty), derive(Arbitrary, Debug))]
+    struct Description(String);
+
+    arbtest(|u| {
+        let s = Description::arbitrary(u)?.into_inner();
+        assert!(!s.is_empty());
+        Ok(())
+    });
+}
+
+fn should_respect_len_char_max() {
+    #[nutype(validate(len_char_max = 7), derive(Arbitrary, Debug))]
+    struct Text(String);
+
+    arbtest(|u| {
+        let s = Text::arbitrary(u)?.into_inner();
+        assert!(s.chars().count() <= 7);
+        Ok(())
+    });
+}
+
+fn should_respec_both_len_boundaries() {
+    #[nutype(validate(len_char_min = 3, len_char_max = 5), derive(Arbitrary, Debug))]
+    struct Text(String);
+
+    arbtest(|u| {
+        let s = Text::arbitrary(u)?.into_inner();
+        assert!(s.chars().count() >= 3);
+        assert!(s.chars().count() <= 5);
+        Ok(())
+    });
+}

examples/string_arbitrary/src/main.rs

@@ -162,19 +162,17 @@ fn gen_implemented_traits(
             AnyIrregularTrait::TryFrom => Ok(
                 gen_impl_trait_try_from(type_name, inner_type, maybe_error_type_name.as_ref())
             ),
-            AnyIrregularTrait::Default => Ok(
-                match maybe_default_value {
-                    Some(ref default_value) => {
-                        let has_validation = maybe_error_type_name.is_some();
-                        gen_impl_trait_default(type_name, default_value, has_validation)
-                    }
-                    None => {
-                        panic!(
-                            "Default trait is derived for type {type_name}, but `default = ` is missing"
-                        );
-                    }
+            AnyIrregularTrait::Default => match maybe_default_value {
+                Some(ref default_value) => {
+                    let has_validation = maybe_error_type_name.is_some();
+                    Ok(gen_impl_trait_default(type_name, default_value, has_validation))
                 }
-            ),
+                None => {
+                    let span = proc_macro2::Span::call_site();
+                    let msg = format!("Trait `Default` is derived for type {type_name}, but `default = ` parameter is missing in #[nutype] macro");
+                    Err(syn::Error::new(span, msg))
+                }
+            },
             AnyIrregularTrait::SerdeSerialize => Ok(
                 gen_impl_trait_serde_serialize(type_name)
             ),

nutype_macros/src/any/gen/traits/mod.rs

@@ -1,4 +1,5 @@
 use kinded::Kinded;
+use std::ops::Add;
 use std::{collections::HashSet, fmt::Debug};
 
 use proc_macro2::{Span, TokenStream};
@@ -219,7 +220,7 @@ pub struct Attributes<G, DT> {
 
 /// Represents a value known at compile time or an expression.
 /// Knowing value at compile time allows to run some extra validations to prevent potential errors.
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub enum ValueOrExpr<T> {
     Value(T),
     Expr(syn::Expr),
@@ -238,6 +239,25 @@ impl<T: ToTokens> ToTokens for ValueOrExpr<T> {
     }
 }
 
+impl<T> Add<T> for ValueOrExpr<T>
+where
+    T: Add<T, Output = T> + ToTokens,
+{
+    type Output = ValueOrExpr<T>;
+
+    fn add(self, rhs: T) -> Self::Output {
+        match self {
+            Self::Value(lhs) => Self::Value(lhs + rhs),
+            Self::Expr(lhs) => {
+                let token_stream = quote!(#lhs + #rhs);
+                let expr = syn::parse2(token_stream)
+                    .expect("Failed to parse token stream in ValueOrExpr::add");
+                Self::Expr(expr)
+            }
+        }
+    }
+}
+
 impl<Sanitizer, Validator> Guard<Sanitizer, Validator> {
     pub fn has_validation(&self) -> bool {
         match self {

nutype_macros/src/common/models.rs

@@ -179,14 +179,15 @@ impl GenerateNewtype for StringNewtype {
         maybe_error_type_name: Option<ErrorTypeName>,
         traits: HashSet<Self::TypedTrait>,
         maybe_default_value: Option<syn::Expr>,
-        _guard: &StringGuard,
+        guard: &StringGuard,
     ) -> Result<GeneratedTraits, syn::Error> {
-        Ok(gen_traits(
+        gen_traits(
             type_name,
             maybe_error_type_name,
             traits,
             maybe_default_value,
-        ))
+            guard,
+        )
     }
 
     fn gen_tests(