add non empty string constraint

Author: Baptouuuu

CHANGELOG.md

@@ -6,6 +6,7 @@
 
 - `Innmind\Validation\Constraint::object()`
 - `Innmind\Validation\Constraint::failWith()`
+- `Innmind\Validation\Constraint::string()->nonEmpty()`
 - `Innmind\Validation\Constraint\Provider`
 
 ### Changed

docs/constraints/primitives.md

@@ -7,6 +7,13 @@
     $validate = Is::string();
     ```
 
+=== "`non-empty-string`"
+    ```php
+    use Innmind\Validation\Is;
+
+    $validate = Is::string()->nonEmpty();
+    ```
+
 === "`int`"
     ```php
     use Innmind\Validation\Is;

proofs/is.php

@@ -54,6 +54,68 @@ static function($assert, $string, $other) {
         },
     );
 
+    yield proof(
+        'Is::string()->nonEmpty()',
+        given(
+            Set::strings()->atLeast(1),
+            Set::either(
+                Set::integers(),
+                Set::realNumbers(),
+                Set::of(
+                    true,
+                    false,
+                    null,
+                    new stdClass,
+                ),
+                Set::sequence(Set::strings()),
+            ),
+        ),
+        static function($assert, $string, $other) {
+            $constraint = Is::string()->nonEmpty();
+
+            $assert->true(
+                $constraint->asPredicate()($string),
+            );
+            $assert->same(
+                $string,
+                $constraint($string)->match(
+                    static fn($value) => $value,
+                    static fn() => null,
+                ),
+            );
+            $assert->false(
+                $constraint->asPredicate()($other),
+            );
+            $assert->same(
+                [['$', 'Value is not of type string']],
+                $constraint($other)->match(
+                    static fn() => null,
+                    static fn($failures) => $failures
+                        ->map(static fn($failure) => [
+                            $failure->path()->toString(),
+                            $failure->message(),
+                        ])
+                        ->toList(),
+                ),
+            );
+            $assert->false(
+                $constraint->asPredicate()(''),
+            );
+            $assert->same(
+                [['$', 'String cannot be empty']],
+                $constraint('')->match(
+                    static fn() => null,
+                    static fn($failures) => $failures
+                        ->map(static fn($failure) => [
+                            $failure->path()->toString(),
+                            $failure->message(),
+                        ])
+                        ->toList(),
+                ),
+            );
+        },
+    );
+
     yield proof(
         'Is::string()->withFailure()',
         given(

src/Constraint.php

@@ -62,12 +62,10 @@ public static function object(): Provider\Objet
 
     /**
      * @psalm-pure
-     *
-     * @return self<mixed, string>
      */
-    public static function string(): self
+    public static function string(): Provider\Str
     {
-        return new self(Constraint\Primitive::string());
+        return Provider\Str::of(self::build(...));
     }
 
     /**

src/Constraint/Like.php

@@ -86,6 +86,18 @@ public function failWith(string $message): Constraint
             ->failWith($message);
     }
 
+    /**
+     * @deprecated Use self::failWith(), this method exist for backaward compatibility
+     *
+     * @param non-empty-string $message
+     *
+     * @return Constraint<I, O>
+     */
+    public function withFailure(string $message): Constraint
+    {
+        return $this->failWith($message);
+    }
+
     /**
      * @return Predicate<O>
      */

src/Constraint/Provider/Str.php

@@ -0,0 +1,63 @@
+<?php
+declare(strict_types = 1);
+
+namespace Innmind\Validation\Constraint\Provider;
+
+use Innmind\Validation\{
+    Constraint,
+    Constraint\Provider,
+    Constraint\Implementation,
+    Constraint\Primitive,
+    Constraint\Like,
+    Failure,
+};
+use Innmind\Immutable\Validation;
+
+/**
+ * @psalm-immutable
+ * @implements Provider<mixed, string>
+ */
+final class Str implements Provider
+{
+    /** @use Like<mixed, string> */
+    use Like;
+
+    /**
+     * @param pure-Closure(Implementation): Constraint $build
+     */
+    private function __construct(
+        private \Closure $build,
+    ) {
+    }
+
+    /**
+     * @internal
+     * @psalm-pure
+     *
+     * @param pure-Closure(Implementation): Constraint $build
+     */
+    public static function of(\Closure $build): self
+    {
+        return new self($build);
+    }
+
+    #[\Override]
+    public function toConstraint(): Constraint
+    {
+        /** @var Constraint<mixed, string> */
+        return ($this->build)(Primitive::string());
+    }
+
+    /**
+     * @return Constraint<mixed, non-empty-string>
+     */
+    public function nonEmpty(): Constraint
+    {
+        return $this
+            ->toConstraint()
+            ->and(Constraint::of(static fn(string $string) => match ($string) {
+                '' => Validation::fail(Failure::of('String cannot be empty')),
+                default => Validation::success($string),
+            }));
+    }
+}

src/Is.php

@@ -21,10 +21,8 @@ private function __construct()
 
     /**
      * @psalm-pure
-     *
-     * @return Constraint<mixed, string>
      */
-    public static function string(): Constraint
+    public static function string(): Provider\Str
     {
         return Constraint::string();
     }