WebSVN – lars-tiefland.laravel_shop – Diff – /trunk/vendor/laravel/framework/src/Illuminate/Validation/Concerns/ValidatesAttributes.php

 <?php
+namespace Illuminate\Validation\Concerns;
+use Brick\Math\BigDecimal;
-namespace Illuminate\Validation\Concerns;
+use Brick\Math\BigNumber;
 use Brick\Math\Exception\MathException as BrickMathException;
 use DateTime;
 use DateTimeInterface;
 use Egulias\EmailValidator\EmailValidator;
 use Egulias\EmailValidator\Validation\NoRFCWarningsValidation;
 use Egulias\EmailValidator\Validation\RFCValidation;
 use Exception;
 use Illuminate\Database\Eloquent\Model;
 use Illuminate\Support\Arr;
+use Illuminate\Support\Exceptions\MathException;
 use Illuminate\Support\Facades\Date;
 use Illuminate\Support\Str;
 use Illuminate\Validation\Rules\Exists;
 use Illuminate\Validation\Rules\Unique;
 use Illuminate\Validation\ValidationData;
+        }
+    }
     /**
+     * Validate that an attribute contains only alphabetic characters.
-     * Validate that an attribute contains only alphabetic characters.
+     * If the 'ascii' option is passed, validate that an attribute contains only ascii alphabetic characters.
+     *
      * @param  string  $attribute
      * @param  mixed  $value
      * @return bool
      */
-    public function validateAlpha($attribute, $value)
+    public function validateAlpha($attribute, $value, $parameters)
+    {
+        if (isset($parameters[0]) && $parameters[0] === 'ascii') {
+            return is_string($value) && preg_match('/\A[a-zA-Z]+\z/u', $value);
+        }
-    {
-        return is_string($value) && preg_match('/^[\pL\pM]+$/u', $value);
+        return is_string($value) && preg_match('/\A[\pL\pM]+\z/u', $value);
+    }
+    /**
+     * Validate that an attribute contains only alpha-numeric characters, dashes, and underscores.
-    /**
+     * If the 'ascii' option is passed, validate that an attribute contains only ascii alpha-numeric characters,
-     * Validate that an attribute contains only alpha-numeric characters, dashes, and underscores.
+     * dashes, and underscores.
+     *
      * @param  string  $attribute
      * @param  mixed  $value
      * @return bool
      */
-    public function validateAlphaDash($attribute, $value)
+    public function validateAlphaDash($attribute, $value, $parameters)
+    {
         if (! is_string($value) && ! is_numeric($value)) {
+            return false;
+        }
+        if (isset($parameters[0]) && $parameters[0] === 'ascii') {
-            return false;
+            return preg_match('/\A[a-zA-Z0-9_-]+\z/u', $value) > 0;
+        }
-        return preg_match('/^[\pL\pM\pN_-]+$/u', $value) > 0;
+        return preg_match('/\A[\pL\pM\pN_-]+\z/u', $value) > 0;
+    }
     /**
-    /**
+     * Validate that an attribute contains only alpha-numeric characters.
-     * Validate that an attribute contains only alpha-numeric characters.
+     * If the 'ascii' option is passed, validate that an attribute contains only ascii alpha-numeric characters.
+     *
      * @param  string  $attribute
      * @param  mixed  $value
      * @return bool
      */
-    public function validateAlphaNum($attribute, $value)
+    public function validateAlphaNum($attribute, $value, $parameters)
+    {
+        if (! is_string($value) && ! is_numeric($value)) {
+            return false;
+        }
-    {
-        if (! is_string($value) && ! is_numeric($value)) {
+        if (isset($parameters[0]) && $parameters[0] === 'ascii') {
-            return false;
+            return preg_match('/\A[a-zA-Z0-9]+\z/u', $value) > 0;
+        }
      */
     public function validateBetween($attribute, $value, $parameters)
+    {
         $this->requireParameterCount(2, $parameters, 'between');
+        return with(
-        $size = $this->getSize($attribute, $value);
+            BigNumber::of($this->getSize($attribute, $value)),
+            fn ($size) => $size->isGreaterThanOrEqualTo($parameters[0]) && $size->isLessThanOrEqualTo($parameters[1])
-        return $size >= $parameters[0] && $size <= $parameters[1];
+        );
+    }
     /**
         $comparedToValue = $this->getValue($parameters[0]);
         $this->shouldBeNumeric($attribute, 'Gt');
         if (is_null($comparedToValue) && (is_numeric($value) && is_numeric($parameters[0]))) {
-            return $this->getSize($attribute, $value) > $parameters[0];
+            return BigNumber::of($this->getSize($attribute, $value))->isGreaterThan($parameters[0]);
+        }
         if (is_numeric($parameters[0])) {
             return false;
+        }
         if ($this->hasRule($attribute, $this->numericRules) && is_numeric($value) && is_numeric($comparedToValue)) {
-            return $value > $comparedToValue;
+            return BigNumber::of($value)->isGreaterThan($comparedToValue);
         $comparedToValue = $this->getValue($parameters[0]);
         $this->shouldBeNumeric($attribute, 'Lt');
         if (is_null($comparedToValue) && (is_numeric($value) && is_numeric($parameters[0]))) {
-            return $this->getSize($attribute, $value) < $parameters[0];
+            return BigNumber::of($this->getSize($attribute, $value))->isLessThan($parameters[0]);
+        }
         if (is_numeric($parameters[0])) {
             return false;
+        }
         if ($this->hasRule($attribute, $this->numericRules) && is_numeric($value) && is_numeric($comparedToValue)) {
-            return $value < $comparedToValue;
+            return BigNumber::of($value)->isLessThan($comparedToValue);
         $comparedToValue = $this->getValue($parameters[0]);
         $this->shouldBeNumeric($attribute, 'Gte');
         if (is_null($comparedToValue) && (is_numeric($value) && is_numeric($parameters[0]))) {
-            return $this->getSize($attribute, $value) >= $parameters[0];
+            return BigNumber::of($this->getSize($attribute, $value))->isGreaterThanOrEqualTo($parameters[0]);
+        }
         if (is_numeric($parameters[0])) {
             return false;
+        }
         if ($this->hasRule($attribute, $this->numericRules) && is_numeric($value) && is_numeric($comparedToValue)) {
-            return $value >= $comparedToValue;
+            return BigNumber::of($value)->isGreaterThanOrEqualTo($comparedToValue);
         $comparedToValue = $this->getValue($parameters[0]);
         $this->shouldBeNumeric($attribute, 'Lte');
         if (is_null($comparedToValue) && (is_numeric($value) && is_numeric($parameters[0]))) {
-            return $this->getSize($attribute, $value) <= $parameters[0];
+            return BigNumber::of($this->getSize($attribute, $value))->isLessThanOrEqualTo($parameters[0]);
+        }
         if (is_numeric($parameters[0])) {
             return false;
+        }
         if ($this->hasRule($attribute, $this->numericRules) && is_numeric($value) && is_numeric($comparedToValue)) {
-            return $value <= $comparedToValue;
+            return BigNumber::of($value)->isLessThanOrEqualTo($comparedToValue);
         if ($value instanceof UploadedFile && ! $value->isValid()) {
             return false;
         }
-        return $this->getSize($attribute, $value) <= $parameters[0];
+        return BigNumber::of($this->getSize($attribute, $value))->isLessThanOrEqualTo($parameters[0]);
+    }
      */
     public function validateMin($attribute, $value, $parameters)
+    {
         $this->requireParameterCount(1, $parameters, 'min');
-        return $this->getSize($attribute, $value) >= $parameters[0];
+        return BigNumber::of($this->getSize($attribute, $value))->isGreaterThanOrEqualTo($parameters[0]);
+    }
     /**
         return ! preg_match('/[^0-9]/', $value) && $length >= $parameters[0];
+    }
+    /**
+     * Validate that an attribute is missing.
+     *
+     * @param  string  $attribute
+     * @param  mixed  $value
+     * @param  array<int, int|string>  $parameters
+     * @return bool
+     */
+    public function validateMissing($attribute, $value, $parameters)
+    {
+        return ! Arr::has($this->data, $attribute);
+    }
+    /**
+     * Validate that an attribute is missing when another attribute has a given value.
+     *
+     * @param  string  $attribute
+     * @param  mixed  $value
+     * @param  array<int, int|string>  $parameters
+     * @return bool
+     */
+    public function validateMissingIf($attribute, $value, $parameters)
+    {
+        $this->requireParameterCount(2, $parameters, 'missing_if');
+        [$values, $other] = $this->parseDependentRuleParameters($parameters);
+        if (in_array($other, $values, is_bool($other) || is_null($other))) {
+            return $this->validateMissing($attribute, $value, $parameters);
+        }
+        return true;
+    }
+    /**
+     * Validate that an attribute is missing unless another attribute has a given value.
+     *
+     * @param  string  $attribute
+     * @param  mixed  $value
+     * @param  array<int, int|string>  $parameters
+     * @return bool
+     */
+    public function validateMissingUnless($attribute, $value, $parameters)
+    {
+        $this->requireParameterCount(2, $parameters, 'missing_unless');
+        [$values, $other] = $this->parseDependentRuleParameters($parameters);
+        if (! in_array($other, $values, is_bool($other) || is_null($other))) {
+            return $this->validateMissing($attribute, $value, $parameters);
+        }
+        return true;
+    }
+    /**
+     * Validate that an attribute is missing when any given attribute is present.
+     *
+     * @param  string  $attribute
+     * @param  mixed  $value
+     * @param  array<int, int|string>  $parameters
+     * @return bool
+     */
+    public function validateMissingWith($attribute, $value, $parameters)
+    {
+        $this->requireParameterCount(1, $parameters, 'missing_with');
+        return ! Arr::hasAny($this->data, $parameters);
+    }
+    /**
+     * Validate that an attribute is missing when all given attributes are present.
+     *
+     * @param  string  $attribute
+     * @param  mixed  $value
+     * @param  array<int, int|string>  $parameters
+     * @return bool
+     */
+    public function validateMissingWithAll($attribute, $value, $parameters)
+    {
+        $this->requireParameterCount(1, $parameters, 'missing_with');
+        return ! Arr::has($this->data, $parameters);
+    }
     /**
      * Validate the value of an attribute is a multiple of a given value.
+     *
      * @param  string  $attribute
         if (! $this->validateNumeric($attribute, $value) || ! $this->validateNumeric($attribute, $parameters[0])) {
             return false;
+        }
-        }
+        try {
+            $numerator = BigDecimal::of($value);
+            $denominator = BigDecimal::of($parameters[0]);
+            if ($numerator->isZero() && $denominator->isZero()) {
+                return false;
+            }
-        if ((float) $parameters[0] === 0.0) {
+            if ($numerator->isZero()) {
+                return true;
+            }
+            if ($denominator->isZero()) {
-            return false;
+                return false;
+            }
+            return $numerator->remainder($denominator)->isZero();
         } catch (BrickMathException $e) {
             throw new MathException('An error occurred while handling the mulitple_of input values.', previous: $e);
         return bcmod($value, $parameters[0], 16) === '0.0000000000000000';
+    }
      * @param  mixed  $value
      * @return bool
      */
     public function validateProhibited($attribute, $value)
+    {
-        return false;
+        return ! $this->validateRequired($attribute, $value);
+    }
     /**
      * Validate that an attribute does not exist when another attribute has a given value.
      * @param  mixed  $parameters
      * @return bool
      */
     public function validateProhibits($attribute, $value, $parameters)
+    {
+        if ($this->validateRequired($attribute, $value)) {
-        return ! Arr::hasAny($this->data, $parameters);
+            foreach ($parameters as $parameter) {
+                if ($this->validateRequired($parameter, Arr::get($this->data, $parameter))) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
     /**
      * Indicate that an attribute is excluded.
      */
     public function validateSize($attribute, $value, $parameters)
+    {
         $this->requireParameterCount(1, $parameters, 'size');
-        return $this->getSize($attribute, $value) == $parameters[0];
+        return BigNumber::of($this->getSize($attribute, $value))->isEqualTo($parameters[0]);
+    }
     /**
     /**
      * Get the size of an attribute.
+     *
      * @param  string  $attribute
      * @param  mixed  $value
-     * @return mixed
+     * @return int|float|string
      */
     protected function getSize($attribute, $value)
+    {
         $hasNumeric = $this->hasRule($attribute, $this->numericRules);

Subversion-Projekte lars-tiefland.laravel_shop

(root)/trunk/vendor/laravel/framework/src/Illuminate/Validation/Concerns/ValidatesAttributes.php – Revision 150 → 399