Merge pull request #38 from tomoikey/v0.6.0

Release v0.6.0

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.20"
+version = "0.6.0"
 edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
 paste = "1.0.15"
 regex = "1.11.1"
-serde = { version = "1.0.214", features = ["derive"] }
+serde = { version = "1.0.215", features = ["derive"] }
 
 [dev-dependencies]
-anyhow = "1.0.92"
-serde_json = "1.0.128"
+anyhow = "1.0.93"
+serde_json = "1.0.133"

README.md

@@ -1,19 +1,22 @@
 <h2 align="center">Refined Type</h2>
 
 <div align="center">
-    <img src="https://github.com/tomoikey/refined_type/actions/workflows/ci.yml/badge.svg"/>
-    <img src="https://github.com/tomoikey/refined_type/actions/workflows/publish.yml/badge.svg"/>
-    <br/>
+    <div>
+        <img src="https://img.shields.io/crates/v/refined_type.svg"/>
+        <img src="https://img.shields.io/crates/d/refined_type"/>
+    </div>
     <i>Code More simply, More safely, for all Rustaceans.🦀</i>
     <br/>
     <img width=550 src="https://github.com/user-attachments/assets/2ae4bfee-1d42-4ed7-820a-b13260d359ef">
     <br/>
-    <a href="https://github.com/tomoikey/refined_type/stargazers">
-        <img src="https://img.shields.io/github/stars/tomoikey/refined_type" alt="Stars Badge"/>
-    </a>
-    <a href="https://github.com/tomoikey/refined_type/network/members">
-        <img src="https://img.shields.io/github/forks/tomoikey/refined_type" alt="Forks Badge"/>
-    </a>
+    <div>
+        <a href="https://github.com/tomoikey/refined_type/stargazers">
+            <img src="https://img.shields.io/github/stars/tomoikey/refined_type" alt="Stars Badge"/>
+        </a>
+        <a href="https://github.com/tomoikey/refined_type/network/members">
+            <img src="https://img.shields.io/github/forks/tomoikey/refined_type" alt="Forks Badge"/>
+        </a>
+    </div>
     <a href="https://github.com/tomoikey/refined_type/pulls">
         <img src="https://img.shields.io/github/issues-pr/tomoikey/refined_type" alt="Pull Requests Badge"/>
     </a>
@@ -132,9 +135,11 @@ By using Rule Composer, composite rules can be easily created.
 
 `And` Rule Composer is a rule that satisfies both of the two rules.
 It is generally effective when you want to narrow down the condition range.
+
 ```rust
 type Target = Refined<And![EvenRuleU8, MinMaxRuleU8<0, 100>]>;
 ```
+
 ```rust
 fn and_example() -> Result<(), Error<u8>> {
     let target = Target::new(50)?;
@@ -155,6 +160,7 @@ It is generally effective when you want to expand the condition range.
 ```rust
 type Target = Refined<Or![LessRuleU8<10>, GreaterRuleU8<50>]>;
 ```
+
 ```rust
 fn or_example() -> Result<(), Error<u8>> {
     let target = Target::new(5)?;
@@ -181,6 +187,7 @@ It is generally effective when you want to discard only certain situations.
 ```rust
 type Target = Refined<Not<EqualRuleU8<50>>>;
 ```
+
 ```rust
 fn not_example() -> Result<(), Error<u8>> {
     let target = Target::new(49)?;
@@ -222,7 +229,8 @@ fn if_example() -> Result<(), Error<i8>> {
 
 ### 5: `IfElse` Rule Composer
 
-`IfElse` Rule Composer is a rule that applies a specific rule when a certain condition is met and another rule when it is not met.
+`IfElse` Rule Composer is a rule that applies a specific rule when a certain condition is met and another rule when it
+is not met.
 
 ```rust
 type Target = Refined<IfElse<GreaterEqualRuleI8<10>, EvenRuleI8, OddRuleI8>>;
@@ -393,7 +401,6 @@ fn range_example() -> Result<(), Error<u8>> {
 }
 ```
 
-
 # Iterator
 
 `refined_type` has several useful refined types for Iterators.
@@ -552,9 +559,121 @@ fn example_17() -> anyhow::Result<()> {
 }
 ```
 
+## `CountEqual`
+
+`CountEqual` is a type that signifies the number of elements that satisfy the rule is a specific number.
+
+```rust
+fn count_equal_example() -> Result<(), Error<Vec<i32>>> {
+    let table = vec![
+        (vec!["good morning".to_string(), "hello".to_string()], false),
+        (vec!["good morning".to_string(), "".to_string()], true),
+        (vec!["".to_string(), "hello".to_string()], true),
+        (vec!["".to_string(), "".to_string()], false),
+    ];
+
+    for (value, expected) in table {
+        let refined = CountEqualVec::<1, NonEmptyStringRule>::new(value.clone());
+        assert_eq!(refined.is_ok(), expected);
+    }
+
+    Ok(())
+}
+```
+
+## `CountLess`
+
+`CountLess` is a type that signifies the number of elements that satisfy the rule is less than a specific number.
+
+```rust
+fn count_less_example() -> Result<(), Error<Vec<i32>>> {
+    let table = vec![
+        (vec!["good morning".to_string(), "hello".to_string()], false),
+        (vec!["good morning".to_string(), "".to_string()], true),
+        (vec!["".to_string(), "hello".to_string()], true),
+        (vec!["".to_string(), "".to_string()], true),
+    ];
+
+    for (value, expected) in table {
+        let refined = CountLessVec::<2, NonEmptyStringRule>::new(value.clone());
+        assert_eq!(refined.is_ok(), expected);
+    }
+
+    Ok(())
+}
+```
+
+## `CountGreater`
+
+`CountGreater` is a type that signifies the number of elements that satisfy the rule is greater than a specific number.
+
+```rust
+fn count_greater_example() -> Result<(), Error<Vec<i32>>> {
+    let table = vec![
+        (vec!["good morning".to_string(), "hello".to_string()], true),
+        (vec!["good morning".to_string(), "".to_string()], false),
+        (vec!["".to_string(), "hello".to_string()], false),
+        (vec!["".to_string(), "".to_string()], false),
+    ];
+
+    for (value, expected) in table {
+        let refined = CountGreaterVec::<1, NonEmptyStringRule>::new(value.clone());
+        assert_eq!(refined.is_ok(), expected);
+    }
+
+    Ok(())
+}
+```
+
+## `CountLessEqual`
+
+`CountLessEqual` is a type that signifies the number of elements that satisfy the rule is less than or equal to a
+specific number.
+
+```rust
+fn count_less_equal_example() -> Result<(), Error<Vec<i32>>> {
+    let table = vec![
+        (vec!["good morning".to_string(), "hello".to_string()], true),
+        (vec!["good morning".to_string(), "".to_string()], true),
+        (vec!["".to_string(), "hello".to_string()], true),
+        (vec!["".to_string(), "".to_string()], true),
+    ];
+
+    for (value, expected) in table {
+        let refined = CountLessEqualVec::<2, NonEmptyStringRule>::new(value.clone());
+        assert_eq!(refined.is_ok(), expected);
+    }
+
+    Ok(())
+}
+```
+
+## `CountGreaterEqual`
+
+`CountGreaterEqual` is a type that signifies the number of elements that satisfy the rule is greater than or equal to a
+specific number.
+
+```rust
+fn count_greater_equal_example() -> Result<(), Error<Vec<i32>>> {
+    let table = vec![
+        (vec!["good morning".to_string(), "hello".to_string()], true),
+        (vec!["good morning".to_string(), "".to_string()], true),
+        (vec!["".to_string(), "hello".to_string()], true),
+        (vec!["".to_string(), "".to_string()], false),
+    ];
+
+    for (value, expected) in table {
+        let refined = CountGreaterEqualVec::<1, NonEmptyStringRule>::new(value.clone());
+        assert_eq!(refined.is_ok(), expected);
+    }
+
+    Ok(())
+}
+```
+
 ## `Reverse`
 
-`Reverse` is a rule that applies a specific rule to all elements in the Iterator in reverse order.  
+`Reverse` is a rule that applies a specific rule to all elements in the Iterator in reverse order.
 
 ```rust
 fn example_18() -> Result<(), Error<Vec<i32>>> {
@@ -622,6 +741,7 @@ impl<ITEM> SkipOption for NoSkip<ITEM> {
 You can impose constraints on objects that have a length, such as `String` or `Vec`.
 
 ## `LengthMinMax`
+
 `LengthMinMax` is a type that signifies the target has a length between a certain number and another number.
 
 ```rust
@@ -642,6 +762,7 @@ fn length_min_max_example() -> Result<(), Error<String>> {
 ```
 
 ## `LengthGreater`
+
 `LengthGreater` is a type that signifies the target has a length greater than a certain number.
 
 ```rust
@@ -659,6 +780,7 @@ fn length_greater_example() -> Result<(), Error<String>> {
 ```
 
 ## `LengthLess`
+
 `LengthLess` is a type that signifies the target has a length less than a certain number.
 
 ```rust
@@ -676,6 +798,7 @@ fn length_less_example() -> Result<(), Error<String>> {
 ```
 
 ## `LengthEqual`
+
 `LengthEqual` is a type that signifies the target has a length equal to a certain number.
 
 ```rust

src/rule/collection.rs

@@ -1,3 +1,4 @@
+mod count;
 mod exists;
 mod for_all;
 mod head;
@@ -10,6 +11,7 @@ mod reverse;
 mod skip;
 mod tail;
 
+pub use count::*;
 pub use exists::*;
 pub use for_all::*;
 pub use head::*;

src/rule/collection/count.rs

@@ -0,0 +1,11 @@
+mod equal;
+mod grater_equal;
+mod greater;
+mod less;
+mod less_equal;
+
+pub use equal::*;
+pub use grater_equal::*;
+pub use greater::*;
+pub use less::*;
+pub use less_equal::*;

src/rule/collection/count/equal.rs

@@ -0,0 +1,102 @@
+use crate::result::Error;
+use crate::rule::{Iterable, Rule};
+use crate::Refined;
+use std::collections::VecDeque;
+
+/// A type that holds a value satisfying the `CountEqualRule`
+pub type CountEqual<const N: usize, RULE, ITERABLE> = Refined<CountEqualRule<N, RULE, ITERABLE>>;
+
+/// A type that holds a `Vec` value satisfying the `CountEqualRule`
+pub type CountEqualVec<const N: usize, RULE> = Refined<CountEqualVecRule<N, RULE>>;
+
+/// A type that holds a `VecDeque` value satisfying the `CountEqualRule`
+pub type CountEqualVecDeque<const N: usize, RULE> = Refined<CountEqualVecDequeRule<N, RULE>>;
+
+/// A type that holds a `HashMap` value satisfying the `CountEqualRule`
+pub type CountEqualHashMap<const N: usize, RULE, K> = Refined<CountEqualHashMapRule<N, RULE, K>>;
+
+/// A type that holds a `HashSet` value satisfying the `CountEqualRule`
+pub type CountEqualHashSet<const N: usize, RULE, K> = Refined<CountEqualHashSetRule<N, RULE, K>>;
+
+/// A type that holds a `String` value satisfying the `CountEqualRule`
+pub type CountEqualString<const N: usize, RULE> = Refined<CountEqualStringRule<N, RULE>>;
+
+/// A type that holds a `&'a str` value satisfying the `CountEqualRule`
+pub type CountEqualStr<'a, const N: usize, RULE> = Refined<CountEqualStrRule<'a, N, RULE>>;
+
+/// Rule where the count of items that satisfy the condition is equal to `N`.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct CountEqualRule<const N: usize, RULE: Rule, ITERABLE: Iterable>
+where
+    ITERABLE: Iterable<Item = RULE::Item>,
+{
+    _phantom: std::marker::PhantomData<(RULE, ITERABLE)>,
+}
+
+impl<const N: usize, ITERABLE, RULE> Rule for CountEqualRule<N, RULE, ITERABLE>
+where
+    ITERABLE: Iterable<Item = RULE::Item> + FromIterator<ITERABLE::Item>,
+    RULE: Rule,
+{
+    type Item = ITERABLE;
+    fn validate(target: Self::Item) -> crate::Result<Self::Item> {
+        let mut count = 0;
+        let mut deque = VecDeque::new();
+        for item in target.into_iterator() {
+            match RULE::validate(item) {
+                Ok(item) => {
+                    deque.push_back(item);
+                    count += 1
+                }
+                Err(e) => {
+                    deque.push_back(e.into_value());
+                }
+            }
+        }
+        let target = ITERABLE::from_iter(deque);
+        if count == N {
+            Ok(target)
+        } else {
+            Err(Error::new(
+                target,
+                format!("count is not equal to {}, actual count is {}", N, count),
+            ))
+        }
+    }
+}
+
+/// Rule where the count of items in the `Vec` that satisfy the condition is equal to `N`.
+pub type CountEqualVecRule<const N: usize, RULE> =
+    CountEqualRule<N, RULE, Vec<<RULE as Rule>::Item>>;
+
+/// Rule where the count of items in the `VecDeque` that satisfy the condition is equal to `N`.
+pub type CountEqualVecDequeRule<const N: usize, RULE> =
+    CountEqualRule<N, RULE, VecDeque<<RULE as Rule>::Item>>;
+
+/// Rule where the count of items in the `HashMap` that satisfy the condition is equal to `N`.
+pub type CountEqualHashMapRule<const N: usize, RULE, K> =
+    CountEqualRule<N, RULE, std::collections::HashMap<K, <RULE as Rule>::Item>>;
+
+/// Rule where the count of items in the `HashSet` that satisfy the condition is equal to `N`.
+pub type CountEqualHashSetRule<const N: usize, RULE, K> =
+    CountEqualRule<N, RULE, std::collections::HashSet<K>>;
+
+/// Rule where the count of items in the `String` that satisfy the condition is equal to `N`.
+pub type CountEqualStringRule<const N: usize, RULE> = CountEqualRule<N, RULE, String>;
+
+/// Rule where the count of items in the `&'a str` that satisfy the condition is equal to `N`.
+pub type CountEqualStrRule<'a, const N: usize, RULE> = CountEqualRule<N, RULE, &'a str>;
+
+#[cfg(test)]
+mod tests {
+    use crate::result::Error;
+    use crate::rule::{CountEqualVec, NonEmptyStringRule};
+
+    #[test]
+    fn count_equal_1() -> Result<(), Error<Vec<String>>> {
+        let value = vec!["good morning".to_string(), "hello".to_string()];
+        let count_equal = CountEqualVec::<2, NonEmptyStringRule>::new(value.clone())?;
+        assert_eq!(count_equal.into_value(), value);
+        Ok(())
+    }
+}