Add every, some, none methods to ArrayAssertions with tests and README updates

Author: k2gl

README.md

@@ -65,72 +65,16 @@ fact([])->isEmptyArray(); // Passes
 fact([1, 2])->isEmptyArray(); // Fails
 
 fact([1, 2])->isNotEmptyArray(); // Passes
-fact([])->isNotEmptyArray(); // Fails     
+fact([])->isNotEmptyArray(); // Fails
 
-```
-
-### Boolean assertions
-```php
-fact(true)->true(); // Passes
-fact(1)->true(); // Fails due to strict comparison
-
-fact(false)->notTrue(); // Passes
-fact(true)->notTrue(); // Fails
-
-fact(false)->false(); // Passes
-fact(0)->false(); // Fails due to strict comparison
-
-fact(true)->notFalse(); // Passes
-fact(false)->notFalse(); // Fails
-```
-
-
-### Comparison and equality assertions
-```php
-fact(42)->is(42); // Passes
-fact(42)->is('42'); // Fails due to type difference
-
-fact(42)->equals(42); // Passes
-fact(42)->equals('42'); // Passes due to loose comparison
-
-fact(42)->not(43); // Passes
-fact(42)->not(42); // Fails
-```
+fact([2, 4, 6])->every(fn($v) => $v % 2 === 0); // Passes
+fact([1, 2, 3])->every(fn($v) => $v > 5); // Fails
 
+fact([1, 2, 3])->some(fn($v) => $v > 2); // Passes
+fact([1, 2, 3])->some(fn($v) => $v > 10); // Fails
 
-### Null assertions
-```php
-fact(null)->null(); // Passes
-fact('')->null(); // Fails
-
-fact(42)->notNull(); // Passes
-fact(null)->notNull(); // Fails
-```
-
-### Numeric assertions
-```php
-fact(5)->isLowerThan(10); // Passes
-fact(10)->isLowerThan(5); // Fails
-
-fact(10)->isGreaterThan(5); // Passes
-fact(5)->isGreaterThan(10); // Fails
-     
-fact(5)->isPositive(); // Passes
-fact(-3)->isPositive(); // Fails
-
-fact(-3)->isNegative(); // Passes
-fact(5)->isNegative(); // Fails
-
-fact(0)->isZero(); // Passes
-fact(0.0)->isZero(); // Passes
-fact(1)->isZero(); // Fails
-
-fact(5)->isBetween(1, 10); // Passes
-fact(15)->isBetween(1, 10); // Fails
-```
-
-### Special assertions
-```php
+fact([1, 2, 3])->none(fn($v) => $v > 10); // Passes
+fact([1, 2, 3])->none(fn($v) => $v > 2); // Fails
 ```
 
 ### String assertions
@@ -174,6 +118,8 @@ fact('invalid json')->isJson(); // Fails
 fact('[email protected]')->isValidEmail(); // Passes
 fact('invalid-email')->isValidEmail(); // Fails
 
+fact('01ARZ3NDEKTSV4RRFFQ69G5FAV')->ulid(); // Passes (if valid ULID)
+fact('invalid-ulid')->ulid(); // Fails
 ```
 
 ### Type Checking assertions

src/FluentAssertions.php

@@ -9,7 +9,6 @@
 use K2gl\PHPUnitFluentAssertions\Traits\ComparisonAndEqualityAssertions;
 use K2gl\PHPUnitFluentAssertions\Traits\NullAssertions;
 use K2gl\PHPUnitFluentAssertions\Traits\NumericAssertions;
-use K2gl\PHPUnitFluentAssertions\Traits\SpecialAssertions;
 use K2gl\PHPUnitFluentAssertions\Traits\StringAssertions;
 use K2gl\PHPUnitFluentAssertions\Traits\TypeCheckingAssertions;
 
@@ -22,7 +21,6 @@ class FluentAssertions
     use StringAssertions;
     use ArrayAssertions;
     use TypeCheckingAssertions;
-    use SpecialAssertions;
 
     public function __construct(
         public readonly mixed $variable = null

src/Traits/ArrayAssertions.php

@@ -240,4 +240,103 @@ public function isNotEmptyArray(string $message = ''): self
 
         return $this;
     }
+
+    /**
+     * Asserts that every element in the array satisfies the given callback.
+     *
+     * This method checks if all elements pass the condition defined by the callback.
+     * The callback receives the value and optionally the key.
+     *
+     * Example usage:
+     * fact([2, 4, 6])->every(fn($v) => $v % 2 === 0); // Passes
+     * fact([1, 2, 3])->every(fn($v) => $v > 5); // Fails
+     *
+     * @param callable $callback The function to test each element (receives value and key).
+     * @param string $message Optional custom error message.
+     *
+     * @return self Enables fluent chaining of assertion methods.
+     */
+    public function every(callable $callback, string $message = ''): self
+    {
+        $array = $this->variable;
+        if (!is_array($array)) {
+            Assert::assertTrue(false, $message ?: 'Variable is not an array.');
+        }
+        if (empty($array)) {
+            Assert::assertTrue(false, $message ?: 'Array is empty, cannot evaluate condition on elements.');
+        }
+        foreach ($array as $key => $value) {
+            if (!$callback($value, $key)) {
+                Assert::assertTrue(false, $message ?: 'Not all elements satisfy the condition.');
+            }
+        }
+        Assert::assertTrue(true, $message);
+        return $this;
+    }
+
+    /**
+     * Asserts that at least one element in the array satisfies the given callback.
+     *
+     * This method checks if any element passes the condition defined by the callback.
+     * The callback receives the value and optionally the key.
+     *
+     * Example usage:
+     * fact([1, 2, 3])->some(fn($v) => $v > 2); // Passes
+     * fact([1, 2, 3])->some(fn($v) => $v > 10); // Fails
+     *
+     * @param callable $callback The function to test each element (receives value and key).
+     * @param string $message Optional custom error message.
+     *
+     * @return self Enables fluent chaining of assertion methods.
+     */
+    public function some(callable $callback, string $message = ''): self
+    {
+        $array = $this->variable;
+        if (!is_array($array)) {
+            Assert::assertTrue(false, $message ?: 'Variable is not an array.');
+        }
+        if (empty($array)) {
+            Assert::assertTrue(false, $message ?: 'Array is empty, cannot evaluate condition on elements.');
+        }
+        foreach ($array as $key => $value) {
+            if ($callback($value, $key)) {
+                Assert::assertTrue(true, $message);
+                return $this;
+            }
+        }
+        Assert::assertTrue(false, $message ?: 'No elements satisfy the condition.');
+    }
+
+    /**
+     * Asserts that no elements in the array satisfy the given callback.
+     *
+     * This method checks if none of the elements pass the condition defined by the callback.
+     * The callback receives the value and optionally the key.
+     *
+     * Example usage:
+     * fact([1, 2, 3])->none(fn($v) => $v > 10); // Passes
+     * fact([1, 2, 3])->none(fn($v) => $v > 2); // Fails
+     *
+     * @param callable $callback The function to test each element (receives value and key).
+     * @param string $message Optional custom error message.
+     *
+     * @return self Enables fluent chaining of assertion methods.
+     */
+    public function none(callable $callback, string $message = ''): self
+    {
+        $array = $this->variable;
+        if (!is_array($array)) {
+            Assert::assertTrue(false, $message ?: 'Variable is not an array.');
+        }
+        if (empty($array)) {
+            Assert::assertTrue(false, $message ?: 'Array is empty, cannot evaluate condition on elements.');
+        }
+        foreach ($array as $key => $value) {
+            if ($callback($value, $key)) {
+                Assert::assertTrue(false, $message ?: 'At least one element satisfies the condition.');
+            }
+        }
+        Assert::assertTrue(true, $message);
+        return $this;
+    }
 }

src/Traits/SpecialAssertions.php

@@ -27,7 +27,7 @@ trait StringAssertions
      * @param string $pattern The regular expression pattern to match against.
      * @param string $message Optional custom error message.
      *
-     * @return self Enables fluent chaining of assertion methods.
+     * @return StringAssertions|FluentAssertions Enables fluent chaining of assertion methods.
      */
     public function matchesRegularExpression(string $pattern, string $message = ''): self
     {

src/Traits/StringAssertions.php

@@ -0,0 +1,51 @@
+<?php declare(strict_types=1);
+
+namespace K2gl\PHPUnitFluentAssertions\Tests\FluentAssertions\Asserts\Every;
+
+use K2gl\PHPUnitFluentAssertions\Tests\FluentAssertions\FluentAssertionsTestCase;
+use K2gl\PHPUnitFluentAssertions\FluentAssertions;
+use PHPUnit\Framework\Attributes\CoversMethod;
+use PHPUnit\Framework\Attributes\DataProvider;
+
+use function K2gl\PHPUnitFluentAssertions\fact;
+
+#[CoversMethod(className: FluentAssertions::class, methodName: 'every')]
+final class EveryTest extends FluentAssertionsTestCase
+{
+    #[DataProvider('everyDataProvider')]
+    public function testEvery(mixed $variable, callable $callback): void
+    {
+        // act
+        fact($variable)->every($callback);
+
+        // assert
+        $this->correctAssertionExecuted();
+    }
+
+    #[DataProvider('notEveryDataProvider')]
+    public function testNotEvery(mixed $variable, callable $callback): void
+    {
+        // assert
+        $this->incorrectAssertionExpected();
+
+        // act
+        fact($variable)->every($callback);
+    }
+
+    public static function everyDataProvider(): array
+    {
+        return [
+            [[2, 4, 6], fn($v) => $v % 2 === 0],
+            [['a' => 1, 'b' => 3], fn($v, $k) => $v > 0],
+        ];
+    }
+
+    public static function notEveryDataProvider(): array
+    {
+        return [
+            [[1, 2, 3], fn($v) => $v > 5],
+            [[], fn($v) => true], // empty array
+            ['not array', fn($v) => true], // not array
+        ];
+    }
+}

tests/FluentAssertions/Asserts/Every/EveryTest.php

@@ -0,0 +1,51 @@
+<?php declare(strict_types=1);
+
+namespace K2gl\PHPUnitFluentAssertions\Tests\FluentAssertions\Asserts\None;
+
+use K2gl\PHPUnitFluentAssertions\Tests\FluentAssertions\FluentAssertionsTestCase;
+use K2gl\PHPUnitFluentAssertions\FluentAssertions;
+use PHPUnit\Framework\Attributes\CoversMethod;
+use PHPUnit\Framework\Attributes\DataProvider;
+
+use function K2gl\PHPUnitFluentAssertions\fact;
+
+#[CoversMethod(className: FluentAssertions::class, methodName: 'none')]
+final class NoneTest extends FluentAssertionsTestCase
+{
+    #[DataProvider('noneDataProvider')]
+    public function testNone(mixed $variable, callable $callback): void
+    {
+        // act
+        fact($variable)->none($callback);
+
+        // assert
+        $this->correctAssertionExecuted();
+    }
+
+    #[DataProvider('notNoneDataProvider')]
+    public function testNotNone(mixed $variable, callable $callback): void
+    {
+        // assert
+        $this->incorrectAssertionExpected();
+
+        // act
+        fact($variable)->none($callback);
+    }
+
+    public static function noneDataProvider(): array
+    {
+        return [
+            [[1, 2, 3], fn($v) => $v > 10],
+            [['a' => 1, 'b' => 2], fn($v, $k) => $k === 'c'],
+        ];
+    }
+
+    public static function notNoneDataProvider(): array
+    {
+        return [
+            [[1, 2, 3], fn($v) => $v > 2],
+            [[], fn($v) => true], // empty array
+            ['not array', fn($v) => true], // not array
+        ];
+    }
+}

tests/FluentAssertions/Asserts/None/NoneTest.php

@@ -0,0 +1,51 @@
+<?php declare(strict_types=1);
+
+namespace K2gl\PHPUnitFluentAssertions\Tests\FluentAssertions\Asserts\Some;
+
+use K2gl\PHPUnitFluentAssertions\Tests\FluentAssertions\FluentAssertionsTestCase;
+use K2gl\PHPUnitFluentAssertions\FluentAssertions;
+use PHPUnit\Framework\Attributes\CoversMethod;
+use PHPUnit\Framework\Attributes\DataProvider;
+
+use function K2gl\PHPUnitFluentAssertions\fact;
+
+#[CoversMethod(className: FluentAssertions::class, methodName: 'some')]
+final class SomeTest extends FluentAssertionsTestCase
+{
+    #[DataProvider('someDataProvider')]
+    public function testSome(mixed $variable, callable $callback): void
+    {
+        // act
+        fact($variable)->some($callback);
+
+        // assert
+        $this->correctAssertionExecuted();
+    }
+
+    #[DataProvider('notSomeDataProvider')]
+    public function testNotSome(mixed $variable, callable $callback): void
+    {
+        // assert
+        $this->incorrectAssertionExpected();
+
+        // act
+        fact($variable)->some($callback);
+    }
+
+    public static function someDataProvider(): array
+    {
+        return [
+            [[1, 2, 3], fn($v) => $v > 2],
+            [['a' => 1, 'b' => 2], fn($v, $k) => $k === 'b'],
+        ];
+    }
+
+    public static function notSomeDataProvider(): array
+    {
+        return [
+            [[1, 2, 3], fn($v) => $v > 10],
+            [[], fn($v) => true], // empty array
+            ['not array', fn($v) => true], // not array
+        ];
+    }
+}