Merge pull request #14 from tomoikey/length

Implement Refined Length

Author: tomoikey

Cargo.toml

@@ -6,16 +6,16 @@ repository = "https://github.com/tomoikey/refined-type"
 readme = "README.md"
 categories = ["accessibility", "development-tools", "rust-patterns"]
 license = "MIT"
-version = "0.5.1"
+version = "0.5.2"
 edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-paste = "1.0.14"
-regex = "1.10.3"
-serde = { version = "1.0.197", features = ["derive"] }
+paste = "1.0.15"
+regex = "1.10.4"
+serde = { version = "1.0.203", features = ["derive"] }
 
 [dev-dependencies]
-anyhow = "1.0.80"
-serde_json = "1.0.114"
+anyhow = "1.0.86"
+serde_json = "1.0.117"

README.md

@@ -107,6 +107,7 @@ By using Rule Composer, composite rules can be easily created.
 
 ```rust
 struct ContainsHelloRule;
+
 struct ContainsWorldRule;
 
 impl Rule for ContainsHelloRule {
@@ -195,7 +196,9 @@ Therefore, it can be treated much like a composite function
 
 ```rust
 struct StartsWithHelloRule;
+
 struct StartsWithByeRule;
+
 struct EndsWithJohnRule;
 
 impl Rule for StartsWithHelloRule {
@@ -320,15 +323,19 @@ type TargetAgeRule = And<TargetAge18OrMore, TargetAge80OrLess>;
 ```
 
 # Iterator
+
 I have also prepared several useful refined types for Iterators.
+
 ## `ForAll`
+
 `ForAll` is a rule that applies a specific rule to all elements in the Iterator.
+
 ```rust
 fn example_11() -> anyhow::Result<()> {
     let vec = vec!["Hello".to_string(), "World".to_string()];
     let for_all_ok = ForAll::<NonEmptyStringRule, _>::new(vec.clone())?;
     assert_eq!(vec, for_all_ok.into_value());
-    
+
     let vec = vec!["Hello".to_string(), "".to_string()];
     let for_all_err = ForAll::<NonEmptyStringRule, _>::new(vec.clone());
     assert!(for_all_err.is_err());
@@ -337,7 +344,9 @@ fn example_11() -> anyhow::Result<()> {
 ```
 
 ## `Exists`
+
 `Exists` is a rule that applies a specific rule to at least one element in the Iterator.
+
 ```rust
 fn example_12() -> anyhow::Result<()> {
     let vec = vec!["Hello".to_string(), "".to_string()];
@@ -350,8 +359,11 @@ fn example_12() -> anyhow::Result<()> {
     Ok(())
 }
 ```
+
 ---
+
 ## `into_iter()` and `iter()`
+
 The Iterator I’ve prepared has `into_iter` and `iter` implemented.
 Therefore, you can easily map or convert it to a different Iterator using `collect`.
 Feel free to explore the capabilities of the Iterator you’ve been given!
@@ -420,6 +432,122 @@ fn example_15() -> anyhow::Result<()> {
 }
 ```
 
+# Length
+
+You can impose constraints on objects that have a length, such as `String` or `Vec`.
+
+### String
+
+```rust
+fn example_16() -> Result<(), Error> {
+    length_greater_than!(5);
+    length_equal!(5, 10);
+    length_less_than!(10);
+
+    type Password = Refined<From5To10Rule<String>>;
+
+    type From5To10Rule<T> = And<
+        Or<LengthEqualRule5<T>, LengthGreaterThanRule5<T>>,
+        Or<LengthLessThanRule10<T>, LengthEqualRule10<T>>,
+    >;
+
+    // length is 8. so, this is valid
+    let raw_password = "password";
+    let password = Password::new(raw_password.to_string())?;
+    assert_eq!(password.into_value(), "password");
+
+    // length is 4. so, this is invalid
+    let raw_password = "pswd";
+    let password = Password::new(raw_password.to_string());
+    assert!(password.is_err());
+
+    // length is 17. so, this is invalid
+    let raw_password = "password password";
+    let password = Password::new(raw_password.to_string());
+    assert!(password.is_err());
+
+    Ok(())
+}
+```
+
+### Vec
+
+```rust
+#[test]
+fn example_17() -> anyhow::Result<()> {
+    length_greater_than!(5);
+    length_equal!(5, 10);
+    length_less_than!(10);
+
+    type Friends = Refined<From5To10Rule<Vec<String>>>;
+
+    type From5To10Rule<T> = And<
+        Or<LengthEqualRule5<T>, LengthGreaterThanRule5<T>>,
+        Or<LengthLessThanRule10<T>, LengthEqualRule10<T>>,
+    >;
+
+    // length is 6. so, this is valid
+    let raw_friends = vec![
+        "Tom".to_string(),
+        "Taro".to_string(),
+        "Jiro".to_string(),
+        "Hanako".to_string(),
+        "Sachiko".to_string(),
+        "Yoshiko".to_string(),
+    ];
+    let friends = Friends::new(raw_friends.clone())?;
+    assert_eq!(friends.into_value(), raw_friends);
+
+    // length is 2. so, this is invalid
+    let raw_friends = vec!["Tom".to_string(), "Taro".to_string()];
+    let friends = Friends::new(raw_friends.clone());
+    assert!(friends.is_err());
+
+    // length is 11. so, this is invalid
+    let raw_friends = vec![
+        "Tom".to_string(),
+        "Taro".to_string(),
+        "Jiro".to_string(),
+        "Hanako".to_string(),
+        "Sachiko".to_string(),
+        "Yuiko".to_string(),
+        "Taiko".to_string(),
+        "John".to_string(),
+        "Jane".to_string(),
+        "Jack".to_string(),
+        "Jill".to_string(),
+    ];
+    let friends = Friends::new(raw_friends.clone());
+    assert!(friends.is_err());
+
+    Ok(())
+}
+```
+
+### Custom Length
+
+You can define a length for any type. Therefore, if you want to implement a length that is not provided
+by `refined_type`, you can easily do so using `LengthDefinition`.
+
+```rust
+#[test]
+fn example_18() -> anyhow::Result<()> {
+    length_equal!(5);
+
+    #[derive(Debug, PartialEq)]
+    struct Hello;
+    impl LengthDefinition for Hello {
+        fn length(&self) -> usize {
+            5
+        }
+    }
+
+    let hello = Refined::<LengthEqualRule5<Hello>>::new(Hello)?;
+    assert_eq!(hello.into_value(), Hello);
+    Ok(())
+}
+```
+
 # Tips
 
 Directly writing `And`, `Or`, `Not` or `Refined` can often lead to a decrease in readability.

src/refined.rs

@@ -1,9 +1,10 @@
-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;
+
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
+
+use crate::result::Error;
+use crate::rule::Rule;
 
 /// Refined is a versatile type in ensuring that `T` satisfies the conditions of `RULE` (predicate type)
 /// # Example
@@ -96,11 +97,12 @@ where
 
 #[cfg(test)]
 mod test {
+    use serde::{Deserialize, Serialize};
+    use serde_json::json;
+
     use crate::refined::Refined;
     use crate::result::Error;
     use crate::rule::{NonEmptyString, NonEmptyStringRule, NonEmptyVec};
-    use serde::{Deserialize, Serialize};
-    use serde_json::json;
 
     #[test]
     fn test_unsafe_new_success() {

src/rule.rs

@@ -1,19 +1,22 @@
+pub use empty::*;
+pub use exists::*;
+pub use for_all::*;
+pub use length::*;
+pub use non_empty::*;
+pub use number::*;
+pub use string::*;
+
+use crate::result::Error;
+
 pub mod composer;
 mod empty;
 mod exists;
 mod for_all;
+mod length;
 mod non_empty;
 mod number;
 mod string;
 
-use crate::result::Error;
-pub use empty::*;
-pub use exists::*;
-pub use for_all::*;
-pub use non_empty::*;
-pub use number::*;
-pub use string::*;
-
 /// This is a `trait` that specifies the conditions a type `T` should satisfy
 pub trait Rule {
     type Item;

src/rule/length.rs

@@ -0,0 +1,6 @@
+pub use length_definition::*;
+
+mod equal;
+mod grater;
+mod length_definition;
+mod less;

src/rule/length/equal.rs

@@ -0,0 +1,82 @@
+/// This macro generates a rule that checks if the length of the target is equal to `N`
+/// # Example
+/// ```rust
+/// use refined_type::length_equal;
+/// length_equal!(5);
+///
+/// let target = "12345";
+/// let refined = LengthEqual5::new(target).unwrap();
+/// assert_eq!(refined.into_value(), "12345");
+///
+/// let target = "1234";
+/// let refined = LengthEqual5::new(target);
+/// assert!(refined.is_err());
+/// ```
+#[macro_export]
+macro_rules! length_equal {
+    ($length:literal) => {
+        paste::item! {
+            /// A type that holds a value satisfying the LengthEqualN rule.
+            #[allow(dead_code)]
+            pub type [<LengthEqual $length>]<ITEM> = $crate::Refined<[<LengthEqualRule $length>]<ITEM>>;
+
+            /// Rule where the length of the input value is equal to N
+            #[allow(dead_code)]
+            pub struct [<LengthEqualRule $length>]<ITEM> {
+                _phantom: ::std::marker::PhantomData<ITEM>,
+            }
+
+            impl<ITEM> $crate::rule::Rule for [<LengthEqualRule $length>]<ITEM> where ITEM: $crate::rule::LengthDefinition {
+                type Item = ITEM;
+                fn validate(target: &Self::Item) -> Result<(), $crate::result::Error> {
+                    if target.length() == $length {
+                        Ok(())
+                    } else {
+                        Err($crate::result::Error::new(format!("target length is not equal to {}", $length)))
+                    }
+                }
+            }
+        }
+    };
+    ($length:literal, $($lengths:literal),+) => {
+        length_equal!($length);
+        length_equal!($($lengths),+);
+    };
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::result::Error;
+
+    length_equal!(5, 10);
+
+    #[test]
+    fn test_length_equal_5() -> Result<(), Error> {
+        let target = "12345";
+        let refined = LengthEqual5::new(target)?;
+        assert_eq!(refined.into_value(), "12345");
+        Ok(())
+    }
+
+    #[test]
+    fn test_length_equal_5_fail() {
+        let target = "1234";
+        let refined = LengthEqual5::new(target);
+        assert!(refined.is_err());
+    }
+
+    #[test]
+    fn test_length_equal_10() -> Result<(), Error> {
+        let target = "1234567890";
+        let refined = LengthEqual10::new(target)?;
+        assert_eq!(refined.into_value(), "1234567890");
+        Ok(())
+    }
+
+    #[test]
+    fn test_length_equal_10_fail() {
+        let target = "123456789";
+        let refined = LengthEqual10::new(target);
+        assert!(refined.is_err());
+    }
+}