implement less_than

Author: tomoikey

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,5 @@
+pub use length_definition::*;
+
+mod length_definition;
+mod less_than;
+

src/rule/length/length_definition.rs

@@ -0,0 +1,76 @@
+pub trait LengthDefinition {
+    fn length(&self) -> usize;
+}
+
+impl LengthDefinition for str {
+    fn length(&self) -> usize {
+        self.chars().count()
+    }
+}
+
+impl LengthDefinition for &str {
+    fn length(&self) -> usize {
+        self.chars().count()
+    }
+}
+
+impl LengthDefinition for String {
+    fn length(&self) -> usize {
+        self.chars().count()
+    }
+}
+
+impl<T> LengthDefinition for Vec<T> {
+    fn length(&self) -> usize {
+        self.len()
+    }
+}
+
+// Implementions of Iteration
+impl<T> LengthDefinition for [T] {
+    fn length(&self) -> usize {
+        self.len()
+    }
+}
+
+impl<K, V> LengthDefinition for std::collections::HashMap<K, V> {
+    fn length(&self) -> usize {
+        self.len()
+    }
+}
+
+impl<K, V> LengthDefinition for std::collections::BTreeMap<K, V> {
+    fn length(&self) -> usize {
+        self.len()
+    }
+}
+
+impl<T> LengthDefinition for std::collections::HashSet<T> {
+    fn length(&self) -> usize {
+        self.len()
+    }
+}
+
+impl<T> LengthDefinition for std::collections::BTreeSet<T> {
+    fn length(&self) -> usize {
+        self.len()
+    }
+}
+
+impl<T> LengthDefinition for std::collections::LinkedList<T> {
+    fn length(&self) -> usize {
+        self.len()
+    }
+}
+
+impl<T> LengthDefinition for std::collections::VecDeque<T> {
+    fn length(&self) -> usize {
+        self.len()
+    }
+}
+
+impl<T> LengthDefinition for std::collections::BinaryHeap<T> {
+    fn length(&self) -> usize {
+        self.len()
+    }
+}

src/rule/length/less_than.rs

@@ -0,0 +1,66 @@
+#[macro_export]
+macro_rules! length_less_than {
+    ($length:literal) => {
+        paste::item! {
+            #[allow(dead_code)]
+            pub type [<LengthLessThan $length>]<ITEM> = $crate::Refined<[<LengthLessThanRule $length>]<ITEM>>;
+
+            #[allow(dead_code)]
+            pub struct [<LengthLessThanRule $length>]<ITEM> {
+                _phantom: ::std::marker::PhantomData<ITEM>,
+            }
+
+            impl<ITEM> $crate::rule::Rule for [<LengthLessThanRule $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(Error::new(format!("target length is not less than {}", $length)))
+                    }
+                }
+            }
+        }
+    };
+    ($length:literal, $($lengths:literal),+) => {
+        length_less_than!($length);
+        length_less_than!($($lengths),+);
+    };
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::result::Error;
+
+    length_less_than!(5, 10);
+
+    #[test]
+    fn test_length_less_than_5() -> Result<(), Error> {
+        let target = "1234";
+        let refined = LengthLessThan5::new(target)?;
+        assert_eq!(refined.into_value(), "1234");
+        Ok(())
+    }
+
+    #[test]
+    fn test_length_less_than_5_fail() {
+        let target = "12345";
+        let refined = LengthLessThan5::new(target);
+        assert!(refined.is_err());
+    }
+
+    #[test]
+    fn test_length_less_than_10() -> Result<(), Error> {
+        let target = "123456789";
+        let refined = LengthLessThan10::new(target)?;
+        assert_eq!(refined.into_value(), "123456789");
+        Ok(())
+    }
+
+    #[test]
+    fn test_length_less_than_10_fail() {
+        let target = "1234567890";
+        let refined = LengthLessThan10::new(target);
+        assert!(refined.is_err());
+    }
+}