update readme

Author: tomoikey

README.md

@@ -13,15 +13,66 @@ All rules can be arbitrarily combined and extended as long as the target type ma
 
 # Example Usage
 
+As an example, let's convert from JSON to a struct.
+
 ```rust
-type NonEmptyString = Refined<NonEmptyStringRule>;
+use refined_type::Refined;
+use refined_type::rule::NonEmptyRule;
+use serde::Deserialize;
+use serde_json::json;
 
-fn main() {
-    let hello_world = NonEmptyString::new("hello world".to_string());
-    assert_eq!(hello_world.unwrap().into_value(), "hello world");
+// define the constraints you expect by combining 'Refined' and 'Rule'.
+pub type MyNonEmptyString = Refined<NonEmptyRule<String>>;
+pub type MyNonEmptyVec<T> = Refined<NonEmptyRule<Vec<T>>>;
+
+// define a struct for converting from JSON.
+#[derive(Debug, Eq, PartialEq, Deserialize)]
+struct Human {
+    name: MyNonEmptyString,
+    friends: MyNonEmptyVec<String>
+}
+
+// In the first example, both 'name' and 'friends' satisfy the rule, so the conversion from JSON will succeed.
+fn example_1() -> anyhow::Result<()> {
+    let json = json! {{
+        "name": "john",
+        "friends": ["tom", "taro"]
+    }}
+        .to_string();
+
+    let actual = serde_json::from_str::<Human>(&json)?;
+    let expected = Human {
+        name: MyNonEmptyString::new("john".to_string())?,
+        friends: MyNonEmptyVec::new(vec!["tom".to_string(), "taro".to_string()])?
+    };
+    assert_eq!(actual, expected);
+    Ok(())
+}
+
+// In the second example, while `friends` meets the rule, `name` does not, causing the conversion from JSON to fail
+fn example_2() -> anyhow::Result<()> {
+    let json = json! {{
+        "name": "",
+        "friends": ["tom", "taro"]
+    }}
+        .to_string();
+
+    // because `name` is empty
+    assert!(serde_json::from_str::<Human>(&json).is_err());
+    Ok(())
+}
+
+// In the third example, while `name` satisfies the rule, `friends` does not, causing the conversion from JSON to fail.
+fn example_3() -> anyhow::Result<()> {
+    let json = json! {{
+        "name": "john",
+        "friends": []
+    }}
+        .to_string();
 
-    let empty_string = NonEmptyString::new("".to_string());
-    assert!(empty_string.is_err());
+    // because `friends` is empty
+    assert!(serde_json::from_str::<Human>(&json).is_err());
+    Ok(())
 }
 ```
 

src/refined.rs

@@ -97,7 +97,7 @@ where
 mod test {
     use crate::refined::Refined;
     use crate::result::Error;
-    use crate::rule::NonEmptyStringRule;
+    use crate::rule::{NonEmptyString, NonEmptyStringRule, NonEmptyVec};
     use serde::{Deserialize, Serialize};
     use serde_json::json;
 
@@ -180,15 +180,16 @@ mod test {
     }
 
     #[test]
-    fn test_refined_deserialize_json_ok_struct() -> anyhow::Result<()> {
-        type NonEmptyString = Refined<NonEmptyStringRule>;
+    fn test_refined_deserialize_json_ok_1() -> anyhow::Result<()> {
         #[derive(Debug, Eq, PartialEq, Deserialize)]
         struct Human {
             name: NonEmptyString,
+            friends: NonEmptyVec<String>,
             age: u8,
         }
         let json = json! {{
             "name": "john",
+            "friends": ["tom", "taro"],
             "age": 8
         }}
         .to_string();
@@ -197,14 +198,55 @@ mod test {
 
         let expected = Human {
             name: NonEmptyString::new("john".to_string())?,
+            friends: NonEmptyVec::new(vec!["tom".to_string(), "taro".to_string()])?,
             age: 8,
         };
         assert_eq!(actual, expected);
         Ok(())
     }
 
     #[test]
-    fn test_refined_deserialize_json_err() -> anyhow::Result<()> {
+    fn test_refined_deserialize_json_err_1() -> anyhow::Result<()> {
+        #[derive(Debug, Eq, PartialEq, Deserialize)]
+        struct Human {
+            name: NonEmptyString,
+            friends: NonEmptyVec<String>,
+            age: u8,
+        }
+        let json = json! {{
+            "name": "john",
+            "friends": [],
+            "age": 8
+        }}
+        .to_string();
+
+        // because `friends` is empty vec
+        assert!(serde_json::from_str::<Human>(&json).is_err());
+        Ok(())
+    }
+
+    #[test]
+    fn test_refined_deserialize_json_err_2() -> anyhow::Result<()> {
+        #[derive(Debug, Eq, PartialEq, Deserialize)]
+        struct Human {
+            name: NonEmptyString,
+            friends: NonEmptyVec<String>,
+            age: u8,
+        }
+        let json = json! {{
+            "name": "",
+            "friends": ["tom", "taro"],
+            "age": 8
+        }}
+        .to_string();
+
+        // because `name` is empty string
+        assert!(serde_json::from_str::<Human>(&json).is_err());
+        Ok(())
+    }
+
+    #[test]
+    fn test_refined_deserialize_json_err_3() -> anyhow::Result<()> {
         let json = json!("").to_string();
         let result = serde_json::from_str::<Refined<NonEmptyStringRule>>(&json);
         assert!(result.is_err());