Merge pull request #10 from tomoikey/serde

support serde_json

Author: tomoikey

Cargo.toml

@@ -6,10 +6,15 @@ repository = "https://github.com/tomoikey/refined-type"
 readme = "README.md"
 categories = ["development-tools"]
 license = "MIT"
-version = "0.3.6"
+version = "0.3.7"
 edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-regex = "1.10.3"
+regex = "1.10.3"
+serde = { version = "1.0.197", features = ["derive"] }
+serde_json = "1.0.114"
+
+[dev-dependencies]
+anyhow = "1.0.80"

README.md

@@ -13,7 +13,7 @@ type NonEmptyString = Refined<NonEmptyStringRule>;
 
 fn main() {
     let hello_world = NonEmptyString::new("hello world".to_string());
-    assert_eq!(hello_world.unwrap().deref(), "hello world");
+    assert_eq!(hello_world.unwrap().into_value(), "hello world");
 
     let empty_string = NonEmptyString::new("".to_string());
     assert!(empty_string.is_err());
@@ -186,6 +186,62 @@ fn main() {
 }
 ```
 
+# JSON
+`refined_type` is compatible with `serde_json`. This ensures type-safe communication and eliminates the need to write new validation processes. All you need to do is implement a set of rules once and implement `serde`’s `Serialize` and `Deserialize`.
+### Serialize
+```rust
+type NonEmptyString = Refined<NonEmptyStringRule>;
+
+#[derive(Serialize)]
+struct Human {
+    name: NonEmptyString,
+    age: u8,
+}
+
+fn main() -> anyhow::Result<()> {
+    let john = Human {
+        name: NonEmptyString::new("john".to_string())?,
+        age: 8,
+    };
+
+    let actual = json!(john);
+    let expected = json! {{
+        "name": "john",
+        "age": 8
+    }};
+    assert_eq!(actual, expected);
+    Ok(())
+}
+```
+
+### Deserialize
+```rust
+type NonEmptyString = Refined<NonEmptyStringRule>;
+
+#[derive(Debug, Eq, PartialEq, Deserialize)]
+struct Human {
+    name: NonEmptyString,
+    age: u8,
+}
+
+fn test_refined_deserialize_json_ok_struct() -> anyhow::Result<()> {
+    let json = json! {{
+        "name": "john",
+        "age": 8
+    }}
+    .to_string();
+
+    let actual = serde_json::from_str::<Human>(&json)?;
+
+    let expected = Human {
+        name: NonEmptyString::new("john".to_string())?,
+        age: 8,
+    };
+    assert_eq!(actual, expected);
+    Ok(())
+}
+```
+
 # Tips
 Directly writing `And`, `Or`, `Not` or `Refined` can often lead to a decrease in readability. 
 Therefore, using **type aliases** can help make your code clearer.

src/refined.rs

@@ -1,5 +1,6 @@
 use crate::result::Error;
 use crate::rule::Rule;
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 use std::fmt::{Display, Formatter};
 use std::marker::PhantomData;
 use std::ops::Deref;
@@ -17,7 +18,7 @@ use std::ops::Deref;
 /// let empty_string_result = Refined::<NonEmptyStringRule>::new("".to_string());
 /// assert!(empty_string_result.is_err())
 /// ```
-#[derive(Debug, PartialEq, Eq, Clone)]
+#[derive(Debug, Eq, PartialEq, Ord, PartialOrd)]
 pub struct Refined<RULE>
 where
     RULE: Rule,
@@ -26,6 +27,35 @@ where
     _rule: PhantomData<RULE>,
 }
 
+impl<RULE, T> Serialize for Refined<RULE>
+where
+    RULE: Rule<Item = T>,
+    T: Serialize,
+{
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        self.value.serialize(serializer)
+    }
+}
+
+impl<'de, RULE, T> Deserialize<'de> for Refined<RULE>
+where
+    RULE: Rule<Item = T>,
+    T: Deserialize<'de>,
+{
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        use serde::de::Error;
+        let item: T = Deserialize::deserialize(deserializer)?;
+        let refined = Refined::new(item).map_err(|e| Error::custom(e.to_string()))?;
+        Ok(refined)
+    }
+}
+
 impl<RULE, T> Refined<RULE>
 where
     RULE: Rule<Item = T>,
@@ -72,6 +102,8 @@ mod test {
     use crate::refined::Refined;
     use crate::result::Error;
     use crate::rule::NonEmptyStringRule;
+    use serde::{Deserialize, Serialize};
+    use serde_json::json;
 
     #[test]
     fn test_refined_non_empty_string_ok() -> Result<(), Error<String>> {
@@ -93,4 +125,80 @@ mod test {
         assert_eq!(format!("{}", non_empty_string), "Hello");
         Ok(())
     }
+
+    #[test]
+    fn test_refined_serialize_json_string() -> anyhow::Result<()> {
+        let non_empty_string = Refined::<NonEmptyStringRule>::new("hello".to_string())?;
+
+        let actual = json!(non_empty_string);
+        let expected = json!("hello");
+        assert_eq!(actual, expected);
+        Ok(())
+    }
+
+    #[test]
+    fn test_refined_serialize_json_struct() -> anyhow::Result<()> {
+        type NonEmptyString = Refined<NonEmptyStringRule>;
+        #[derive(Serialize)]
+        struct Human {
+            name: NonEmptyString,
+            age: u8,
+        }
+
+        let john = Human {
+            name: NonEmptyString::new("john".to_string())?,
+            age: 8,
+        };
+
+        let actual = json!(john);
+        let expected = json! {{
+            "name": "john",
+            "age": 8
+        }};
+        assert_eq!(actual, expected);
+        Ok(())
+    }
+
+    #[test]
+    fn test_refined_deserialize_json_ok_string() -> anyhow::Result<()> {
+        let json = json!("hello").to_string();
+        let non_empty_string: Refined<NonEmptyStringRule> = serde_json::from_str(&json)?;
+
+        let actual = non_empty_string.into_value();
+        let expected = "hello";
+        assert_eq!(actual, expected);
+        Ok(())
+    }
+
+    #[test]
+    fn test_refined_deserialize_json_ok_struct() -> anyhow::Result<()> {
+        type NonEmptyString = Refined<NonEmptyStringRule>;
+        #[derive(Debug, Eq, PartialEq, Deserialize)]
+        struct Human {
+            name: NonEmptyString,
+            age: u8,
+        }
+        let json = json! {{
+            "name": "john",
+            "age": 8
+        }}
+        .to_string();
+
+        let actual = serde_json::from_str::<Human>(&json)?;
+
+        let expected = Human {
+            name: NonEmptyString::new("john".to_string())?,
+            age: 8,
+        };
+        assert_eq!(actual, expected);
+        Ok(())
+    }
+
+    #[test]
+    fn test_refined_deserialize_json_err() -> anyhow::Result<()> {
+        let json = json!("").to_string();
+        let result = serde_json::from_str::<Refined<NonEmptyStringRule>>(&json);
+        assert!(result.is_err());
+        Ok(())
+    }
 }

src/result.rs

@@ -2,11 +2,13 @@ use std::fmt::{Debug, Display, Formatter};
 
 /// A type indicating a failure to convert to `Refined`
 #[derive(Debug)]
-pub struct Error<T> {
+pub struct Error<T: Sized> {
     message: String,
     target: T,
 }
 
+impl<T> std::error::Error for Error<T> where T: Debug {}
+
 impl<T> Error<T> {
     pub fn new(message: impl Into<String>, target: T) -> Self {
         Self {

src/rule/composer/and.rs

@@ -13,6 +13,7 @@ use std::marker::PhantomData;
 ///  let actual = NonEmptyAlphabetString::validate("Hello".to_string());
 ///  assert!(actual.is_ok_and(|n| n.as_str() == "Hello"));
 /// ```
+#[derive(Debug, Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
 pub struct And<RULE1, RULE2> {
     _rule1: PhantomData<RULE1>,
     _rule2: PhantomData<RULE2>,

src/rule/composer/not.rs

@@ -13,6 +13,7 @@ use std::marker::PhantomData;
 /// assert!(NonEmptyString::validate("non empty".to_string()).is_ok());
 /// assert!(NonEmptyString::validate("".to_string()).is_err());
 /// ```
+#[derive(Debug, Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
 pub struct Not<RULE> {
     _rule: PhantomData<RULE>,
 }

src/rule/composer/or.rs

@@ -14,6 +14,7 @@ use std::marker::PhantomData;
 /// assert!(EmptyOrAlphabetString::validate("alphabet".to_string()).is_ok());
 /// assert!(EmptyOrAlphabetString::validate("1".to_string()).is_err());
 /// ```
+#[derive(Debug, Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
 pub struct Or<RULE1, RULE2> {
     _rule1: PhantomData<RULE1>,
     _rule2: PhantomData<RULE2>,

src/rule/empty.rs

@@ -16,7 +16,7 @@ use std::marker::PhantomData;
 /// assert!(Empty::<u8>::validate(0).is_ok());
 /// assert!(Empty::<u8>::validate(1).is_err());
 /// ```
-#[derive(Default)]
+#[derive(Debug, Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
 pub struct Empty<T> {
     _phantom_data: PhantomData<T>,
 }