Merge pull request #144 from greyblake/generics-derive-serde

Make it possible to derive Serialize and Deserialize on Cow<a, str>
greyblake · Jun 3, 2024 · 05adaa1 · 05adaa1
2 parents 67ecaa5 + 28f8820
commit 05adaa1
Show file tree

Hide file tree

Showing 9 changed files with 100 additions and 32 deletions.
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/examples/any_generics/Cargo.toml b/examples/any_generics/Cargo.toml
@@ -6,4 +6,6 @@ edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-nutype = { path = "../../nutype" }
+nutype = { path = "../../nutype", features = ["serde"] }
+serde = "1.0.203"
+serde_json = "1.0.117"
diff --git a/examples/any_generics/src/main.rs b/examples/any_generics/src/main.rs
@@ -21,15 +21,15 @@ struct NotEmpty<T>(Vec<T>);
     Deref,
     Borrow,
     AsRef,
+    Serialize,
+    Deserialize,
     // TODO
     // FromStr,
     // TryFrom,
     // Default,
-    // Serialize,
-    // Deserialize,
     // Arbitrary,
 ))]
-struct Clarabelle<'b>(Cow<'b, str>);
+struct Clarabelle<'a>(Cow<'a, str>);
 
 fn main() {
     {
@@ -44,5 +44,11 @@ fn main() {
     {
         let muu = Clarabelle::new(Cow::Borrowed("Muu"));
         assert_eq!(muu.to_string(), "Muu");
+        // serialize muu with serde_json
+        let json = serde_json::to_string(&muu).unwrap();
+        assert_eq!(json, "\"Muu\"");
+        // deserialize muu with serde_json
+        let same_muu: Clarabelle = serde_json::from_str(&json).unwrap();
+        assert_eq!(muu, same_muu);
     }
 }
diff --git a/nutype_macros/src/any/gen/traits/mod.rs b/nutype_macros/src/any/gen/traits/mod.rs
@@ -177,10 +177,10 @@ fn gen_implemented_traits(
                 }
             },
             AnyIrregularTrait::SerdeSerialize => Ok(
-                gen_impl_trait_serde_serialize(type_name)
+                gen_impl_trait_serde_serialize(type_name, generics)
             ),
             AnyIrregularTrait::SerdeDeserialize => Ok(
-                gen_impl_trait_serde_deserialize(type_name, inner_type, maybe_error_type_name.as_ref())
+                gen_impl_trait_serde_deserialize(type_name, generics, inner_type, maybe_error_type_name.as_ref())
             ),
             AnyIrregularTrait::ArbitraryArbitrary => arbitrary::gen_impl_trait_arbitrary(type_name, inner_type, guard),
         })

diff --git a/nutype_macros/src/common/gen/traits.rs b/nutype_macros/src/common/gen/traits.rs
@@ -238,10 +238,10 @@ pub fn gen_impl_trait_from_str(
     }
 }
 
-pub fn gen_impl_trait_serde_serialize(type_name: &TypeName) -> TokenStream {
+pub fn gen_impl_trait_serde_serialize(type_name: &TypeName, generics: &Generics) -> TokenStream {
     let type_name_str = type_name.to_string();
     quote! {
-        impl ::serde::Serialize for #type_name {
+        impl #generics ::serde::Serialize for #type_name #generics {
             fn serialize<S>(&self, serializer: S) -> ::core::result::Result<S::Ok, S::Error>
             where
                 S: ::serde::Serializer
@@ -254,6 +254,7 @@ pub fn gen_impl_trait_serde_serialize(type_name: &TypeName) -> TokenStream {
 
 pub fn gen_impl_trait_serde_deserialize(
     type_name: &TypeName,
+    type_generics: &Generics,
     inner_type: impl Into<InnerType>,
     maybe_error_type_name: Option<&ErrorTypeName>,
 ) -> TokenStream {
@@ -276,16 +277,23 @@ pub fn gen_impl_trait_serde_deserialize(
     let expecting_str = format!("tuple struct {type_name}");
     let type_name_str = type_name.to_string();
 
+    // type generics + 'de lifetime for Deserialize
+    let all_generics = {
+        let mut all_generics = type_generics.clone();
+        all_generics.params.push(syn::parse_quote!('de));
+        all_generics
+    };
+
     quote! {
-        impl<'de> ::serde::Deserialize<'de> for #type_name {
+        impl #all_generics ::serde::Deserialize<'de> for #type_name #type_generics {
             fn deserialize<D: ::serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
-                struct __Visitor<'de> {
-                    marker: ::std::marker::PhantomData<#type_name>,
+                struct __Visitor #all_generics {
+                    marker: ::std::marker::PhantomData<#type_name #type_generics>,
                     lifetime: ::std::marker::PhantomData<&'de ()>,
                 }
 
-                impl<'de> ::serde::de::Visitor<'de> for __Visitor<'de> {
-                    type Value = #type_name;
+                impl #all_generics ::serde::de::Visitor<'de> for __Visitor #all_generics {
+                    type Value = #type_name #type_generics;
 
                     fn expecting(&self, formatter: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
                         write!(formatter, #expecting_str)

diff --git a/nutype_macros/src/float/gen/traits/mod.rs b/nutype_macros/src/float/gen/traits/mod.rs
@@ -192,9 +192,10 @@ fn gen_implemented_traits<T: ToTokens>(
                     Err(syn::Error::new(span, msg))
                 }
             },
-            FloatIrregularTrait::SerdeSerialize => Ok(gen_impl_trait_serde_serialize(type_name)),
+            FloatIrregularTrait::SerdeSerialize => Ok(gen_impl_trait_serde_serialize(type_name, generics)),
             FloatIrregularTrait::SerdeDeserialize => Ok(gen_impl_trait_serde_deserialize(
                 type_name,
+                generics,
                 inner_type,
                 maybe_error_type_name.as_ref(),
             )),

diff --git a/nutype_macros/src/integer/gen/traits/mod.rs b/nutype_macros/src/integer/gen/traits/mod.rs
@@ -214,9 +214,10 @@ fn gen_implemented_traits<T: ToTokens>(
                     }
                 }
             }
-            IntegerIrregularTrait::SerdeSerialize => Ok(gen_impl_trait_serde_serialize(type_name)),
+            IntegerIrregularTrait::SerdeSerialize => Ok(gen_impl_trait_serde_serialize(type_name, generics)),
             IntegerIrregularTrait::SerdeDeserialize => Ok(gen_impl_trait_serde_deserialize(
                 type_name,
+                generics,
                 inner_type,
                 maybe_error_type_name.as_ref(),
             )),

diff --git a/nutype_macros/src/string/gen/traits/mod.rs b/nutype_macros/src/string/gen/traits/mod.rs
@@ -210,9 +210,10 @@ fn gen_implemented_traits(
                     Err(syn::Error::new(span, msg))
                 }
             },
-            StringIrregularTrait::SerdeSerialize => Ok(gen_impl_trait_serde_serialize(type_name)),
+            StringIrregularTrait::SerdeSerialize => Ok(gen_impl_trait_serde_serialize(type_name, generics)),
             StringIrregularTrait::SerdeDeserialize => Ok(gen_impl_trait_serde_deserialize(
                 type_name,
+                generics,
                 inner_type,
                 maybe_error_type_name.as_ref(),
             )),

diff --git a/test_suite/tests/any.rs b/test_suite/tests/any.rs
@@ -329,6 +329,53 @@ mod traits {
                 assert_eq!(deserialized, place);
             }
         }
+
+        mod with_generics {
+            use super::*;
+
+            // TODO: Uncomment when https://github.com/greyblake/nutype/issues/142 is fixed
+            // #[test]
+            // fn test_generic_with_serde() {
+            //     #[nutype(
+            //         derive(Debug, Serialize, Deserialize),
+            //         validate(predicate = |v| v.is_empty())
+            //     )]
+            //     struct EmptyVec<T>(Vec<T>);
+
+            //     {
+            //         let vec = EmptyVec::new(vec![]);
+            //         let json = serde_json::to_string(&vec).unwrap();
+            //         assert_eq!(json, "[]");
+
+            //         let same_vec: EmptyVec<u8> = serde_json::from_str(&json).unwrap();
+            //         assert_eq!(vec, same_vec);
+            //     }
+
+            //     {
+            //         let vec = EmptyVec::new(vec![1, 2, 3]);
+            //         let err = serde_json::to_string(&vec).unwrap_err();
+            //         assert_eq!(
+            //             err.to_string(),
+            //             "EmptyVec failed the predicate test. Expected valid EmptyVec"
+            //         );
+            //     }
+            // }
+
+            #[test]
+            fn serialize_and_deserialize_cow() {
+                #[nutype(
+                    validate(predicate = |s| s.len() >= 3),
+                    derive(Debug, Serialize, Deserialize, PartialEq)
+                )]
+                struct Clarabelle<'a>(Cow<'a, str>);
+
+                let muu = Clarabelle::new(Cow::Borrowed("Muu")).unwrap();
+                let json = serde_json::to_string(&muu).unwrap();
+                assert_eq!(json, "\"Muu\"");
+                let same_muu: Clarabelle = serde_json::from_str(&json).unwrap();
+                assert_eq!(muu, same_muu);
+            }
+        }
     }
 }