Update the validation engine of simple rules

By "simple," I mean rules that have nothing in their constructor or that
have simple templates. This change introduces two classes that will be
the foundation for migrating all the rules to the newest validation
engine:

* Standard: this abstract rule contains only the accessors to define and
  retrieve names and templates, which means that the classes that extend
  it must implement the "evaluate()" method.

* Simple: this abstract rule contains the "evaluate()" method, which
  relies on the "validate()" method, which means that the classes that
  extend it must implement that method.

I expect many changes to the Simple abstract rule once all the rules get
migrated to the newest validation engine. I've chosen to keep relying on
the "validate()" method because it will make it easier to migrate
everything.

The "Standard" abstract rule uses a trait that triggers an
"E_USER_DEPRECATED" error in every method from the old validation
engine. That aims to support the migration because I can see clearly if
any places still use the methods I would like to delete once I migrate
everything.

Signed-off-by: Henrique Moody <henriquemoody@gmail.com>

library/Helpers/DeprecatedValidatableMethods.php

@@ -0,0 +1,70 @@
+<?php
+
+/*
+ * Copyright (c) Alexandre Gomes Gaigalas <alganet@gmail.com>
+ * SPDX-License-Identifier: MIT
+ */
+
+declare(strict_types=1);
+
+namespace Respect\Validation\Helpers;
+
+use Respect\Validation\Exceptions\ValidationException;
+use Respect\Validation\Message\Parameter\Stringify;
+use Respect\Validation\Message\TemplateRenderer;
+
+use function sprintf;
+use function trigger_error;
+
+use const E_USER_DEPRECATED;
+
+trait DeprecatedValidatableMethods
+{
+    public function validate(mixed $input): bool
+    {
+        $this->triggerDeprecation(__METHOD__);
+
+        return false;
+    }
+
+    public function assert(mixed $input): void
+    {
+        $this->triggerDeprecation(__FUNCTION__);
+    }
+
+    public function check(mixed $input): void
+    {
+        $this->triggerDeprecation(__FUNCTION__);
+    }
+
+    /** @param array<string, mixed> $extraParameters */
+    public function reportError(mixed $input, array $extraParameters = []): ValidationException
+    {
+        $this->triggerDeprecation(__FUNCTION__);
+
+        return new ValidationException(
+            input: $input,
+            id:  'id',
+            params: $extraParameters,
+            template: 'template',
+            templates: [],
+            formatter: new TemplateRenderer(static fn (string $message) => $message, new Stringify()),
+        );
+    }
+
+    /** @return array<string, mixed> */
+    public function getParams(): array
+    {
+        $this->triggerDeprecation(__FUNCTION__);
+
+        return [];
+    }
+
+    private function triggerDeprecation(string $function): void
+    {
+        trigger_error(
+            sprintf('The "%s" method is deprecated, please use the "Validator" class instead.', $function),
+            E_USER_DEPRECATED
+        );
+    }
+}

library/Rules/AlwaysInvalid.php

@@ -21,7 +21,7 @@ use Respect\Validation\Message\Template;
     '{{name}} is valid',
     self::TEMPLATE_SIMPLE,
 )]
-final class AlwaysInvalid extends AbstractRule
+final class AlwaysInvalid extends Simple
 {
     public const TEMPLATE_SIMPLE = '__simple__';
 

library/Rules/AlwaysValid.php

@@ -15,7 +15,7 @@ use Respect\Validation\Message\Template;
     '{{name}} is always valid',
     '{{name}} is always invalid',
 )]
-final class AlwaysValid extends AbstractRule
+final class AlwaysValid extends Simple
 {
     public function validate(mixed $input): bool
     {

library/Rules/ArrayType.php

@@ -17,7 +17,7 @@ use function is_array;
     '{{name}} must be of type array',
     '{{name}} must not be of type array',
 )]
-final class ArrayType extends AbstractRule
+final class ArrayType extends Simple
 {
     public function validate(mixed $input): bool
     {

library/Rules/ArrayVal.php

@@ -19,7 +19,7 @@ use function is_array;
     '{{name}} must be an array value',
     '{{name}} must not be an array value',
 )]
-final class ArrayVal extends AbstractRule
+final class ArrayVal extends Simple
 {
     public function validate(mixed $input): bool
     {

library/Rules/Base64.php

@@ -19,7 +19,7 @@ use function preg_match;
     '{{name}} must be Base64-encoded',
     '{{name}} must not be Base64-encoded',
 )]
-final class Base64 extends AbstractRule
+final class Base64 extends Simple
 {
     public function validate(mixed $input): bool
     {

library/Rules/BoolType.php

@@ -17,7 +17,7 @@ use function is_bool;
     '{{name}} must be of type boolean',
     '{{name}} must not be of type boolean',
 )]
-final class BoolType extends AbstractRule
+final class BoolType extends Simple
 {
     public function validate(mixed $input): bool
     {

library/Rules/BoolVal.php

@@ -21,7 +21,7 @@ use const FILTER_VALIDATE_BOOLEAN;
     '{{name}} must be a boolean value',
     '{{name}} must not be a boolean value',
 )]
-final class BoolVal extends AbstractRule
+final class BoolVal extends Simple
 {
     public function validate(mixed $input): bool
     {

library/Rules/Bsn.php

@@ -24,7 +24,7 @@ use function strval;
     '{{name}} must be a BSN',
     '{{name}} must not be a BSN',
 )]
-final class Bsn extends AbstractRule
+final class Bsn extends Simple
 {
     public function validate(mixed $input): bool
     {

library/Rules/CallableType.php

@@ -17,7 +17,7 @@ use function is_callable;
     '{{name}} must be callable',
     '{{name}} must not be callable',
 )]
-final class CallableType extends AbstractRule
+final class CallableType extends Simple
 {
     public function validate(mixed $input): bool
     {

library/Rules/Callback.php

@@ -19,7 +19,7 @@ use function count;
     '{{name}} must be valid',
     '{{name}} must not be valid',
 )]
-final class Callback extends AbstractRule
+final class Callback extends Simple
 {
     /**
      * @var callable

library/Rules/Cnh.php

@@ -19,7 +19,7 @@ use function preg_replace;
     '{{name}} must be a valid CNH number',
     '{{name}} must not be a valid CNH number',
 )]
-final class Cnh extends AbstractRule
+final class Cnh extends Simple
 {
     public function validate(mixed $input): bool
     {

library/Rules/Cnpj.php

@@ -22,7 +22,7 @@ use function str_split;
     '{{name}} must be a valid CNPJ number',
     '{{name}} must not be a valid CNPJ number',
 )]
-final class Cnpj extends AbstractRule
+final class Cnpj extends Simple
 {
     public function validate(mixed $input): bool
     {

library/Rules/Countable.php

@@ -18,7 +18,7 @@ use function is_array;
     '{{name}} must be countable',
     '{{name}} must not be countable',
 )]
-final class Countable extends AbstractRule
+final class Countable extends Simple
 {
     public function validate(mixed $input): bool
     {

library/Rules/Cpf.php

@@ -20,7 +20,7 @@ use function preg_replace;
     '{{name}} must be a valid CPF number',
     '{{name}} must not be a valid CPF number',
 )]
-final class Cpf extends AbstractRule
+final class Cpf extends Simple
 {
     public function validate(mixed $input): bool
     {

library/Rules/Directory.php

@@ -20,7 +20,7 @@ use function is_scalar;
     '{{name}} must be a directory',
     '{{name}} must not be a directory',
 )]
-final class Directory extends AbstractRule
+final class Directory extends Simple
 {
     public function validate(mixed $input): bool
     {

library/Rules/Email.php

@@ -24,7 +24,7 @@ use const FILTER_VALIDATE_EMAIL;
     '{{name}} must be valid email',
     '{{name}} must not be an email',
 )]
-final class Email extends AbstractRule
+final class Email extends Simple
 {
     private readonly ?EmailValidator $validator;
 

library/Rules/Even.php

@@ -19,7 +19,7 @@ use const FILTER_VALIDATE_INT;
     '{{name}} must be an even number',
     '{{name}} must not be an even number',
 )]
-final class Even extends AbstractRule
+final class Even extends Simple
 {
     public function validate(mixed $input): bool
     {

library/Rules/Executable.php

@@ -19,7 +19,7 @@ use function is_scalar;
     '{{name}} must be an executable file',
     '{{name}} must not be an executable file',
 )]
-final class Executable extends AbstractRule
+final class Executable extends Simple
 {
     public function validate(mixed $input): bool
     {

library/Rules/Exists.php

@@ -19,7 +19,7 @@ use function is_string;
     '{{name}} must exist',
     '{{name}} must not exist',
 )]
-final class Exists extends AbstractRule
+final class Exists extends Simple
 {
     public function validate(mixed $input): bool
     {

library/Rules/FalseVal.php

@@ -20,7 +20,7 @@ use const FILTER_VALIDATE_BOOLEAN;
     '{{name}} must evaluate to `false`',
     '{{name}} must not evaluate to `false`',
 )]
-final class FalseVal extends AbstractRule
+final class FalseVal extends Simple
 {
     public function validate(mixed $input): bool
     {

library/Rules/Fibonacci.php

@@ -17,7 +17,7 @@ use function is_numeric;
     '{{name}} must be a valid Fibonacci number',
     '{{name}} must not be a valid Fibonacci number',
 )]
-final class Fibonacci extends AbstractRule
+final class Fibonacci extends Simple
 {
     public function validate(mixed $input): bool
     {

library/Rules/File.php

@@ -19,7 +19,7 @@ use function is_string;
     '{{name}} must be a file',
     '{{name}} must not be a file',
 )]
-final class File extends AbstractRule
+final class File extends Simple
 {
     public function validate(mixed $input): bool
     {

library/Rules/Finite.php

@@ -18,7 +18,7 @@ use function is_numeric;
     '{{name}} must be a finite number',
     '{{name}} must not be a finite number',
 )]
-final class Finite extends AbstractRule
+final class Finite extends Simple
 {
     public function validate(mixed $input): bool
     {

library/Rules/FloatType.php

@@ -17,7 +17,7 @@ use function is_float;
     '{{name}} must be of type float',
     '{{name}} must not be of type float',
 )]
-final class FloatType extends AbstractRule
+final class FloatType extends Simple
 {
     public function validate(mixed $input): bool
     {

library/Rules/FloatVal.php

@@ -20,7 +20,7 @@ use const FILTER_VALIDATE_FLOAT;
     '{{name}} must be a float number',
     '{{name}} must not be a float number',
 )]
-final class FloatVal extends AbstractRule
+final class FloatVal extends Simple
 {
     public function validate(mixed $input): bool
     {

library/Rules/Image.php

@@ -23,7 +23,7 @@ use const FILEINFO_MIME_TYPE;
     '{{name}} must be a valid image',
     '{{name}} must not be a valid image',
 )]
-final class Image extends AbstractRule
+final class Image extends Simple
 {
     private readonly finfo $fileInfo;
 

library/Rules/Imei.php

@@ -19,7 +19,7 @@ use function preg_replace;
     '{{name}} must be a valid IMEI',
     '{{name}} must not be a valid IMEI',
 )]
-final class Imei extends AbstractRule
+final class Imei extends Simple
 {
     private const IMEI_SIZE = 15;
 

library/Rules/Infinite.php

@@ -18,7 +18,7 @@ use function is_numeric;
     '{{name}} must be an infinite number',
     '{{name}} must not be an infinite number',
 )]
-final class Infinite extends AbstractRule
+final class Infinite extends Simple
 {
     public function validate(mixed $input): bool
     {

library/Rules/IntType.php

@@ -17,7 +17,7 @@ use function is_int;
     '{{name}} must be of type integer',
     '{{name}} must not be of type integer',
 )]
-final class IntType extends AbstractRule
+final class IntType extends Simple
 {
     public function validate(mixed $input): bool
     {

library/Rules/IntVal.php

@@ -19,7 +19,7 @@ use function preg_match;
     '{{name}} must be an integer number',
     '{{name}} must not be an integer number',
 )]
-final class IntVal extends AbstractRule
+final class IntVal extends Simple
 {
     public function validate(mixed $input): bool
     {

library/Rules/Isbn.php

@@ -20,7 +20,7 @@ use function sprintf;
     '{{name}} must be a ISBN',
     '{{name}} must not be a ISBN',
 )]
-final class Isbn extends AbstractRule
+final class Isbn extends Simple
 {
     /**
      * @see https://howtodoinjava.com/regex/java-regex-validate-international-standard-book-number-isbns

library/Rules/IterableType.php

@@ -16,7 +16,7 @@ use Respect\Validation\Message\Template;
     '{{name}} must be iterable',
     '{{name}} must not be iterable',
 )]
-final class IterableType extends AbstractRule
+final class IterableType extends Simple
 {
     use CanValidateIterable;
 

library/Rules/Json.php

@@ -23,7 +23,7 @@ use const JSON_ERROR_NONE;
     '{{name}} must be a valid JSON string',
     '{{name}} must not be a valid JSON string',
 )]
-final class Json extends AbstractRule
+final class Json extends Simple
 {
     public function validate(mixed $input): bool
     {

library/Rules/LeapDate.php

@@ -19,7 +19,7 @@ use function is_scalar;
     '{{name}} must be leap date',
     '{{name}} must not be leap date',
 )]
-final class LeapDate extends AbstractRule
+final class LeapDate extends Simple
 {
     public function __construct(
         private readonly string $format

library/Rules/LeapYear.php

@@ -22,7 +22,7 @@ use function strtotime;
     '{{name}} must be a leap year',
     '{{name}} must not be a leap year',
 )]
-final class LeapYear extends AbstractRule
+final class LeapYear extends Simple
 {
     public function validate(mixed $input): bool
     {

library/Rules/Lowercase.php

@@ -18,7 +18,7 @@ use function mb_strtolower;
     '{{name}} must be lowercase',
     '{{name}} must not be lowercase',
 )]
-final class Lowercase extends AbstractRule
+final class Lowercase extends Simple
 {
     public function validate(mixed $input): bool
     {

library/Rules/Luhn.php

@@ -22,7 +22,7 @@ use function str_split;
     '{{name}} must be a valid Luhn number',
     '{{name}} must not be a valid Luhn number',
 )]
-final class Luhn extends AbstractRule
+final class Luhn extends Simple
 {
     public function validate(mixed $input): bool
     {

library/Rules/MacAddress.php

@@ -18,7 +18,7 @@ use function preg_match;
     '{{name}} must be a valid MAC address',
     '{{name}} must not be a valid MAC address',
 )]
-final class MacAddress extends AbstractRule
+final class MacAddress extends Simple
 {
     public function validate(mixed $input): bool
     {

library/Rules/Negative.php

@@ -17,7 +17,7 @@ use function is_numeric;
     '{{name}} must be negative',
     '{{name}} must not be negative',
 )]
-final class Negative extends AbstractRule
+final class Negative extends Simple
 {
     public function validate(mixed $input): bool
     {

library/Rules/NfeAccessKey.php

@@ -23,7 +23,7 @@ use function str_split;
     '{{name}} must be a valid NFe access key',
     '{{name}} must not be a valid NFe access key',
 )]
-final class NfeAccessKey extends AbstractRule
+final class NfeAccessKey extends Simple
 {
     public function validate(mixed $input): bool
     {

library/Rules/Nif.php

@@ -26,7 +26,7 @@ use function str_split;
     '{{name}} must be a NIF',
     '{{name}} must not be a NIF',
 )]
-final class Nif extends AbstractRule
+final class Nif extends Simple
 {
     public function validate(mixed $input): bool
     {

library/Rules/Nip.php

@@ -23,7 +23,7 @@ use function str_split;
     '{{name}} must be a valid Polish VAT identification number',
     '{{name}} must not be a valid Polish VAT identification number',
 )]
-final class Nip extends AbstractRule
+final class Nip extends Simple
 {
     public function validate(mixed $input): bool
     {

library/Rules/NoWhitespace.php

@@ -19,7 +19,7 @@ use function preg_match;
     '{{name}} must not contain whitespace',
     '{{name}} must contain whitespace',
 )]
-final class NoWhitespace extends AbstractRule
+final class NoWhitespace extends Simple
 {
     public function validate(mixed $input): bool
     {

library/Rules/NotEmoji.php

@@ -19,7 +19,7 @@ use function preg_match;
     '{{name}} must not contain an Emoji',
     '{{name}} must contain an Emoji',
 )]
-final class NotEmoji extends AbstractRule
+final class NotEmoji extends Simple
 {
     private const RANGES = [
         '\x{0023}\x{FE0F}\x{20E3}',

library/Rules/NullType.php

@@ -17,7 +17,7 @@ use function is_null;
     '{{name}} must be null',
     '{{name}} must not be null',
 )]
-final class NullType extends AbstractRule
+final class NullType extends Simple
 {
     public function validate(mixed $input): bool
     {

library/Rules/Number.php

@@ -18,7 +18,7 @@ use function is_numeric;
     '{{name}} must be a number',
     '{{name}} must not be a number',
 )]
-final class Number extends AbstractRule
+final class Number extends Simple
 {
     public function validate(mixed $input): bool
     {

library/Rules/NumericVal.php

@@ -17,7 +17,7 @@ use function is_numeric;
     '{{name}} must be numeric',
     '{{name}} must not be numeric',
 )]
-final class NumericVal extends AbstractRule
+final class NumericVal extends Simple
 {
     public function validate(mixed $input): bool
     {

library/Rules/ObjectType.php

@@ -17,7 +17,7 @@ use function is_object;
     '{{name}} must be of type object',
     '{{name}} must not be of type object',
 )]
-final class ObjectType extends AbstractRule
+final class ObjectType extends Simple
 {
     public function validate(mixed $input): bool
     {

library/Rules/Odd.php

@@ -20,7 +20,7 @@ use const FILTER_VALIDATE_INT;
     '{{name}} must be an odd number',
     '{{name}} must not be an odd number',
 )]
-final class Odd extends AbstractRule
+final class Odd extends Simple
 {
     public function validate(mixed $input): bool
     {

library/Rules/PerfectSquare.php

@@ -19,7 +19,7 @@ use function sqrt;
     '{{name}} must be a valid perfect square',
     '{{name}} must not be a valid perfect square',
 )]
-final class PerfectSquare extends AbstractRule
+final class PerfectSquare extends Simple
 {
     public function validate(mixed $input): bool
     {

library/Rules/Pesel.php

@@ -18,7 +18,7 @@ use function preg_match;
     '{{name}} must be a valid PESEL',
     '{{name}} must not be a valid PESEL',
 )]
-final class Pesel extends AbstractRule
+final class Pesel extends Simple
 {
     public function validate(mixed $input): bool
     {

library/Rules/PhpLabel.php

@@ -18,7 +18,7 @@ use function preg_match;
     '{{name}} must be a valid PHP label',
     '{{name}} must not be a valid PHP label',
 )]
-final class PhpLabel extends AbstractRule
+final class PhpLabel extends Simple
 {
     public function validate(mixed $input): bool
     {

library/Rules/Pis.php

@@ -20,7 +20,7 @@ use function preg_replace;
     '{{name}} must be a valid PIS number',
     '{{name}} must not be a valid PIS number',
 )]
-final class Pis extends AbstractRule
+final class Pis extends Simple
 {
     public function validate(mixed $input): bool
     {

library/Rules/PolishIdCard.php

@@ -22,7 +22,7 @@ use function preg_match;
     '{{name}} must be a valid Polish Identity Card number',
     '{{name}} must not be a valid Polish Identity Card number',
 )]
-final class PolishIdCard extends AbstractRule
+final class PolishIdCard extends Simple
 {
     private const ASCII_CODE_0 = 48;
     private const ASCII_CODE_7 = 55;

library/Rules/PortugueseNif.php

@@ -28,7 +28,7 @@ use function strlen;
     '{{name}} must be a Portuguese NIF',
     '{{name}} must not be a Portuguese NIF',
 )]
-final class PortugueseNif extends AbstractRule
+final class PortugueseNif extends Simple
 {
     public function validate(mixed $input): bool
     {

library/Rules/Positive.php

@@ -17,7 +17,7 @@ use function is_numeric;
     '{{name}} must be positive',
     '{{name}} must not be positive',
 )]
-final class Positive extends AbstractRule
+final class Positive extends Simple
 {
     public function validate(mixed $input): bool
     {

library/Rules/PrimeNumber.php

@@ -19,7 +19,7 @@ use function sqrt;
     '{{name}} must be a valid prime number',
     '{{name}} must not be a valid prime number',
 )]
-final class PrimeNumber extends AbstractRule
+final class PrimeNumber extends Simple
 {
     public function validate(mixed $input): bool
     {

library/Rules/PublicDomainSuffix.php

@@ -23,7 +23,7 @@ use function strtoupper;
     '{{name}} must be a public domain suffix',
     '{{name}} must be a public domain suffix',
 )]
-final class PublicDomainSuffix extends AbstractRule
+final class PublicDomainSuffix extends Simple
 {
     use CanValidateUndefined;
 

library/Rules/Readable.php

@@ -20,7 +20,7 @@ use function is_string;
     '{{name}} must be readable',
     '{{name}} must not be readable',
 )]
-final class Readable extends AbstractRule
+final class Readable extends Simple
 {
     public function validate(mixed $input): bool
     {

library/Rules/ResourceType.php

@@ -17,7 +17,7 @@ use function is_resource;
     '{{name}} must be a resource',
     '{{name}} must not be a resource',
 )]
-final class ResourceType extends AbstractRule
+final class ResourceType extends Simple
 {
     public function validate(mixed $input): bool
     {

library/Rules/ScalarVal.php

@@ -17,7 +17,7 @@ use function is_scalar;
     '{{name}} must be a scalar value',
     '{{name}} must not be a scalar value',
 )]
-final class ScalarVal extends AbstractRule
+final class ScalarVal extends Simple
 {
     public function validate(mixed $input): bool
     {

library/Rules/Simple.php

@@ -0,0 +1,20 @@
+<?php
+
+/*
+ * Copyright (c) Alexandre Gomes Gaigalas <alganet@gmail.com>
+ * SPDX-License-Identifier: MIT
+ */
+
+declare(strict_types=1);
+
+namespace Respect\Validation\Rules;
+
+use Respect\Validation\Result;
+
+abstract class Simple extends Standard
+{
+    public function evaluate(mixed $input): Result
+    {
+        return new Result($this->validate($input), $input, $this, self::TEMPLATE_STANDARD);
+    }
+}

library/Rules/Slug.php

@@ -19,7 +19,7 @@ use function preg_match;
     '{{name}} must be a valid slug',
     '{{name}} must not be a valid slug',
 )]
-final class Slug extends AbstractRule
+final class Slug extends Simple
 {
     public function validate(mixed $input): bool
     {

library/Rules/Standard.php

@@ -0,0 +1,46 @@
+<?php
+
+/*
+ * Copyright (c) Alexandre Gomes Gaigalas <alganet@gmail.com>
+ * SPDX-License-Identifier: MIT
+ */
+
+declare(strict_types=1);
+
+namespace Respect\Validation\Rules;
+
+use Respect\Validation\Helpers\DeprecatedValidatableMethods;
+use Respect\Validation\Validatable;
+
+abstract class Standard implements Validatable
+{
+    use DeprecatedValidatableMethods;
+
+    private ?string $name = null;
+
+    private ?string $template = null;
+
+    public function getName(): ?string
+    {
+        return $this->name;
+    }
+
+    public function setName(string $name): static
+    {
+        $this->name = $name;
+
+        return $this;
+    }
+
+    public function getTemplate(): ?string
+    {
+        return $this->template;
+    }
+
+    public function setTemplate(string $template): static
+    {
+        $this->template = $template;
+
+        return $this;
+    }
+}

library/Rules/StringType.php

@@ -17,7 +17,7 @@ use function is_string;
     '{{name}} must be of type string',
     '{{name}} must not be of type string',
 )]
-final class StringType extends AbstractRule
+final class StringType extends Simple
 {
     public function validate(mixed $input): bool
     {

library/Rules/StringVal.php

@@ -19,7 +19,7 @@ use function method_exists;
     '{{name}} must be a string',
     '{{name}} must not be string',
 )]
-final class StringVal extends AbstractRule
+final class StringVal extends Simple
 {
     public function validate(mixed $input): bool
     {

library/Rules/SymbolicLink.php

@@ -19,7 +19,7 @@ use function is_string;
     '{{name}} must be a symbolic link',
     '{{name}} must not be a symbolic link',
 )]
-final class SymbolicLink extends AbstractRule
+final class SymbolicLink extends Simple
 {
     public function validate(mixed $input): bool
     {

library/Rules/Tld.php

@@ -19,7 +19,7 @@ use function mb_strtoupper;
     '{{name}} must be a valid top-level domain name',
     '{{name}} must not be a valid top-level domain name',
 )]
-final class Tld extends AbstractRule
+final class Tld extends Simple
 {
     // List extracted from https://data.iana.org/TLD/tlds-alpha-by-domain.txt
     private const TLD_LIST = [

library/Rules/TrueVal.php

@@ -20,7 +20,7 @@ use const FILTER_VALIDATE_BOOLEAN;
     '{{name}} must evaluate to `true`',
     '{{name}} must not evaluate to `true`',
 )]
-final class TrueVal extends AbstractRule
+final class TrueVal extends Simple
 {
     public function validate(mixed $input): bool
     {

library/Rules/Unique.php

@@ -20,7 +20,7 @@ use const SORT_REGULAR;
     '{{name}} must not contain duplicates',
     '{{name}} must contain duplicates',
 )]
-final class Unique extends AbstractRule
+final class Unique extends Simple
 {
     public function validate(mixed $input): bool
     {

library/Rules/Uploaded.php

@@ -20,7 +20,7 @@ use function is_uploaded_file;
     '{{name}} must be an uploaded file',
     '{{name}} must not be an uploaded file',
 )]
-final class Uploaded extends AbstractRule
+final class Uploaded extends Simple
 {
     public function validate(mixed $input): bool
     {

library/Rules/Uppercase.php

@@ -18,7 +18,7 @@ use function mb_strtoupper;
     '{{name}} must be uppercase',
     '{{name}} must not be uppercase',
 )]
-final class Uppercase extends AbstractRule
+final class Uppercase extends Simple
 {
     public function validate(mixed $input): bool
     {

library/Rules/Version.php

@@ -21,7 +21,7 @@ use function preg_match;
     '{{name}} must be a version',
     '{{name}} must not be a version',
 )]
-final class Version extends AbstractRule
+final class Version extends Simple
 {
     public function validate(mixed $input): bool
     {

library/Rules/Writable.php

@@ -20,7 +20,7 @@ use function is_writable;
     '{{name}} must be writable',
     '{{name}} must not be writable',
 )]
-final class Writable extends AbstractRule
+final class Writable extends Simple
 {
     public function validate(mixed $input): bool
     {

library/Rules/Yes.php

@@ -21,7 +21,7 @@ use const YESEXPR;
     '{{name}} must be similar to "Yes"',
     '{{name}} must not be similar to "Yes"',
 )]
-final class Yes extends AbstractRule
+final class Yes extends Simple
 {
     public function __construct(
         private readonly bool $useLocale = false

tests/library/Rules/ConcreteSimple.php

@@ -0,0 +1,20 @@
+<?php
+
+/*
+ * Copyright (c) Alexandre Gomes Gaigalas <alganet@gmail.com>
+ * SPDX-License-Identifier: MIT
+ */
+
+declare(strict_types=1);
+
+namespace Respect\Validation\Test\Rules;
+
+use Respect\Validation\Rules\Simple;
+
+final class ConcreteSimple extends Simple
+{
+    public function validate(mixed $input): bool
+    {
+        return true;
+    }
+}

tests/library/Rules/ConcreteStandard.php

@@ -0,0 +1,21 @@
+<?php
+
+/*
+ * Copyright (c) Alexandre Gomes Gaigalas <alganet@gmail.com>
+ * SPDX-License-Identifier: MIT
+ */
+
+declare(strict_types=1);
+
+namespace Respect\Validation\Test\Rules;
+
+use Respect\Validation\Result;
+use Respect\Validation\Rules\Standard;
+
+final class ConcreteStandard extends Standard
+{
+    public function evaluate(mixed $input): Result
+    {
+        return Result::passed($input, $this);
+    }
+}

tests/unit/Rules/AlwaysInvalidTest.php

@@ -25,7 +25,7 @@ final class AlwaysInvalidTest extends TestCase
     {
         $rule = new AlwaysInvalid();
 
-        self::assertFalse($rule->validate($input));
+        self::assertFalse($rule->evaluate($input)->isValid);
     }
 
     /**

tests/unit/Rules/AlwaysValidTest.php

@@ -25,7 +25,7 @@ final class AlwaysValidTest extends TestCase
     {
         $rule = new AlwaysValid();
 
-        self::assertTrue($rule->validate($input));
+        self::assertTrue($rule->evaluate($input)->isValid);
     }
 
     /**

tests/unit/Rules/NotTest.php

@@ -13,7 +13,6 @@ use PHPUnit\Framework\Attributes\CoversClass;
 use PHPUnit\Framework\Attributes\DataProvider;
 use PHPUnit\Framework\Attributes\Group;
 use PHPUnit\Framework\Attributes\Test;
-use Respect\Validation\Exceptions\ValidationException;
 use Respect\Validation\Test\TestCase;
 use Respect\Validation\Validatable;
 use Respect\Validation\Validator;
@@ -26,10 +25,9 @@ final class NotTest extends TestCase
     #[DataProvider('providerForValidNot')]
     public function not(Validatable $rule, mixed $input): void
     {
-        $this->expectNotToPerformAssertions();
-
         $not = new Not($rule);
-        $not->assert($input);
+
+        self::assertTrue($not->evaluate($input)->isValid);
     }
 
     #[Test]
@@ -38,9 +36,7 @@ final class NotTest extends TestCase
     {
         $not = new Not($rule);
 
-        $this->expectException(ValidationException::class);
-
-        $not->assert($input);
+        self::assertFalse($not->evaluate($input)->isValid);
     }
 
     #[Test]

tests/unit/Rules/SimpleTest.php

@@ -0,0 +1,46 @@
+<?php
+
+/*
+ * Copyright (c) Alexandre Gomes Gaigalas <alganet@gmail.com>
+ * SPDX-License-Identifier: MIT
+ */
+
+declare(strict_types=1);
+
+namespace Respect\Validation\Rules;
+
+use PHPUnit\Framework\Attributes\CoversClass;
+use PHPUnit\Framework\Attributes\Group;
+use PHPUnit\Framework\Attributes\Test;
+use Respect\Validation\Rule;
+use Respect\Validation\Test\Rules\ConcreteSimple;
+use Respect\Validation\Test\TestCase;
+
+#[Group('core')]
+#[CoversClass(Simple::class)]
+final class SimpleTest extends TestCase
+{
+    #[Test]
+    public function itShouldEvaluateUsingTheValidateMethod(): void
+    {
+        $rule = new ConcreteSimple();
+
+        self::assertTrue($rule->evaluate('any')->isValid);
+    }
+
+    #[Test]
+    public function itShouldEvaluateReturningTheCurrentRule(): void
+    {
+        $rule = new ConcreteSimple();
+
+        self::assertSame($rule, $rule->evaluate('any')->rule);
+    }
+
+    #[Test]
+    public function itShouldEvaluateReturningTheStandardTemplate(): void
+    {
+        $rule = new ConcreteSimple();
+
+        self::assertSame(Rule::TEMPLATE_STANDARD, $rule->evaluate('any')->template);
+    }
+}

tests/unit/Rules/StandardTest.php

@@ -0,0 +1,55 @@
+<?php
+
+/*
+ * Copyright (c) Alexandre Gomes Gaigalas <alganet@gmail.com>
+ * SPDX-License-Identifier: MIT
+ */
+
+declare(strict_types=1);
+
+namespace Respect\Validation\Rules;
+
+use PHPUnit\Framework\Attributes\CoversClass;
+use PHPUnit\Framework\Attributes\Group;
+use PHPUnit\Framework\Attributes\Test;
+use Respect\Validation\Test\Rules\ConcreteStandard;
+use Respect\Validation\Test\TestCase;
+
+#[Group('core')]
+#[CoversClass(Standard::class)]
+final class StandardTest extends TestCase
+{
+    #[Test]
+    public function itShouldNotHaveAnyNameByDefault(): void
+    {
+        $rule = new ConcreteStandard();
+
+        self::assertNull($rule->getName());
+    }
+
+    #[Test]
+    public function itShouldBeAbleToSetName(): void
+    {
+        $rule = new ConcreteStandard();
+        $rule->setName('foo');
+
+        self::assertEquals('foo', $rule->getName());
+    }
+
+    #[Test]
+    public function itShouldNotHaveAnyTemplateByDefault(): void
+    {
+        $rule = new ConcreteStandard();
+
+        self::assertNull($rule->getTemplate());
+    }
+
+    #[Test]
+    public function itShouldBeAbleToSetTemplate(): void
+    {
+        $rule = new ConcreteStandard();
+        $rule->setTemplate('foo');
+
+        self::assertEquals('foo', $rule->getTemplate());
+    }
+}