Added exclude rules for hyperf/validation (#7148)

Author: xiewxin

publish/en/validation.php

@@ -111,6 +111,11 @@
     'required_with_all' => 'The :attribute field is required when :values is present.',
     'required_without' => 'The :attribute field is required when :values is not present.',
     'required_without_all' => 'The :attribute field is required when none of :values are present.',
+    'exclude' => 'The :attribute field is excluded.',
+    'exclude_if' => 'The :attribute field is excluded when :other is :value.',
+    'exclude_unless' => 'The :attribute field is excluded unless :other is in :values.',
+    'exclude_with' => 'The :attribute field is excluded when :values is present.',
+    'exclude_without' => 'The :attribute field is excluded when :values is not present.',
     'same' => 'The :attribute and :other must match.',
     'size' => [
         'numeric' => 'The :attribute must be :size.',

publish/zh_CN/validation.php

@@ -111,6 +111,11 @@
     'required_with_all' => ':attribute 字段是必须的当 :values 是存在的',
     'required_without' => ':attribute 字段是必须的当 :values 是不存在的',
     'required_without_all' => ':attribute 字段是必须的当 没有一个 :values 是存在的',
+    'exclude' => ':attribute 字段是被排除的',
+    'exclude_if' => '当 :other 为 :value 时，排除 :attribute 字段',
+    'exclude_unless' => '除非 :other 是在 :values 中，否则排除 :attribute 字段',
+    'exclude_with' => '当 :values 存在时，排除 :attribute 字段',
+    'exclude_without' => '当 :values 不存在时，排除 :attribute 字段',
     'same' => ':attribute 和 :other 必须匹配',
     'size' => [
         'numeric' => ':attribute 必须是 :size',

src/Concerns/ValidatesAttributes.php

@@ -1297,6 +1297,46 @@ public function validateRequiredIf(string $attribute, $value, array $parameters)
         return true;
     }
 
+    /**
+     * Indicate that an attribute is excluded.
+     */
+    public function validateExclude(): bool
+    {
+        return false;
+    }
+
+    /**
+     * Indicate that an attribute should be excluded when another attribute has a given value.
+     *
+     * @param mixed $value
+     */
+    public function validateExcludeIf(string $attribute, $value, array $parameters): bool
+    {
+        $this->requireParameterCount(2, $parameters, 'exclude_if');
+
+        if (! Arr::has($this->data, $parameters[0])) {
+            return true;
+        }
+
+        [$values, $other] = $this->parseDependentRuleParameters($parameters);
+
+        return ! in_array($other, $values, is_bool($other) || is_null($other));
+    }
+
+    /**
+     * Indicate that an attribute should be excluded when another attribute does not have a given value.
+     *
+     * @param mixed $value
+     */
+    public function validateExcludeUnless(string $attribute, $value, array $parameters): bool
+    {
+        $this->requireParameterCount(2, $parameters, 'exclude_unless');
+
+        [$values, $other] = $this->parseDependentRuleParameters($parameters);
+
+        return in_array($other, $values, is_bool($other) || is_null($other));
+    }
+
     /**
      * Validate that an attribute exists when another attribute does not have a given value.
      *
@@ -1317,6 +1357,38 @@ public function validateRequiredUnless(string $attribute, $value, array $paramet
         return true;
     }
 
+    /**
+     * Indicate that an attribute should be excluded when another attribute presents.
+     *
+     * @param mixed $value
+     */
+    public function validateExcludeWith(string $attribute, $value, array $parameters): bool
+    {
+        $this->requireParameterCount(1, $parameters, 'exclude_with');
+
+        if (! Arr::has($this->data, $parameters[0])) {
+            return true;
+        }
+
+        return false;
+    }
+
+    /**
+     * Indicate that an attribute should be excluded when another attribute is missing.
+     *
+     * @param mixed $value
+     */
+    public function validateExcludeWithout(string $attribute, $value, array $parameters): bool
+    {
+        $this->requireParameterCount(1, $parameters, 'exclude_without');
+
+        if ($this->anyFailingRequired($parameters)) {
+            return false;
+        }
+
+        return true;
+    }
+
     /**
      * Validate that an attribute exists when any other attribute exists.
      *

src/Validator.php

@@ -52,6 +52,11 @@ class Validator implements ValidatorContract
      */
     public array $customValues = [];
 
+    /**
+     * Indicates that unvalidated array keys should be excluded, even if the parent array was validated.
+     */
+    public bool $excludeUnvalidatedArrayKeys = false;
+
     /**
      * All the custom validator extensions.
      */
@@ -77,6 +82,11 @@ class Validator implements ValidatorContract
      */
     protected array $failedRules = [];
 
+    /**
+     * Attributes that should be excluded from the validated data.
+     */
+    protected array $excludeAttributes = [];
+
     /**
      * The message bag instance.
      */
@@ -137,9 +147,14 @@ class Validator implements ValidatorContract
         'RequiredWith', 'RequiredWithAll', 'RequiredWithout', 'RequiredWithoutAll',
         'RequiredIf', 'RequiredUnless', 'Confirmed', 'Same', 'Different', 'Unique',
         'Before', 'After', 'BeforeOrEqual', 'AfterOrEqual', 'Gt', 'Lt', 'Gte', 'Lte',
-        'Prohibits',
+        'Prohibits', 'ExcludeIf', 'ExcludeUnless', 'ExcludeWith', 'ExcludeWithout',
     ];
 
+    /**
+     * The validation rules that can exclude an attribute.
+     */
+    protected array $excludeRules = ['Exclude', 'ExcludeIf', 'ExcludeUnless', 'ExcludeWith', 'ExcludeWithout'];
+
     /**
      * The size related validation rules.
      */
@@ -242,9 +257,19 @@ public function passes(): bool
         foreach ($this->rules as $attribute => $rules) {
             $attribute = str_replace('\.', '->', $attribute);
 
+            if ($this->shouldBeExcluded($attribute)) {
+                $this->removeAttribute($attribute);
+
+                continue;
+            }
+
             foreach ($rules as $rule) {
                 $this->validateAttribute($attribute, $rule);
 
+                if ($this->shouldBeExcluded($attribute)) {
+                    break;
+                }
+
                 if ($this->shouldStopValidating($attribute)) {
                     break;
                 }
@@ -298,9 +323,16 @@ public function validated(): array
 
         $missingValue = Str::random(10);
 
-        foreach (array_keys($this->getRules()) as $key) {
+        foreach ($this->getRules() as $key => $rules) {
             $value = data_get($this->getData(), $key, $missingValue);
 
+            if ($this->excludeUnvalidatedArrayKeys
+                && (in_array('array', $rules) || in_array('list', $rules))
+                && $value !== null
+                && ! empty(preg_grep('/^' . preg_quote($key, '/') . '\.+/', array_keys($this->getRules())))) {
+                continue;
+            }
+
             if ($value !== $missingValue) {
                 Arr::set($results, $key, $value);
             }
@@ -312,12 +344,17 @@ public function validated(): array
     /**
      * Add a failed rule and error message to the collection.
      */
-    public function addFailure(string $attribute, string $rule, array $parameters = [])
+    public function addFailure(string $attribute, string $rule, array $parameters = []): void
     {
         if (! $this->messages) {
             $this->passes();
         }
 
+        if (in_array($rule, $this->excludeRules)) {
+            $this->excludeAttribute($attribute);
+            return;
+        }
+
         $this->messages->add($attribute, $this->makeReplacements(
             $this->getMessage($attribute, $rule),
             $attribute,
@@ -720,6 +757,31 @@ public function setValue($attribute, $value)
         Arr::set($this->data, $attribute, $value);
     }
 
+    /**
+     * Determine if the attribute should be excluded.
+     */
+    protected function shouldBeExcluded(string $attribute): bool
+    {
+        foreach ($this->excludeAttributes as $excludeAttribute) {
+            if ($attribute === $excludeAttribute
+                || Str::startsWith($attribute, $excludeAttribute . '.')) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    /**
+     * Add the given attribute to the list of excluded attributes.
+     */
+    protected function excludeAttribute(string $attribute): void
+    {
+        $this->excludeAttributes[] = $attribute;
+
+        $this->excludeAttributes = array_unique($this->excludeAttributes);
+    }
+
     /**
      * Validate a given attribute against a rule.
      *
@@ -832,6 +894,10 @@ protected function replaceAsterisksInParameters(array $parameters, array $keys):
      */
     protected function isValidatable($rule, string $attribute, $value): bool
     {
+        if (in_array($rule, $this->excludeRules)) {
+            return true;
+        }
+
         return $this->presentOrRuleIsImplicit($rule, $attribute, $value)
             && $this->passesOptionalCheck($attribute)
             && $this->isNotNullIfMarkedAsNullable($rule, $attribute)