chore: add garde crate example

examples/Cargo.toml

@@ -11,4 +11,5 @@ edition = "2024"
 [dev-dependencies]
 serdev     = { path = "../serdev", features = ["derive"] }
 serde_json = { version = "1.0" }
-validator  = { version = "0.20", features = ["derive"] }
+validator  = { version = "0.20", features = ["derive"] }
+garde      = { version = "0.22", features = ["derive"] }

examples/examples/garde_crate.rs

@@ -0,0 +1,35 @@
+use serdev::Deserialize;
+use garde::Validate;
+
+#[derive(Deserialize, Validate, Debug, PartialEq)]
+#[serde(validate = "Validate::validate")]
+struct User<'a> {
+    #[garde(ascii, length(min = 3, max = 25))]
+    username: &'a str,
+    #[garde(length(min = 15))]
+    password: &'a str,
+}
+
+fn main() {
+    let result = serde_json::from_str::<User>(
+        r#"{
+            "username": "test",
+            "password": "not_a_very_good_paddword"
+        }"#
+    );
+    assert_eq!(
+        dbg!(result).unwrap(),
+        User {
+            username: "test",
+            password: "not_a_very_good_paddword",
+        }
+    );
+
+    let result = serde_json::from_str::<User>(
+        r#"{
+            "username": "test",
+            "password": "short_password"
+        }"#
+    );
+    assert!(dbg!(result).is_err());
+}

examples/examples/inlined_closure.rs

@@ -1,4 +1,4 @@
-use serdev::{Serialize, Deserialize};
+use serdev::{Deserialize, Serialize};
 
 #[derive(Serialize, Deserialize, Debug)]
 #[serde(validate = r#"|p| (p.x * p.y <= 100).then_some(()).ok_or("x * y must not exceed 100")"#)]
@@ -8,16 +8,22 @@ struct Point {
 }
 
 fn main() {
-    let point = serde_json::from_str::<Point>(r#"
+    let point = serde_json::from_str::<Point>(
+        r#"
         { "x" : 1, "y" : 2 }
-    "#).unwrap();
+    "#,
+    )
+    .unwrap();
 
     // Prints point = Point { x: 1, y: 2 }
     println!("point = {point:?}");
 
-    let error = serde_json::from_str::<Point>(r#"
+    let error = serde_json::from_str::<Point>(
+        r#"
         { "x" : 10, "y" : 20 }
-    "#).unwrap_err();
+    "#,
+    )
+    .unwrap_err();
 
     // Prints error = x * y must not exceed 100
     println!("error = {error}");

examples/examples/readme.rs

@@ -1,4 +1,4 @@
-use serdev::{Serialize, Deserialize};
+use serdev::{Deserialize, Serialize};
 
 #[derive(Serialize, Deserialize, Debug)]
 #[serde(validate = "Self::validate")]
@@ -10,23 +10,29 @@ struct Point {
 impl Point {
     fn validate(&self) -> Result<(), impl std::fmt::Display> {
         if self.x * self.y > 100 {
-            return Err("x * y must not exceed 100")
+            return Err("x * y must not exceed 100");
         }
         Ok(())
     }
 }
 
 fn main() {
-    let point = serde_json::from_str::<Point>(r#"
+    let point = serde_json::from_str::<Point>(
+        r#"
         { "x" : 1, "y" : 2 }
-    "#).unwrap();
+    "#,
+    )
+    .unwrap();
 
     // Prints point = Point { x: 1, y: 2 }
     println!("point = {point:?}");
 
-    let error = serde_json::from_str::<Point>(r#"
+    let error = serde_json::from_str::<Point>(
+        r#"
         { "x" : 10, "y" : 20 }
-    "#).unwrap_err();
+    "#,
+    )
+    .unwrap_err();
 
     // Prints error = x * y must not exceed 100
     println!("error = {error}");

examples/examples/validator_crate.rs

@@ -27,31 +27,40 @@ fn validate_unique_username(username: &str) -> Result<(), ValidationError> {
 }
 
 fn main() {
-    let signupdata = serde_json::from_str::<SignupData>(r#"
+    let signupdata = serde_json::from_str::<SignupData>(
+        r#"
         {
             "mail": "serdev@ohkami.rs",
             "site": "https://ohkami.rs",
             "firstName": "serdev",
             "age": 20,
             "height": 0.0
         }
-    "#).unwrap();
-    assert_eq!(signupdata, SignupData {
-        mail: String::from("serdev@ohkami.rs"),
-        site: String::from("https://ohkami.rs"),
-        first_name: String::from("serdev"),
-        age: 20,
-        height: 0.0
-    });
+    "#,
+    )
+    .unwrap();
+    assert_eq!(
+        signupdata,
+        SignupData {
+            mail: String::from("serdev@ohkami.rs"),
+            site: String::from("https://ohkami.rs"),
+            first_name: String::from("serdev"),
+            age: 20,
+            height: 0.0
+        }
+    );
 
-    let error = serde_json::from_str::<SignupData>(r#"
+    let error = serde_json::from_str::<SignupData>(
+        r#"
         {
             "mail": "serdev@ohkami.rs",
             "site": "https://ohkami.rs",
             "firstName": "serdev",
             "age": 0,
             "height": 0.0
         }
-    "#).unwrap_err();
+    "#,
+    )
+    .unwrap_err();
     println!("error: {error}");
 }

examples/examples/various_users.rs

@@ -1,21 +1,21 @@
-use serdev::{Serialize, Deserialize};
+use serdev::{Deserialize, Serialize};
 
 #[derive(Debug, PartialEq, Serialize, Deserialize)]
 struct User {
     name: String,
-    age:  usize,
+    age: usize,
 }
 
 #[derive(Debug, PartialEq, Deserialize)]
 #[serde(validate = "Self::validate")]
 struct VUser {
     name: String,
-    age:  usize,
+    age: usize,
 }
 impl VUser {
     fn validate(&self) -> Result<(), impl std::fmt::Display> {
         if self.name.is_empty() {
-            return Err("`name` must not be empty")
+            return Err("`name` must not be empty");
         }
         Ok(())
     }
@@ -25,28 +25,28 @@ impl VUser {
 #[serde(validate(by = "Self::validate", error = "&'static str"))]
 struct EUser {
     name: String,
-    age:  usize,
+    age: usize,
 }
 impl EUser {
     fn validate(&self) -> Result<(), &'static str> {
         if self.name.is_empty() {
-            return Err("`name` must not be empty")
+            return Err("`name` must not be empty");
         }
         Ok(())
     }
 }
 
 #[derive(Debug, PartialEq, Deserialize)]
 #[serde(validate = "Self::validate")]
-struct GUser<'n, Name: From<String>+ToString, Age: From<u8>> {
-    name:     Name,
-    age:      Age,
-    nickname: Option<&'n str>
+struct GUser<'n, Name: From<String> + ToString, Age: From<u8>> {
+    name: Name,
+    age: Age,
+    nickname: Option<&'n str>,
 }
-impl<'n, Name: From<String>+ToString, Age: From<u8>> GUser<'n, Name, Age> {
+impl<'n, Name: From<String> + ToString, Age: From<u8>> GUser<'n, Name, Age> {
     fn validate(&self) -> Result<(), impl std::fmt::Display> {
         if self.name.to_string().is_empty() {
-            return Err("`name` must not be empty")
+            return Err("`name` must not be empty");
         }
         Ok(())
     }
@@ -56,76 +56,68 @@ fn main() {
     assert_eq!(
         serde_json::to_string(&User {
             name: String::from("serdev"),
-            age:  0
-        }).unwrap(),
+            age: 0
+        })
+        .unwrap(),
         r#"{"name":"serdev","age":0}"#
     );
     assert_eq!(
-        serde_json::from_str::<User>(
-            r#"{"age":4,"name":"ohkami"}"#
-        ).unwrap(),
+        serde_json::from_str::<User>(r#"{"age":4,"name":"ohkami"}"#).unwrap(),
         User {
             name: String::from("ohkami"),
-            age:  4
+            age: 4
         }
     );
 
     assert_eq!(
-        serde_json::from_str::<VUser>(
-            r#"{"age":4,"name":"ohkami"}"#
-        ).unwrap(),
+        serde_json::from_str::<VUser>(r#"{"age":4,"name":"ohkami"}"#).unwrap(),
         VUser {
             name: String::from("ohkami"),
-            age:  4
+            age: 4
         }
     );
     assert_eq!(
-        serde_json::from_str::<VUser>(
-            r#"{"age":4,"name":""}"#
-        ).unwrap_err().to_string(),
+        serde_json::from_str::<VUser>(r#"{"age":4,"name":""}"#)
+            .unwrap_err()
+            .to_string(),
         "`name` must not be empty"
     );
 
     assert_eq!(
-        serde_json::from_str::<EUser>(
-            r#"{"age":4,"name":"ohkami"}"#
-        ).unwrap(),
+        serde_json::from_str::<EUser>(r#"{"age":4,"name":"ohkami"}"#).unwrap(),
         EUser {
             name: String::from("ohkami"),
-            age:  4
+            age: 4
         }
     );
     assert_eq!(
-        serde_json::from_str::<EUser>(
-            r#"{"age":4,"name":""}"#
-        ).unwrap_err().to_string(),
+        serde_json::from_str::<EUser>(r#"{"age":4,"name":""}"#)
+            .unwrap_err()
+            .to_string(),
         "`name` must not be empty"
     );
 
     assert_eq!(
-        serde_json::from_str::<GUser<String, u8>>(
-            r#"{"age":4,"name":"ohkami"}"#
-        ).unwrap(),
+        serde_json::from_str::<GUser<String, u8>>(r#"{"age":4,"name":"ohkami"}"#).unwrap(),
         GUser {
-            name:     String::from("ohkami"),
-            age:      4,
+            name: String::from("ohkami"),
+            age: 4,
             nickname: None
         }
     );
     assert_eq!(
-        serde_json::from_str::<GUser<String, u8>>(
-            r#"{"age":4,"nickname":"wolf","name":"ohkami"}"#
-        ).unwrap(),
+        serde_json::from_str::<GUser<String, u8>>(r#"{"age":4,"nickname":"wolf","name":"ohkami"}"#)
+            .unwrap(),
         GUser {
-            name:     String::from("ohkami"),
-            age:      4,
+            name: String::from("ohkami"),
+            age: 4,
             nickname: Some("wolf")
         }
     );
     assert_eq!(
-        serde_json::from_str::<GUser<String, u8>>(
-            r#"{"age":4,"nickname":"wolf","name":""}"#
-        ).unwrap_err().to_string(),
+        serde_json::from_str::<GUser<String, u8>>(r#"{"age":4,"nickname":"wolf","name":""}"#)
+            .unwrap_err()
+            .to_string(),
         "`name` must not be empty"
     );
 }