Sync with 1.x branch

.github/PULL_REQUEST_TEMPLATE.md

@@ -3,4 +3,3 @@
 | Is bugfix?    | ✔️/❌
 | New feature?  | ✔️/❌
 | Breaks BC?    | ✔️/❌
-| Fixed issues  | <!-- comma-separated list of tickets # fixed by the PR, if any -->

.github/workflows/bc.yml

@@ -30,4 +30,4 @@ jobs:
       os: >-
         ['ubuntu-latest']
       php: >-
-        ['8.1']
+        ['8.0']

.github/workflows/bench.yml

@@ -29,4 +29,4 @@ jobs:
       os: >-
         ['ubuntu-latest', 'windows-latest']
       php: >-
-        ['8.1']
+        ['8.0', '8.1']

.github/workflows/build.yml

@@ -31,7 +31,7 @@ jobs:
       os: >-
         ['ubuntu-latest', 'windows-latest']
       php: >-
-        ['8.1', '8.2', '8.3']
+        ['8.0', '8.1', '8.2', '8.3']
   phpunit-without-intl:
     uses: yiisoft/actions/.github/workflows/phpunit.yml@master
     with:
@@ -41,4 +41,4 @@ jobs:
       os: >-
         ['ubuntu-latest', 'windows-latest']
       php: >-
-        ['8.1', '8.2', '8.3']
+        ['8.0', '8.1', '8.2', '8.3']

.github/workflows/composer-require-checker.yml

@@ -31,5 +31,5 @@ jobs:
       os: >-
         ['ubuntu-latest']
       php: >-
-        ['8.1', '8.2', '8.3']
+        ['8.0', '8.1', '8.2', '8.3']
       config: ./composer-require-checker.json

.github/workflows/static.yml

@@ -30,3 +30,11 @@ jobs:
         ['ubuntu-latest']
       php: >-
         ['8.1', '8.2', '8.3']
+  psalm80:
+    uses: yiisoft/actions/.github/workflows/psalm.yml@master
+    with:
+      psalm-config: psalm80.xml
+      os: >-
+        ['ubuntu-latest']
+      php: >-
+        ['8.0']

src/EmptyCondition/NeverEmpty.php

@@ -24,9 +24,7 @@
 final class NeverEmpty
 {
     /**
-     * @param mixed $value The validated value.
      * @param bool $isAttributeMissing A flag defining whether the attribute is missing (not used / not passed at all).
-     *
      * @return bool Whether the validated value is considered empty.
      */
     public function __invoke(mixed $value, bool $isAttributeMissing = false): bool

src/EmptyCondition/WhenEmpty.php

@@ -38,9 +38,7 @@ public function __construct(
     }
 
     /**
-     * @param mixed $value The validated value.
      * @param bool $isAttributeMissing A flag defining whether the attribute is missing (not used / not passed at all).
-     *
      * @return bool Whether the validated value is considered empty.
      */
     public function __invoke(mixed $value, bool $isAttributeMissing = false): bool

src/EmptyCondition/WhenMissing.php

@@ -20,9 +20,7 @@
 final class WhenMissing
 {
     /**
-     * @param mixed $value The validated value.
      * @param bool $isAttributeMissing A flag defining whether the attribute is missing (not used / not passed at all).
-     *
      * @return bool Whether the validated value is considered empty.
      */
     public function __invoke(mixed $value, bool $isAttributeMissing = false): bool

src/EmptyCondition/WhenNull.php

@@ -20,9 +20,7 @@
 final class WhenNull
 {
     /**
-     * @param mixed $value The validated value.
      * @param bool $isAttributeMissing A flag defining whether the attribute is missing (not used / not passed at all).
-     *
      * @return bool Whether the validated value is considered empty.
      */
     public function __invoke(mixed $value, bool $isAttributeMissing = false): bool

src/Helper/DataSetNormalizer.php

@@ -28,8 +28,6 @@ final class DataSetNormalizer
      * In order to prevent mapping objects and arrays to corresponding data sets, wrap them with
      * {@see SingleValueDataSet} explicitly or use a custom data set ({@see DataSetInterface}).
      *
-     * @param mixed $data Raw validated data of any type.
-     *
      * @return DataSetInterface Data set instance.
      */
     public static function normalize(mixed $data): DataSetInterface

src/Helper/ObjectParser.php

@@ -471,7 +471,6 @@ private function getCacheItem(
      * Updates cache item contents by its name.
      *
      * @param string $name Cache item name. Can be on of: `rules`, `reflectionProperties`, `reflectionSource`.
-     * @param mixed $value A new value.
      */
     private function setCacheItem(
         #[ExpectedValues(['rules', 'reflectionProperties', 'reflectionSource', 'labels'])]

src/Helper/RulesNormalizer.php

@@ -151,10 +151,7 @@ public static function normalizeList(iterable|callable|RuleInterface $rules): it
      *
      * @psalm-param RawRules|null $rules
      *
-     * @param mixed $data Validated data.
-     *
      * @throws ReflectionException When parsing rules from PHP attributes failed.
-     *
      * @return iterable An iterable with rules for further individual rules' normalization.
      */
     private static function prepareRulesIterable(

src/Helper/RulesNormalizerIterator.php

@@ -62,14 +62,12 @@ public function getIterator(): Traversable
      * - For any other type verifies that it's a valid rule instance.
      * - If default "skip on empty" condition is set, applies it if possible.
      *
-     * @param mixed $rule A raw rule.
      * @param callable|null $defaultSkipOnEmptyCondition A "skip on empty" condition ({@see SkipOnEmptyInterface}) to
      * apply as default, already normalized. `null` means there is no condition to apply.
      *
      * @throws InvalidArgumentException When rule is neither a callable nor a {@see RuleInterface} implementation.
      *
      * @return RuleInterface Ready to use rule instance.
-     *
      * @psalm-param SkipOnEmptyCallable|null $defaultSkipOnEmptyCondition
      */
     private static function normalizeRule(mixed $rule, ?callable $defaultSkipOnEmptyCondition): RuleInterface

src/Rule/AbstractCompare.php

@@ -47,12 +47,12 @@
     /**
      * A default for {@see $incorrectInputMessage}.
      */
     protected const DEFAULT_INCORRECT_INPUT_MESSAGE = 'The allowed types are integer, float, string, boolean, null ' .
     'and object implementing \Stringable interface or \DateTimeInterface.';
     /**
      * A default for {@see $incorrectDataSetTypeMessage}.
      */
     protected const DEFAULT_INCORRECT_DATA_SET_TYPE_MESSAGE = 'The attribute value returned from a custom data set ' .
     'must have one of the following types: integer, float, string, boolean, null or an object implementing ' .
     '\Stringable interface or \DateTimeInterface.';
     /**
@@ -60,11 +60,11 @@
      *
      * @see CompareType
      */
     private const VALID_TYPES = [CompareType::ORIGINAL, CompareType::STRING, CompareType::NUMBER];
     /**
      * Map of valid operators. It's used instead of a list for better performance.
      */
     private const VALID_OPERATORS_MAP = [
         '==' => 1,
         '===' => 1,
         '!=' => 1,
@@ -76,8 +76,6 @@
     ];
 
     /**
-     * @param mixed $targetValue The value to be compared with. When both this property and {@see $targetAttribute} are
-     * set, this property takes precedence.
      * @param string|null $targetAttribute The name of the attribute to be compared with. When both this property and
      * {@see $targetValue} are set, the {@see $targetValue} takes precedence.
      * @param string $incorrectInputMessage A message used when the input is incorrect.

src/Rule/AnyRule.php

@@ -0,0 +1,164 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Yiisoft\Validator\Rule;
+
+use Attribute;
+use Closure;
+use JetBrains\PhpStorm\ArrayShape;
+use Yiisoft\Validator\AfterInitAttributeEventInterface;
+use Yiisoft\Validator\Helper\RulesNormalizer;
+use Yiisoft\Validator\Rule\Trait\SkipOnEmptyTrait;
+use Yiisoft\Validator\Rule\Trait\SkipOnErrorTrait;
+use Yiisoft\Validator\Rule\Trait\WhenTrait;
+use Yiisoft\Validator\Helper\RulesDumper;
+use Yiisoft\Validator\RuleWithOptionsInterface;
+use Yiisoft\Validator\SkipOnEmptyInterface;
+use Yiisoft\Validator\SkipOnErrorInterface;
+use Yiisoft\Validator\ValidatorInterface;
+use Yiisoft\Validator\WhenInterface;
+
+/**
+ * Applies to a set of rules, runs validation for each one of them in the order they are defined and stops at the rule
+ * where validation passed. The opposite of {@see StopOnError}.
+ *
+ * An example of usage:
+ *
+ * ```php
+ * $rule = new AnyRule([
+ *      new IntegerType(), // Let's say the validation passed here.
+ *      new FloatType(), // Then this rule will be skipped.
+ * ]);
+ * ```
+ *
+ * When using with other rules, conditional validation options, such as {@see AnyRule::$skipOnError} will be applied
+ * to the whole group of {@see AnyRule::$rules}.
+ *
+ * @see StopOnErrorHandler Corresponding handler performing the actual validation.
+ *
+ * @psalm-import-type SkipOnEmptyValue from SkipOnEmptyInterface
+ * @psalm-import-type WhenType from WhenInterface
+ * @psalm-import-type NormalizedRulesList from RulesNormalizer
+ * @psalm-import-type RawRulesList from ValidatorInterface
+ */
+#[Attribute(Attribute::TARGET_CLASS | Attribute::TARGET_PROPERTY | Attribute::IS_REPEATABLE)]
+final class AnyRule implements
+    RuleWithOptionsInterface,
+    SkipOnEmptyInterface,
+    SkipOnErrorInterface,
+    WhenInterface,
+    AfterInitAttributeEventInterface
+{
+    use SkipOnEmptyTrait;
+    use SkipOnErrorTrait;
+    use WhenTrait;
+
+    /**
+     * @var iterable A set of normalized rules that needs to be run.
+     *
+     * @psalm-var NormalizedRulesList
+     */
+    private iterable $rules = [];
+
+    /**
+     * @param string $message Error message used when validation fails because none of the inner {@see $rules} has
+     * passed the validation.
+     *
+     * @param iterable $rules A set of rules for running the validation. They will be normalized during initialization
+     * using {@see RulesNormalizer}.
+     *
+     * @psalm-param RawRulesList $rules
+     *
+     * @param bool|callable|null $skipOnEmpty Whether to skip this `Any` rule with all defined {@see $rules} if the
+     * validated value is empty / not passed. See {@see SkipOnEmptyInterface}.
+     * @param bool $skipOnError Whether to skip this `Any` rule with all defined {@see $rules} if any of the previous
+     * rules gave an error. See {@see SkipOnErrorInterface}.
+     * @param Closure|null $when A callable to define a condition for applying this `Any` rule with all defined
+     * {@see $rules}. See {@see WhenInterface}.
+     *
+     * @psalm-param SkipOnEmptyValue $skipOnEmpty
+     * @psalm-param WhenType $when
+     */
+    public function __construct(
+        iterable $rules,
+        private string $message = 'At least one of the inner rules must pass the validation.',
+        private mixed $skipOnEmpty = null,
+        private bool $skipOnError = false,
+        private Closure|null $when = null,
+    ) {
+        $this->rules = RulesNormalizer::normalizeList($rules);
+    }
+
+    public function getName(): string
+    {
+        return 'any';
+    }
+
+    /**
+     * Gets a set of rules for running the validation.
+     *
+     * @return iterable A set of rules.
+     *
+     * @psalm-return NormalizedRulesList
+     */
+    public function getRules(): iterable
+    {
+        return $this->rules;
+    }
+
+    /**
+     * Gets error message used when validation fails because none of the inner {@see $rules} has passed the validation.
+     *
+     * @return string Error message / template.
+     *
+     * @see $message
+     */
+    public function getMessage(): string
+    {
+        return $this->message;
+    }
+
+    #[ArrayShape([
+        'message' => 'array',
+        'skipOnEmpty' => 'bool',
+        'skipOnError' => 'bool',
+        'rules' => 'array|null',
+    ])]
+    public function getOptions(): array
+    {
+        return [
+            'message' => [
+                'template' => $this->message,
+                'parameters' => [],
+            ],
+            'skipOnEmpty' => $this->getSkipOnEmptyOption(),
+            'skipOnError' => $this->skipOnError,
+            'rules' => $this->dumpRulesAsArray(),
+        ];
+    }
+
+    public function getHandler(): string
+    {
+        return AnyRuleHandler::class;
+    }
+
+    public function afterInitAttribute(object $object): void
+    {
+        foreach ($this->rules as $rule) {
+            if ($rule instanceof AfterInitAttributeEventInterface) {
+                $rule->afterInitAttribute($object);
+            }
+        }
+    }
+
+    /**
+     * Dumps defined {@see $rules} to array.
+     *
+     * @return array The array of rules with their options.
+     */
+    private function dumpRulesAsArray(): array
+    {
+        return RulesDumper::asArray($this->getRules());
+    }
+}

src/Rule/AnyRuleHandler.php

@@ -0,0 +1,33 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Yiisoft\Validator\Rule;
+
+use Yiisoft\Validator\Exception\UnexpectedRuleException;
+use Yiisoft\Validator\Result;
+use Yiisoft\Validator\RuleHandlerInterface;
+use Yiisoft\Validator\ValidationContext;
+
+/**
+ * A handler for {@see AnyRule} rule. Validates a set of rules consecutively and stops at the rule where validation
+ * has passed.
+ */
+final class AnyRuleHandler implements RuleHandlerInterface
+{
+    public function validate(mixed $value, object $rule, ValidationContext $context): Result
+    {
+        if (!$rule instanceof AnyRule) {
+            throw new UnexpectedRuleException(AnyRule::class, $rule);
+        }
+
+        foreach ($rule->getRules() as $relatedRule) {
+            $result = $context->validate($value, $relatedRule);
+            if ($result->isValid()) {
+                return $result;
+            }
+        }
+
+        return (new Result())->addError($rule->getMessage(), []);
+    }
+}