|
Server IP : 213.176.29.180 / Your IP : 18.188.211.58 Web Server : Apache System : Linux 213.176.29.180.hostiran.name 4.18.0-553.22.1.el8_10.x86_64 #1 SMP Tue Sep 24 05:16:59 EDT 2024 x86_64 User : webtaragh ( 1001) PHP Version : 7.4.33 Disable Function : NONE MySQL : OFF | cURL : ON | WGET : ON | Perl : ON | Python : ON Directory (0750) : /home/webtaragh/public_html/webtaragh.ir/../wp-content/../ |
| [ Home ] | [ C0mmand ] | [ Upload File ] |
|---|
assert/src/Assert.php 0000644 00000156466 14736103027 0010633 0 ustar 00 <?php
/*
* This file is part of the webmozart/assert package.
*
* (c) Bernhard Schussek <bschussek@gmail.com>
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace Webmozart\Assert;
use ArrayAccess;
use BadMethodCallException;
use Closure;
use Countable;
use DateTime;
use DateTimeImmutable;
use Exception;
use ResourceBundle;
use SimpleXMLElement;
use Throwable;
use Traversable;
/**
* Efficient assertions to validate the input/output of your methods.
*
* @since 1.0
*
* @author Bernhard Schussek <bschussek@gmail.com>
*/
class Assert
{
use Mixin;
/**
* @psalm-pure
* @psalm-assert string $value
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function string($value, $message = '')
{
if (!\is_string($value)) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected a string. Got: %s',
static::typeToString($value)
));
}
}
/**
* @psalm-pure
* @psalm-assert non-empty-string $value
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function stringNotEmpty($value, $message = '')
{
static::string($value, $message);
static::notEq($value, '', $message);
}
/**
* @psalm-pure
* @psalm-assert int $value
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function integer($value, $message = '')
{
if (!\is_int($value)) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected an integer. Got: %s',
static::typeToString($value)
));
}
}
/**
* @psalm-pure
* @psalm-assert numeric $value
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function integerish($value, $message = '')
{
if (!\is_numeric($value) || $value != (int) $value) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected an integerish value. Got: %s',
static::typeToString($value)
));
}
}
/**
* @psalm-pure
* @psalm-assert positive-int $value
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function positiveInteger($value, $message = '')
{
if (!(\is_int($value) && $value > 0)) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected a positive integer. Got: %s',
static::valueToString($value)
));
}
}
/**
* @psalm-pure
* @psalm-assert float $value
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function float($value, $message = '')
{
if (!\is_float($value)) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected a float. Got: %s',
static::typeToString($value)
));
}
}
/**
* @psalm-pure
* @psalm-assert numeric $value
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function numeric($value, $message = '')
{
if (!\is_numeric($value)) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected a numeric. Got: %s',
static::typeToString($value)
));
}
}
/**
* @psalm-pure
* @psalm-assert positive-int|0 $value
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function natural($value, $message = '')
{
if (!\is_int($value) || $value < 0) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected a non-negative integer. Got: %s',
static::valueToString($value)
));
}
}
/**
* @psalm-pure
* @psalm-assert bool $value
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function boolean($value, $message = '')
{
if (!\is_bool($value)) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected a boolean. Got: %s',
static::typeToString($value)
));
}
}
/**
* @psalm-pure
* @psalm-assert scalar $value
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function scalar($value, $message = '')
{
if (!\is_scalar($value)) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected a scalar. Got: %s',
static::typeToString($value)
));
}
}
/**
* @psalm-pure
* @psalm-assert object $value
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function object($value, $message = '')
{
if (!\is_object($value)) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected an object. Got: %s',
static::typeToString($value)
));
}
}
/**
* @psalm-pure
* @psalm-assert resource $value
*
* @param mixed $value
* @param string|null $type type of resource this should be. @see https://www.php.net/manual/en/function.get-resource-type.php
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function resource($value, $type = null, $message = '')
{
if (!\is_resource($value)) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected a resource. Got: %s',
static::typeToString($value)
));
}
if ($type && $type !== \get_resource_type($value)) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected a resource of type %2$s. Got: %s',
static::typeToString($value),
$type
));
}
}
/**
* @psalm-pure
* @psalm-assert callable $value
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function isCallable($value, $message = '')
{
if (!\is_callable($value)) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected a callable. Got: %s',
static::typeToString($value)
));
}
}
/**
* @psalm-pure
* @psalm-assert array $value
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function isArray($value, $message = '')
{
if (!\is_array($value)) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected an array. Got: %s',
static::typeToString($value)
));
}
}
/**
* @psalm-pure
* @psalm-assert iterable $value
*
* @deprecated use "isIterable" or "isInstanceOf" instead
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function isTraversable($value, $message = '')
{
@\trigger_error(
\sprintf(
'The "%s" assertion is deprecated. You should stop using it, as it will soon be removed in 2.0 version. Use "isIterable" or "isInstanceOf" instead.',
__METHOD__
),
\E_USER_DEPRECATED
);
if (!\is_array($value) && !($value instanceof Traversable)) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected a traversable. Got: %s',
static::typeToString($value)
));
}
}
/**
* @psalm-pure
* @psalm-assert array|ArrayAccess $value
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function isArrayAccessible($value, $message = '')
{
if (!\is_array($value) && !($value instanceof ArrayAccess)) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected an array accessible. Got: %s',
static::typeToString($value)
));
}
}
/**
* @psalm-pure
* @psalm-assert countable $value
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function isCountable($value, $message = '')
{
if (
!\is_array($value)
&& !($value instanceof Countable)
&& !($value instanceof ResourceBundle)
&& !($value instanceof SimpleXMLElement)
) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected a countable. Got: %s',
static::typeToString($value)
));
}
}
/**
* @psalm-pure
* @psalm-assert iterable $value
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function isIterable($value, $message = '')
{
if (!\is_array($value) && !($value instanceof Traversable)) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected an iterable. Got: %s',
static::typeToString($value)
));
}
}
/**
* @psalm-pure
* @psalm-template ExpectedType of object
* @psalm-param class-string<ExpectedType> $class
* @psalm-assert ExpectedType $value
*
* @param mixed $value
* @param string|object $class
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function isInstanceOf($value, $class, $message = '')
{
if (!($value instanceof $class)) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected an instance of %2$s. Got: %s',
static::typeToString($value),
$class
));
}
}
/**
* @psalm-pure
* @psalm-template ExpectedType of object
* @psalm-param class-string<ExpectedType> $class
* @psalm-assert !ExpectedType $value
*
* @param mixed $value
* @param string|object $class
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function notInstanceOf($value, $class, $message = '')
{
if ($value instanceof $class) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected an instance other than %2$s. Got: %s',
static::typeToString($value),
$class
));
}
}
/**
* @psalm-pure
* @psalm-param array<class-string> $classes
*
* @param mixed $value
* @param array<object|string> $classes
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function isInstanceOfAny($value, array $classes, $message = '')
{
foreach ($classes as $class) {
if ($value instanceof $class) {
return;
}
}
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected an instance of any of %2$s. Got: %s',
static::typeToString($value),
\implode(', ', \array_map(array(static::class, 'valueToString'), $classes))
));
}
/**
* @psalm-pure
* @psalm-template ExpectedType of object
* @psalm-param class-string<ExpectedType> $class
* @psalm-assert ExpectedType|class-string<ExpectedType> $value
*
* @param object|string $value
* @param string $class
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function isAOf($value, $class, $message = '')
{
static::string($class, 'Expected class as a string. Got: %s');
if (!\is_a($value, $class, \is_string($value))) {
static::reportInvalidArgument(sprintf(
$message ?: 'Expected an instance of this class or to this class among its parents "%2$s". Got: %s',
static::valueToString($value),
$class
));
}
}
/**
* @psalm-pure
* @psalm-template UnexpectedType of object
* @psalm-param class-string<UnexpectedType> $class
* @psalm-assert !UnexpectedType $value
* @psalm-assert !class-string<UnexpectedType> $value
*
* @param object|string $value
* @param string $class
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function isNotA($value, $class, $message = '')
{
static::string($class, 'Expected class as a string. Got: %s');
if (\is_a($value, $class, \is_string($value))) {
static::reportInvalidArgument(sprintf(
$message ?: 'Expected an instance of this class or to this class among its parents other than "%2$s". Got: %s',
static::valueToString($value),
$class
));
}
}
/**
* @psalm-pure
* @psalm-param array<class-string> $classes
*
* @param object|string $value
* @param string[] $classes
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function isAnyOf($value, array $classes, $message = '')
{
foreach ($classes as $class) {
static::string($class, 'Expected class as a string. Got: %s');
if (\is_a($value, $class, \is_string($value))) {
return;
}
}
static::reportInvalidArgument(sprintf(
$message ?: 'Expected an instance of any of this classes or any of those classes among their parents "%2$s". Got: %s',
static::valueToString($value),
\implode(', ', $classes)
));
}
/**
* @psalm-pure
* @psalm-assert empty $value
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function isEmpty($value, $message = '')
{
if (!empty($value)) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected an empty value. Got: %s',
static::valueToString($value)
));
}
}
/**
* @psalm-pure
* @psalm-assert !empty $value
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function notEmpty($value, $message = '')
{
if (empty($value)) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected a non-empty value. Got: %s',
static::valueToString($value)
));
}
}
/**
* @psalm-pure
* @psalm-assert null $value
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function null($value, $message = '')
{
if (null !== $value) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected null. Got: %s',
static::valueToString($value)
));
}
}
/**
* @psalm-pure
* @psalm-assert !null $value
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function notNull($value, $message = '')
{
if (null === $value) {
static::reportInvalidArgument(
$message ?: 'Expected a value other than null.'
);
}
}
/**
* @psalm-pure
* @psalm-assert true $value
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function true($value, $message = '')
{
if (true !== $value) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected a value to be true. Got: %s',
static::valueToString($value)
));
}
}
/**
* @psalm-pure
* @psalm-assert false $value
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function false($value, $message = '')
{
if (false !== $value) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected a value to be false. Got: %s',
static::valueToString($value)
));
}
}
/**
* @psalm-pure
* @psalm-assert !false $value
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function notFalse($value, $message = '')
{
if (false === $value) {
static::reportInvalidArgument(
$message ?: 'Expected a value other than false.'
);
}
}
/**
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function ip($value, $message = '')
{
if (false === \filter_var($value, \FILTER_VALIDATE_IP)) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected a value to be an IP. Got: %s',
static::valueToString($value)
));
}
}
/**
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function ipv4($value, $message = '')
{
if (false === \filter_var($value, \FILTER_VALIDATE_IP, \FILTER_FLAG_IPV4)) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected a value to be an IPv4. Got: %s',
static::valueToString($value)
));
}
}
/**
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function ipv6($value, $message = '')
{
if (false === \filter_var($value, \FILTER_VALIDATE_IP, \FILTER_FLAG_IPV6)) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected a value to be an IPv6. Got: %s',
static::valueToString($value)
));
}
}
/**
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function email($value, $message = '')
{
if (false === \filter_var($value, FILTER_VALIDATE_EMAIL)) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected a value to be a valid e-mail address. Got: %s',
static::valueToString($value)
));
}
}
/**
* Does non strict comparisons on the items, so ['3', 3] will not pass the assertion.
*
* @param array $values
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function uniqueValues(array $values, $message = '')
{
$allValues = \count($values);
$uniqueValues = \count(\array_unique($values));
if ($allValues !== $uniqueValues) {
$difference = $allValues - $uniqueValues;
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected an array of unique values, but %s of them %s duplicated',
$difference,
(1 === $difference ? 'is' : 'are')
));
}
}
/**
* @param mixed $value
* @param mixed $expect
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function eq($value, $expect, $message = '')
{
if ($expect != $value) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected a value equal to %2$s. Got: %s',
static::valueToString($value),
static::valueToString($expect)
));
}
}
/**
* @param mixed $value
* @param mixed $expect
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function notEq($value, $expect, $message = '')
{
if ($expect == $value) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected a different value than %s.',
static::valueToString($expect)
));
}
}
/**
* @psalm-pure
*
* @param mixed $value
* @param mixed $expect
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function same($value, $expect, $message = '')
{
if ($expect !== $value) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected a value identical to %2$s. Got: %s',
static::valueToString($value),
static::valueToString($expect)
));
}
}
/**
* @psalm-pure
*
* @param mixed $value
* @param mixed $expect
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function notSame($value, $expect, $message = '')
{
if ($expect === $value) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected a value not identical to %s.',
static::valueToString($expect)
));
}
}
/**
* @psalm-pure
*
* @param mixed $value
* @param mixed $limit
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function greaterThan($value, $limit, $message = '')
{
if ($value <= $limit) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected a value greater than %2$s. Got: %s',
static::valueToString($value),
static::valueToString($limit)
));
}
}
/**
* @psalm-pure
*
* @param mixed $value
* @param mixed $limit
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function greaterThanEq($value, $limit, $message = '')
{
if ($value < $limit) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected a value greater than or equal to %2$s. Got: %s',
static::valueToString($value),
static::valueToString($limit)
));
}
}
/**
* @psalm-pure
*
* @param mixed $value
* @param mixed $limit
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function lessThan($value, $limit, $message = '')
{
if ($value >= $limit) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected a value less than %2$s. Got: %s',
static::valueToString($value),
static::valueToString($limit)
));
}
}
/**
* @psalm-pure
*
* @param mixed $value
* @param mixed $limit
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function lessThanEq($value, $limit, $message = '')
{
if ($value > $limit) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected a value less than or equal to %2$s. Got: %s',
static::valueToString($value),
static::valueToString($limit)
));
}
}
/**
* Inclusive range, so Assert::(3, 3, 5) passes.
*
* @psalm-pure
*
* @param mixed $value
* @param mixed $min
* @param mixed $max
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function range($value, $min, $max, $message = '')
{
if ($value < $min || $value > $max) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected a value between %2$s and %3$s. Got: %s',
static::valueToString($value),
static::valueToString($min),
static::valueToString($max)
));
}
}
/**
* A more human-readable alias of Assert::inArray().
*
* @psalm-pure
*
* @param mixed $value
* @param array $values
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function oneOf($value, array $values, $message = '')
{
static::inArray($value, $values, $message);
}
/**
* Does strict comparison, so Assert::inArray(3, ['3']) does not pass the assertion.
*
* @psalm-pure
*
* @param mixed $value
* @param array $values
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function inArray($value, array $values, $message = '')
{
if (!\in_array($value, $values, true)) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected one of: %2$s. Got: %s',
static::valueToString($value),
\implode(', ', \array_map(array(static::class, 'valueToString'), $values))
));
}
}
/**
* @psalm-pure
*
* @param string $value
* @param string $subString
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function contains($value, $subString, $message = '')
{
if (false === \strpos($value, $subString)) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected a value to contain %2$s. Got: %s',
static::valueToString($value),
static::valueToString($subString)
));
}
}
/**
* @psalm-pure
*
* @param string $value
* @param string $subString
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function notContains($value, $subString, $message = '')
{
if (false !== \strpos($value, $subString)) {
static::reportInvalidArgument(\sprintf(
$message ?: '%2$s was not expected to be contained in a value. Got: %s',
static::valueToString($value),
static::valueToString($subString)
));
}
}
/**
* @psalm-pure
*
* @param string $value
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function notWhitespaceOnly($value, $message = '')
{
if (\preg_match('/^\s*$/', $value)) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected a non-whitespace string. Got: %s',
static::valueToString($value)
));
}
}
/**
* @psalm-pure
*
* @param string $value
* @param string $prefix
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function startsWith($value, $prefix, $message = '')
{
if (0 !== \strpos($value, $prefix)) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected a value to start with %2$s. Got: %s',
static::valueToString($value),
static::valueToString($prefix)
));
}
}
/**
* @psalm-pure
*
* @param string $value
* @param string $prefix
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function notStartsWith($value, $prefix, $message = '')
{
if (0 === \strpos($value, $prefix)) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected a value not to start with %2$s. Got: %s',
static::valueToString($value),
static::valueToString($prefix)
));
}
}
/**
* @psalm-pure
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function startsWithLetter($value, $message = '')
{
static::string($value);
$valid = isset($value[0]);
if ($valid) {
$locale = \setlocale(LC_CTYPE, 0);
\setlocale(LC_CTYPE, 'C');
$valid = \ctype_alpha($value[0]);
\setlocale(LC_CTYPE, $locale);
}
if (!$valid) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected a value to start with a letter. Got: %s',
static::valueToString($value)
));
}
}
/**
* @psalm-pure
*
* @param string $value
* @param string $suffix
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function endsWith($value, $suffix, $message = '')
{
if ($suffix !== \substr($value, -\strlen($suffix))) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected a value to end with %2$s. Got: %s',
static::valueToString($value),
static::valueToString($suffix)
));
}
}
/**
* @psalm-pure
*
* @param string $value
* @param string $suffix
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function notEndsWith($value, $suffix, $message = '')
{
if ($suffix === \substr($value, -\strlen($suffix))) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected a value not to end with %2$s. Got: %s',
static::valueToString($value),
static::valueToString($suffix)
));
}
}
/**
* @psalm-pure
*
* @param string $value
* @param string $pattern
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function regex($value, $pattern, $message = '')
{
if (!\preg_match($pattern, $value)) {
static::reportInvalidArgument(\sprintf(
$message ?: 'The value %s does not match the expected pattern.',
static::valueToString($value)
));
}
}
/**
* @psalm-pure
*
* @param string $value
* @param string $pattern
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function notRegex($value, $pattern, $message = '')
{
if (\preg_match($pattern, $value, $matches, PREG_OFFSET_CAPTURE)) {
static::reportInvalidArgument(\sprintf(
$message ?: 'The value %s matches the pattern %s (at offset %d).',
static::valueToString($value),
static::valueToString($pattern),
$matches[0][1]
));
}
}
/**
* @psalm-pure
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function unicodeLetters($value, $message = '')
{
static::string($value);
if (!\preg_match('/^\p{L}+$/u', $value)) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected a value to contain only Unicode letters. Got: %s',
static::valueToString($value)
));
}
}
/**
* @psalm-pure
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function alpha($value, $message = '')
{
static::string($value);
$locale = \setlocale(LC_CTYPE, 0);
\setlocale(LC_CTYPE, 'C');
$valid = !\ctype_alpha($value);
\setlocale(LC_CTYPE, $locale);
if ($valid) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected a value to contain only letters. Got: %s',
static::valueToString($value)
));
}
}
/**
* @psalm-pure
*
* @param string $value
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function digits($value, $message = '')
{
$locale = \setlocale(LC_CTYPE, 0);
\setlocale(LC_CTYPE, 'C');
$valid = !\ctype_digit($value);
\setlocale(LC_CTYPE, $locale);
if ($valid) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected a value to contain digits only. Got: %s',
static::valueToString($value)
));
}
}
/**
* @psalm-pure
*
* @param string $value
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function alnum($value, $message = '')
{
$locale = \setlocale(LC_CTYPE, 0);
\setlocale(LC_CTYPE, 'C');
$valid = !\ctype_alnum($value);
\setlocale(LC_CTYPE, $locale);
if ($valid) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected a value to contain letters and digits only. Got: %s',
static::valueToString($value)
));
}
}
/**
* @psalm-pure
* @psalm-assert lowercase-string $value
*
* @param string $value
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function lower($value, $message = '')
{
$locale = \setlocale(LC_CTYPE, 0);
\setlocale(LC_CTYPE, 'C');
$valid = !\ctype_lower($value);
\setlocale(LC_CTYPE, $locale);
if ($valid) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected a value to contain lowercase characters only. Got: %s',
static::valueToString($value)
));
}
}
/**
* @psalm-pure
* @psalm-assert !lowercase-string $value
*
* @param string $value
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function upper($value, $message = '')
{
$locale = \setlocale(LC_CTYPE, 0);
\setlocale(LC_CTYPE, 'C');
$valid = !\ctype_upper($value);
\setlocale(LC_CTYPE, $locale);
if ($valid) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected a value to contain uppercase characters only. Got: %s',
static::valueToString($value)
));
}
}
/**
* @psalm-pure
*
* @param string $value
* @param int $length
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function length($value, $length, $message = '')
{
if ($length !== static::strlen($value)) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected a value to contain %2$s characters. Got: %s',
static::valueToString($value),
$length
));
}
}
/**
* Inclusive min.
*
* @psalm-pure
*
* @param string $value
* @param int|float $min
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function minLength($value, $min, $message = '')
{
if (static::strlen($value) < $min) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected a value to contain at least %2$s characters. Got: %s',
static::valueToString($value),
$min
));
}
}
/**
* Inclusive max.
*
* @psalm-pure
*
* @param string $value
* @param int|float $max
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function maxLength($value, $max, $message = '')
{
if (static::strlen($value) > $max) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected a value to contain at most %2$s characters. Got: %s',
static::valueToString($value),
$max
));
}
}
/**
* Inclusive , so Assert::lengthBetween('asd', 3, 5); passes the assertion.
*
* @psalm-pure
*
* @param string $value
* @param int|float $min
* @param int|float $max
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function lengthBetween($value, $min, $max, $message = '')
{
$length = static::strlen($value);
if ($length < $min || $length > $max) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected a value to contain between %2$s and %3$s characters. Got: %s',
static::valueToString($value),
$min,
$max
));
}
}
/**
* Will also pass if $value is a directory, use Assert::file() instead if you need to be sure it is a file.
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function fileExists($value, $message = '')
{
static::string($value);
if (!\file_exists($value)) {
static::reportInvalidArgument(\sprintf(
$message ?: 'The file %s does not exist.',
static::valueToString($value)
));
}
}
/**
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function file($value, $message = '')
{
static::fileExists($value, $message);
if (!\is_file($value)) {
static::reportInvalidArgument(\sprintf(
$message ?: 'The path %s is not a file.',
static::valueToString($value)
));
}
}
/**
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function directory($value, $message = '')
{
static::fileExists($value, $message);
if (!\is_dir($value)) {
static::reportInvalidArgument(\sprintf(
$message ?: 'The path %s is no directory.',
static::valueToString($value)
));
}
}
/**
* @param string $value
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function readable($value, $message = '')
{
if (!\is_readable($value)) {
static::reportInvalidArgument(\sprintf(
$message ?: 'The path %s is not readable.',
static::valueToString($value)
));
}
}
/**
* @param string $value
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function writable($value, $message = '')
{
if (!\is_writable($value)) {
static::reportInvalidArgument(\sprintf(
$message ?: 'The path %s is not writable.',
static::valueToString($value)
));
}
}
/**
* @psalm-assert class-string $value
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function classExists($value, $message = '')
{
if (!\class_exists($value)) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected an existing class name. Got: %s',
static::valueToString($value)
));
}
}
/**
* @psalm-pure
* @psalm-template ExpectedType of object
* @psalm-param class-string<ExpectedType> $class
* @psalm-assert class-string<ExpectedType>|ExpectedType $value
*
* @param mixed $value
* @param string|object $class
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function subclassOf($value, $class, $message = '')
{
if (!\is_subclass_of($value, $class)) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected a sub-class of %2$s. Got: %s',
static::valueToString($value),
static::valueToString($class)
));
}
}
/**
* @psalm-assert class-string $value
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function interfaceExists($value, $message = '')
{
if (!\interface_exists($value)) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected an existing interface name. got %s',
static::valueToString($value)
));
}
}
/**
* @psalm-pure
* @psalm-template ExpectedType of object
* @psalm-param class-string<ExpectedType> $interface
* @psalm-assert class-string<ExpectedType> $value
*
* @param mixed $value
* @param mixed $interface
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function implementsInterface($value, $interface, $message = '')
{
if (!\in_array($interface, \class_implements($value))) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected an implementation of %2$s. Got: %s',
static::valueToString($value),
static::valueToString($interface)
));
}
}
/**
* @psalm-pure
* @psalm-param class-string|object $classOrObject
*
* @param string|object $classOrObject
* @param mixed $property
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function propertyExists($classOrObject, $property, $message = '')
{
if (!\property_exists($classOrObject, $property)) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected the property %s to exist.',
static::valueToString($property)
));
}
}
/**
* @psalm-pure
* @psalm-param class-string|object $classOrObject
*
* @param string|object $classOrObject
* @param mixed $property
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function propertyNotExists($classOrObject, $property, $message = '')
{
if (\property_exists($classOrObject, $property)) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected the property %s to not exist.',
static::valueToString($property)
));
}
}
/**
* @psalm-pure
* @psalm-param class-string|object $classOrObject
*
* @param string|object $classOrObject
* @param mixed $method
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function methodExists($classOrObject, $method, $message = '')
{
if (!(\is_string($classOrObject) || \is_object($classOrObject)) || !\method_exists($classOrObject, $method)) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected the method %s to exist.',
static::valueToString($method)
));
}
}
/**
* @psalm-pure
* @psalm-param class-string|object $classOrObject
*
* @param string|object $classOrObject
* @param mixed $method
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function methodNotExists($classOrObject, $method, $message = '')
{
if ((\is_string($classOrObject) || \is_object($classOrObject)) && \method_exists($classOrObject, $method)) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected the method %s to not exist.',
static::valueToString($method)
));
}
}
/**
* @psalm-pure
*
* @param array $array
* @param string|int $key
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function keyExists($array, $key, $message = '')
{
if (!(isset($array[$key]) || \array_key_exists($key, $array))) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected the key %s to exist.',
static::valueToString($key)
));
}
}
/**
* @psalm-pure
*
* @param array $array
* @param string|int $key
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function keyNotExists($array, $key, $message = '')
{
if (isset($array[$key]) || \array_key_exists($key, $array)) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected the key %s to not exist.',
static::valueToString($key)
));
}
}
/**
* Checks if a value is a valid array key (int or string).
*
* @psalm-pure
* @psalm-assert array-key $value
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function validArrayKey($value, $message = '')
{
if (!(\is_int($value) || \is_string($value))) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected string or integer. Got: %s',
static::typeToString($value)
));
}
}
/**
* Does not check if $array is countable, this can generate a warning on php versions after 7.2.
*
* @param Countable|array $array
* @param int $number
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function count($array, $number, $message = '')
{
static::eq(
\count($array),
$number,
\sprintf(
$message ?: 'Expected an array to contain %d elements. Got: %d.',
$number,
\count($array)
)
);
}
/**
* Does not check if $array is countable, this can generate a warning on php versions after 7.2.
*
* @param Countable|array $array
* @param int|float $min
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function minCount($array, $min, $message = '')
{
if (\count($array) < $min) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected an array to contain at least %2$d elements. Got: %d',
\count($array),
$min
));
}
}
/**
* Does not check if $array is countable, this can generate a warning on php versions after 7.2.
*
* @param Countable|array $array
* @param int|float $max
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function maxCount($array, $max, $message = '')
{
if (\count($array) > $max) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected an array to contain at most %2$d elements. Got: %d',
\count($array),
$max
));
}
}
/**
* Does not check if $array is countable, this can generate a warning on php versions after 7.2.
*
* @param Countable|array $array
* @param int|float $min
* @param int|float $max
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function countBetween($array, $min, $max, $message = '')
{
$count = \count($array);
if ($count < $min || $count > $max) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected an array to contain between %2$d and %3$d elements. Got: %d',
$count,
$min,
$max
));
}
}
/**
* @psalm-pure
* @psalm-assert list $array
*
* @param mixed $array
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function isList($array, $message = '')
{
if (!\is_array($array)) {
static::reportInvalidArgument(
$message ?: 'Expected list - non-associative array.'
);
}
if ($array === \array_values($array)) {
return;
}
$nextKey = -1;
foreach ($array as $k => $v) {
if ($k !== ++$nextKey) {
static::reportInvalidArgument(
$message ?: 'Expected list - non-associative array.'
);
}
}
}
/**
* @psalm-pure
* @psalm-assert non-empty-list $array
*
* @param mixed $array
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function isNonEmptyList($array, $message = '')
{
static::isList($array, $message);
static::notEmpty($array, $message);
}
/**
* @psalm-pure
* @psalm-template T
* @psalm-param mixed|array<T> $array
* @psalm-assert array<string, T> $array
*
* @param mixed $array
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function isMap($array, $message = '')
{
if (
!\is_array($array) ||
\array_keys($array) !== \array_filter(\array_keys($array), '\is_string')
) {
static::reportInvalidArgument(
$message ?: 'Expected map - associative array with string keys.'
);
}
}
/**
* @psalm-pure
* @psalm-template T
* @psalm-param mixed|array<T> $array
* @psalm-assert array<string, T> $array
* @psalm-assert !empty $array
*
* @param mixed $array
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function isNonEmptyMap($array, $message = '')
{
static::isMap($array, $message);
static::notEmpty($array, $message);
}
/**
* @psalm-pure
*
* @param string $value
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function uuid($value, $message = '')
{
$value = \str_replace(array('urn:', 'uuid:', '{', '}'), '', $value);
// The nil UUID is special form of UUID that is specified to have all
// 128 bits set to zero.
if ('00000000-0000-0000-0000-000000000000' === $value) {
return;
}
if (!\preg_match('/^[0-9A-Fa-f]{8}-[0-9A-Fa-f]{4}-[0-9A-Fa-f]{4}-[0-9A-Fa-f]{4}-[0-9A-Fa-f]{12}$/', $value)) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Value %s is not a valid UUID.',
static::valueToString($value)
));
}
}
/**
* @psalm-param class-string<Throwable> $class
*
* @param Closure $expression
* @param string $class
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function throws(Closure $expression, $class = 'Exception', $message = '')
{
static::string($class);
$actual = 'none';
try {
$expression();
} catch (Exception $e) {
$actual = \get_class($e);
if ($e instanceof $class) {
return;
}
} catch (Throwable $e) {
$actual = \get_class($e);
if ($e instanceof $class) {
return;
}
}
static::reportInvalidArgument($message ?: \sprintf(
'Expected to throw "%s", got "%s"',
$class,
$actual
));
}
/**
* @throws BadMethodCallException
*/
public static function __callStatic($name, $arguments)
{
if ('nullOr' === \substr($name, 0, 6)) {
if (null !== $arguments[0]) {
$method = \lcfirst(\substr($name, 6));
\call_user_func_array(array(static::class, $method), $arguments);
}
return;
}
if ('all' === \substr($name, 0, 3)) {
static::isIterable($arguments[0]);
$method = \lcfirst(\substr($name, 3));
$args = $arguments;
foreach ($arguments[0] as $entry) {
$args[0] = $entry;
\call_user_func_array(array(static::class, $method), $args);
}
return;
}
throw new BadMethodCallException('No such method: '.$name);
}
/**
* @param mixed $value
*
* @return string
*/
protected static function valueToString($value)
{
if (null === $value) {
return 'null';
}
if (true === $value) {
return 'true';
}
if (false === $value) {
return 'false';
}
if (\is_array($value)) {
return 'array';
}
if (\is_object($value)) {
if (\method_exists($value, '__toString')) {
return \get_class($value).': '.self::valueToString($value->__toString());
}
if ($value instanceof DateTime || $value instanceof DateTimeImmutable) {
return \get_class($value).': '.self::valueToString($value->format('c'));
}
return \get_class($value);
}
if (\is_resource($value)) {
return 'resource';
}
if (\is_string($value)) {
return '"'.$value.'"';
}
return (string) $value;
}
/**
* @param mixed $value
*
* @return string
*/
protected static function typeToString($value)
{
return \is_object($value) ? \get_class($value) : \gettype($value);
}
protected static function strlen($value)
{
if (!\function_exists('mb_detect_encoding')) {
return \strlen($value);
}
if (false === $encoding = \mb_detect_encoding($value)) {
return \strlen($value);
}
return \mb_strlen($value, $encoding);
}
/**
* @param string $message
*
* @throws InvalidArgumentException
*
* @psalm-pure this method is not supposed to perform side-effects
* @psalm-return never
*/
protected static function reportInvalidArgument($message)
{
throw new InvalidArgumentException($message);
}
private function __construct()
{
}
}
assert/src/InvalidArgumentException.php 0000644 00000000533 14736103027 0014321 0 ustar 00 <?php
/*
* This file is part of the webmozart/assert package.
*
* (c) Bernhard Schussek <bschussek@gmail.com>
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace Webmozart\Assert;
class InvalidArgumentException extends \InvalidArgumentException
{
}
assert/src/Mixin.php 0000644 00000353361 14736103027 0010447 0 ustar 00 <?php
namespace Webmozart\Assert;
use ArrayAccess;
use Closure;
use Countable;
use Throwable;
/**
* This trait provides nurllOr*, all* and allNullOr* variants of assertion base methods.
* Do not use this trait directly: it will change, and is not designed for reuse.
*/
trait Mixin
{
/**
* @psalm-pure
* @psalm-assert string|null $value
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function nullOrString($value, $message = '')
{
null === $value || static::string($value, $message);
}
/**
* @psalm-pure
* @psalm-assert iterable<string> $value
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allString($value, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
static::string($entry, $message);
}
}
/**
* @psalm-pure
* @psalm-assert iterable<string|null> $value
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allNullOrString($value, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
null === $entry || static::string($entry, $message);
}
}
/**
* @psalm-pure
* @psalm-assert non-empty-string|null $value
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function nullOrStringNotEmpty($value, $message = '')
{
null === $value || static::stringNotEmpty($value, $message);
}
/**
* @psalm-pure
* @psalm-assert iterable<non-empty-string> $value
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allStringNotEmpty($value, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
static::stringNotEmpty($entry, $message);
}
}
/**
* @psalm-pure
* @psalm-assert iterable<non-empty-string|null> $value
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allNullOrStringNotEmpty($value, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
null === $entry || static::stringNotEmpty($entry, $message);
}
}
/**
* @psalm-pure
* @psalm-assert int|null $value
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function nullOrInteger($value, $message = '')
{
null === $value || static::integer($value, $message);
}
/**
* @psalm-pure
* @psalm-assert iterable<int> $value
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allInteger($value, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
static::integer($entry, $message);
}
}
/**
* @psalm-pure
* @psalm-assert iterable<int|null> $value
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allNullOrInteger($value, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
null === $entry || static::integer($entry, $message);
}
}
/**
* @psalm-pure
* @psalm-assert numeric|null $value
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function nullOrIntegerish($value, $message = '')
{
null === $value || static::integerish($value, $message);
}
/**
* @psalm-pure
* @psalm-assert iterable<numeric> $value
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allIntegerish($value, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
static::integerish($entry, $message);
}
}
/**
* @psalm-pure
* @psalm-assert iterable<numeric|null> $value
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allNullOrIntegerish($value, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
null === $entry || static::integerish($entry, $message);
}
}
/**
* @psalm-pure
* @psalm-assert positive-int|null $value
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function nullOrPositiveInteger($value, $message = '')
{
null === $value || static::positiveInteger($value, $message);
}
/**
* @psalm-pure
* @psalm-assert iterable<positive-int> $value
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allPositiveInteger($value, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
static::positiveInteger($entry, $message);
}
}
/**
* @psalm-pure
* @psalm-assert iterable<positive-int|null> $value
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allNullOrPositiveInteger($value, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
null === $entry || static::positiveInteger($entry, $message);
}
}
/**
* @psalm-pure
* @psalm-assert float|null $value
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function nullOrFloat($value, $message = '')
{
null === $value || static::float($value, $message);
}
/**
* @psalm-pure
* @psalm-assert iterable<float> $value
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allFloat($value, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
static::float($entry, $message);
}
}
/**
* @psalm-pure
* @psalm-assert iterable<float|null> $value
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allNullOrFloat($value, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
null === $entry || static::float($entry, $message);
}
}
/**
* @psalm-pure
* @psalm-assert numeric|null $value
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function nullOrNumeric($value, $message = '')
{
null === $value || static::numeric($value, $message);
}
/**
* @psalm-pure
* @psalm-assert iterable<numeric> $value
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allNumeric($value, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
static::numeric($entry, $message);
}
}
/**
* @psalm-pure
* @psalm-assert iterable<numeric|null> $value
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allNullOrNumeric($value, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
null === $entry || static::numeric($entry, $message);
}
}
/**
* @psalm-pure
* @psalm-assert positive-int|0|null $value
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function nullOrNatural($value, $message = '')
{
null === $value || static::natural($value, $message);
}
/**
* @psalm-pure
* @psalm-assert iterable<positive-int|0> $value
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allNatural($value, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
static::natural($entry, $message);
}
}
/**
* @psalm-pure
* @psalm-assert iterable<positive-int|0|null> $value
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allNullOrNatural($value, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
null === $entry || static::natural($entry, $message);
}
}
/**
* @psalm-pure
* @psalm-assert bool|null $value
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function nullOrBoolean($value, $message = '')
{
null === $value || static::boolean($value, $message);
}
/**
* @psalm-pure
* @psalm-assert iterable<bool> $value
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allBoolean($value, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
static::boolean($entry, $message);
}
}
/**
* @psalm-pure
* @psalm-assert iterable<bool|null> $value
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allNullOrBoolean($value, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
null === $entry || static::boolean($entry, $message);
}
}
/**
* @psalm-pure
* @psalm-assert scalar|null $value
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function nullOrScalar($value, $message = '')
{
null === $value || static::scalar($value, $message);
}
/**
* @psalm-pure
* @psalm-assert iterable<scalar> $value
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allScalar($value, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
static::scalar($entry, $message);
}
}
/**
* @psalm-pure
* @psalm-assert iterable<scalar|null> $value
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allNullOrScalar($value, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
null === $entry || static::scalar($entry, $message);
}
}
/**
* @psalm-pure
* @psalm-assert object|null $value
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function nullOrObject($value, $message = '')
{
null === $value || static::object($value, $message);
}
/**
* @psalm-pure
* @psalm-assert iterable<object> $value
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allObject($value, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
static::object($entry, $message);
}
}
/**
* @psalm-pure
* @psalm-assert iterable<object|null> $value
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allNullOrObject($value, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
null === $entry || static::object($entry, $message);
}
}
/**
* @psalm-pure
* @psalm-assert resource|null $value
*
* @param mixed $value
* @param string|null $type type of resource this should be. @see https://www.php.net/manual/en/function.get-resource-type.php
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function nullOrResource($value, $type = null, $message = '')
{
null === $value || static::resource($value, $type, $message);
}
/**
* @psalm-pure
* @psalm-assert iterable<resource> $value
*
* @param mixed $value
* @param string|null $type type of resource this should be. @see https://www.php.net/manual/en/function.get-resource-type.php
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allResource($value, $type = null, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
static::resource($entry, $type, $message);
}
}
/**
* @psalm-pure
* @psalm-assert iterable<resource|null> $value
*
* @param mixed $value
* @param string|null $type type of resource this should be. @see https://www.php.net/manual/en/function.get-resource-type.php
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allNullOrResource($value, $type = null, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
null === $entry || static::resource($entry, $type, $message);
}
}
/**
* @psalm-pure
* @psalm-assert callable|null $value
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function nullOrIsCallable($value, $message = '')
{
null === $value || static::isCallable($value, $message);
}
/**
* @psalm-pure
* @psalm-assert iterable<callable> $value
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allIsCallable($value, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
static::isCallable($entry, $message);
}
}
/**
* @psalm-pure
* @psalm-assert iterable<callable|null> $value
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allNullOrIsCallable($value, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
null === $entry || static::isCallable($entry, $message);
}
}
/**
* @psalm-pure
* @psalm-assert array|null $value
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function nullOrIsArray($value, $message = '')
{
null === $value || static::isArray($value, $message);
}
/**
* @psalm-pure
* @psalm-assert iterable<array> $value
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allIsArray($value, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
static::isArray($entry, $message);
}
}
/**
* @psalm-pure
* @psalm-assert iterable<array|null> $value
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allNullOrIsArray($value, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
null === $entry || static::isArray($entry, $message);
}
}
/**
* @psalm-pure
* @psalm-assert iterable|null $value
*
* @deprecated use "isIterable" or "isInstanceOf" instead
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function nullOrIsTraversable($value, $message = '')
{
null === $value || static::isTraversable($value, $message);
}
/**
* @psalm-pure
* @psalm-assert iterable<iterable> $value
*
* @deprecated use "isIterable" or "isInstanceOf" instead
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allIsTraversable($value, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
static::isTraversable($entry, $message);
}
}
/**
* @psalm-pure
* @psalm-assert iterable<iterable|null> $value
*
* @deprecated use "isIterable" or "isInstanceOf" instead
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allNullOrIsTraversable($value, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
null === $entry || static::isTraversable($entry, $message);
}
}
/**
* @psalm-pure
* @psalm-assert array|ArrayAccess|null $value
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function nullOrIsArrayAccessible($value, $message = '')
{
null === $value || static::isArrayAccessible($value, $message);
}
/**
* @psalm-pure
* @psalm-assert iterable<array|ArrayAccess> $value
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allIsArrayAccessible($value, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
static::isArrayAccessible($entry, $message);
}
}
/**
* @psalm-pure
* @psalm-assert iterable<array|ArrayAccess|null> $value
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allNullOrIsArrayAccessible($value, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
null === $entry || static::isArrayAccessible($entry, $message);
}
}
/**
* @psalm-pure
* @psalm-assert countable|null $value
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function nullOrIsCountable($value, $message = '')
{
null === $value || static::isCountable($value, $message);
}
/**
* @psalm-pure
* @psalm-assert iterable<countable> $value
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allIsCountable($value, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
static::isCountable($entry, $message);
}
}
/**
* @psalm-pure
* @psalm-assert iterable<countable|null> $value
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allNullOrIsCountable($value, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
null === $entry || static::isCountable($entry, $message);
}
}
/**
* @psalm-pure
* @psalm-assert iterable|null $value
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function nullOrIsIterable($value, $message = '')
{
null === $value || static::isIterable($value, $message);
}
/**
* @psalm-pure
* @psalm-assert iterable<iterable> $value
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allIsIterable($value, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
static::isIterable($entry, $message);
}
}
/**
* @psalm-pure
* @psalm-assert iterable<iterable|null> $value
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allNullOrIsIterable($value, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
null === $entry || static::isIterable($entry, $message);
}
}
/**
* @psalm-pure
* @psalm-template ExpectedType of object
* @psalm-param class-string<ExpectedType> $class
* @psalm-assert ExpectedType|null $value
*
* @param mixed $value
* @param string|object $class
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function nullOrIsInstanceOf($value, $class, $message = '')
{
null === $value || static::isInstanceOf($value, $class, $message);
}
/**
* @psalm-pure
* @psalm-template ExpectedType of object
* @psalm-param class-string<ExpectedType> $class
* @psalm-assert iterable<ExpectedType> $value
*
* @param mixed $value
* @param string|object $class
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allIsInstanceOf($value, $class, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
static::isInstanceOf($entry, $class, $message);
}
}
/**
* @psalm-pure
* @psalm-template ExpectedType of object
* @psalm-param class-string<ExpectedType> $class
* @psalm-assert iterable<ExpectedType|null> $value
*
* @param mixed $value
* @param string|object $class
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allNullOrIsInstanceOf($value, $class, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
null === $entry || static::isInstanceOf($entry, $class, $message);
}
}
/**
* @psalm-pure
* @psalm-template ExpectedType of object
* @psalm-param class-string<ExpectedType> $class
*
* @param mixed $value
* @param string|object $class
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function nullOrNotInstanceOf($value, $class, $message = '')
{
null === $value || static::notInstanceOf($value, $class, $message);
}
/**
* @psalm-pure
* @psalm-template ExpectedType of object
* @psalm-param class-string<ExpectedType> $class
*
* @param mixed $value
* @param string|object $class
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allNotInstanceOf($value, $class, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
static::notInstanceOf($entry, $class, $message);
}
}
/**
* @psalm-pure
* @psalm-template ExpectedType of object
* @psalm-param class-string<ExpectedType> $class
* @psalm-assert iterable<!ExpectedType|null> $value
*
* @param mixed $value
* @param string|object $class
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allNullOrNotInstanceOf($value, $class, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
null === $entry || static::notInstanceOf($entry, $class, $message);
}
}
/**
* @psalm-pure
* @psalm-param array<class-string> $classes
*
* @param mixed $value
* @param array<object|string> $classes
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function nullOrIsInstanceOfAny($value, $classes, $message = '')
{
null === $value || static::isInstanceOfAny($value, $classes, $message);
}
/**
* @psalm-pure
* @psalm-param array<class-string> $classes
*
* @param mixed $value
* @param array<object|string> $classes
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allIsInstanceOfAny($value, $classes, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
static::isInstanceOfAny($entry, $classes, $message);
}
}
/**
* @psalm-pure
* @psalm-param array<class-string> $classes
*
* @param mixed $value
* @param array<object|string> $classes
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allNullOrIsInstanceOfAny($value, $classes, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
null === $entry || static::isInstanceOfAny($entry, $classes, $message);
}
}
/**
* @psalm-pure
* @psalm-template ExpectedType of object
* @psalm-param class-string<ExpectedType> $class
* @psalm-assert ExpectedType|class-string<ExpectedType>|null $value
*
* @param object|string|null $value
* @param string $class
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function nullOrIsAOf($value, $class, $message = '')
{
null === $value || static::isAOf($value, $class, $message);
}
/**
* @psalm-pure
* @psalm-template ExpectedType of object
* @psalm-param class-string<ExpectedType> $class
* @psalm-assert iterable<ExpectedType|class-string<ExpectedType>> $value
*
* @param iterable<object|string> $value
* @param string $class
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allIsAOf($value, $class, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
static::isAOf($entry, $class, $message);
}
}
/**
* @psalm-pure
* @psalm-template ExpectedType of object
* @psalm-param class-string<ExpectedType> $class
* @psalm-assert iterable<ExpectedType|class-string<ExpectedType>|null> $value
*
* @param iterable<object|string|null> $value
* @param string $class
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allNullOrIsAOf($value, $class, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
null === $entry || static::isAOf($entry, $class, $message);
}
}
/**
* @psalm-pure
* @psalm-template UnexpectedType of object
* @psalm-param class-string<UnexpectedType> $class
*
* @param object|string|null $value
* @param string $class
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function nullOrIsNotA($value, $class, $message = '')
{
null === $value || static::isNotA($value, $class, $message);
}
/**
* @psalm-pure
* @psalm-template UnexpectedType of object
* @psalm-param class-string<UnexpectedType> $class
*
* @param iterable<object|string> $value
* @param string $class
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allIsNotA($value, $class, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
static::isNotA($entry, $class, $message);
}
}
/**
* @psalm-pure
* @psalm-template UnexpectedType of object
* @psalm-param class-string<UnexpectedType> $class
* @psalm-assert iterable<!UnexpectedType|null> $value
* @psalm-assert iterable<!class-string<UnexpectedType>|null> $value
*
* @param iterable<object|string|null> $value
* @param string $class
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allNullOrIsNotA($value, $class, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
null === $entry || static::isNotA($entry, $class, $message);
}
}
/**
* @psalm-pure
* @psalm-param array<class-string> $classes
*
* @param object|string|null $value
* @param string[] $classes
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function nullOrIsAnyOf($value, $classes, $message = '')
{
null === $value || static::isAnyOf($value, $classes, $message);
}
/**
* @psalm-pure
* @psalm-param array<class-string> $classes
*
* @param iterable<object|string> $value
* @param string[] $classes
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allIsAnyOf($value, $classes, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
static::isAnyOf($entry, $classes, $message);
}
}
/**
* @psalm-pure
* @psalm-param array<class-string> $classes
*
* @param iterable<object|string|null> $value
* @param string[] $classes
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allNullOrIsAnyOf($value, $classes, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
null === $entry || static::isAnyOf($entry, $classes, $message);
}
}
/**
* @psalm-pure
* @psalm-assert empty $value
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function nullOrIsEmpty($value, $message = '')
{
null === $value || static::isEmpty($value, $message);
}
/**
* @psalm-pure
* @psalm-assert iterable<empty> $value
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allIsEmpty($value, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
static::isEmpty($entry, $message);
}
}
/**
* @psalm-pure
* @psalm-assert iterable<empty|null> $value
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allNullOrIsEmpty($value, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
null === $entry || static::isEmpty($entry, $message);
}
}
/**
* @psalm-pure
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function nullOrNotEmpty($value, $message = '')
{
null === $value || static::notEmpty($value, $message);
}
/**
* @psalm-pure
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allNotEmpty($value, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
static::notEmpty($entry, $message);
}
}
/**
* @psalm-pure
* @psalm-assert iterable<!empty|null> $value
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allNullOrNotEmpty($value, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
null === $entry || static::notEmpty($entry, $message);
}
}
/**
* @psalm-pure
* @psalm-assert iterable<null> $value
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allNull($value, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
static::null($entry, $message);
}
}
/**
* @psalm-pure
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allNotNull($value, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
static::notNull($entry, $message);
}
}
/**
* @psalm-pure
* @psalm-assert true|null $value
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function nullOrTrue($value, $message = '')
{
null === $value || static::true($value, $message);
}
/**
* @psalm-pure
* @psalm-assert iterable<true> $value
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allTrue($value, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
static::true($entry, $message);
}
}
/**
* @psalm-pure
* @psalm-assert iterable<true|null> $value
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allNullOrTrue($value, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
null === $entry || static::true($entry, $message);
}
}
/**
* @psalm-pure
* @psalm-assert false|null $value
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function nullOrFalse($value, $message = '')
{
null === $value || static::false($value, $message);
}
/**
* @psalm-pure
* @psalm-assert iterable<false> $value
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allFalse($value, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
static::false($entry, $message);
}
}
/**
* @psalm-pure
* @psalm-assert iterable<false|null> $value
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allNullOrFalse($value, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
null === $entry || static::false($entry, $message);
}
}
/**
* @psalm-pure
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function nullOrNotFalse($value, $message = '')
{
null === $value || static::notFalse($value, $message);
}
/**
* @psalm-pure
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allNotFalse($value, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
static::notFalse($entry, $message);
}
}
/**
* @psalm-pure
* @psalm-assert iterable<!false|null> $value
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allNullOrNotFalse($value, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
null === $entry || static::notFalse($entry, $message);
}
}
/**
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function nullOrIp($value, $message = '')
{
null === $value || static::ip($value, $message);
}
/**
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allIp($value, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
static::ip($entry, $message);
}
}
/**
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allNullOrIp($value, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
null === $entry || static::ip($entry, $message);
}
}
/**
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function nullOrIpv4($value, $message = '')
{
null === $value || static::ipv4($value, $message);
}
/**
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allIpv4($value, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
static::ipv4($entry, $message);
}
}
/**
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allNullOrIpv4($value, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
null === $entry || static::ipv4($entry, $message);
}
}
/**
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function nullOrIpv6($value, $message = '')
{
null === $value || static::ipv6($value, $message);
}
/**
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allIpv6($value, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
static::ipv6($entry, $message);
}
}
/**
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allNullOrIpv6($value, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
null === $entry || static::ipv6($entry, $message);
}
}
/**
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function nullOrEmail($value, $message = '')
{
null === $value || static::email($value, $message);
}
/**
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allEmail($value, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
static::email($entry, $message);
}
}
/**
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allNullOrEmail($value, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
null === $entry || static::email($entry, $message);
}
}
/**
* @param array|null $values
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function nullOrUniqueValues($values, $message = '')
{
null === $values || static::uniqueValues($values, $message);
}
/**
* @param iterable<array> $values
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allUniqueValues($values, $message = '')
{
static::isIterable($values);
foreach ($values as $entry) {
static::uniqueValues($entry, $message);
}
}
/**
* @param iterable<array|null> $values
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allNullOrUniqueValues($values, $message = '')
{
static::isIterable($values);
foreach ($values as $entry) {
null === $entry || static::uniqueValues($entry, $message);
}
}
/**
* @param mixed $value
* @param mixed $expect
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function nullOrEq($value, $expect, $message = '')
{
null === $value || static::eq($value, $expect, $message);
}
/**
* @param mixed $value
* @param mixed $expect
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allEq($value, $expect, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
static::eq($entry, $expect, $message);
}
}
/**
* @param mixed $value
* @param mixed $expect
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allNullOrEq($value, $expect, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
null === $entry || static::eq($entry, $expect, $message);
}
}
/**
* @param mixed $value
* @param mixed $expect
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function nullOrNotEq($value, $expect, $message = '')
{
null === $value || static::notEq($value, $expect, $message);
}
/**
* @param mixed $value
* @param mixed $expect
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allNotEq($value, $expect, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
static::notEq($entry, $expect, $message);
}
}
/**
* @param mixed $value
* @param mixed $expect
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allNullOrNotEq($value, $expect, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
null === $entry || static::notEq($entry, $expect, $message);
}
}
/**
* @psalm-pure
*
* @param mixed $value
* @param mixed $expect
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function nullOrSame($value, $expect, $message = '')
{
null === $value || static::same($value, $expect, $message);
}
/**
* @psalm-pure
*
* @param mixed $value
* @param mixed $expect
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allSame($value, $expect, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
static::same($entry, $expect, $message);
}
}
/**
* @psalm-pure
*
* @param mixed $value
* @param mixed $expect
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allNullOrSame($value, $expect, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
null === $entry || static::same($entry, $expect, $message);
}
}
/**
* @psalm-pure
*
* @param mixed $value
* @param mixed $expect
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function nullOrNotSame($value, $expect, $message = '')
{
null === $value || static::notSame($value, $expect, $message);
}
/**
* @psalm-pure
*
* @param mixed $value
* @param mixed $expect
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allNotSame($value, $expect, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
static::notSame($entry, $expect, $message);
}
}
/**
* @psalm-pure
*
* @param mixed $value
* @param mixed $expect
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allNullOrNotSame($value, $expect, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
null === $entry || static::notSame($entry, $expect, $message);
}
}
/**
* @psalm-pure
*
* @param mixed $value
* @param mixed $limit
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function nullOrGreaterThan($value, $limit, $message = '')
{
null === $value || static::greaterThan($value, $limit, $message);
}
/**
* @psalm-pure
*
* @param mixed $value
* @param mixed $limit
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allGreaterThan($value, $limit, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
static::greaterThan($entry, $limit, $message);
}
}
/**
* @psalm-pure
*
* @param mixed $value
* @param mixed $limit
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allNullOrGreaterThan($value, $limit, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
null === $entry || static::greaterThan($entry, $limit, $message);
}
}
/**
* @psalm-pure
*
* @param mixed $value
* @param mixed $limit
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function nullOrGreaterThanEq($value, $limit, $message = '')
{
null === $value || static::greaterThanEq($value, $limit, $message);
}
/**
* @psalm-pure
*
* @param mixed $value
* @param mixed $limit
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allGreaterThanEq($value, $limit, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
static::greaterThanEq($entry, $limit, $message);
}
}
/**
* @psalm-pure
*
* @param mixed $value
* @param mixed $limit
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allNullOrGreaterThanEq($value, $limit, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
null === $entry || static::greaterThanEq($entry, $limit, $message);
}
}
/**
* @psalm-pure
*
* @param mixed $value
* @param mixed $limit
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function nullOrLessThan($value, $limit, $message = '')
{
null === $value || static::lessThan($value, $limit, $message);
}
/**
* @psalm-pure
*
* @param mixed $value
* @param mixed $limit
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allLessThan($value, $limit, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
static::lessThan($entry, $limit, $message);
}
}
/**
* @psalm-pure
*
* @param mixed $value
* @param mixed $limit
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allNullOrLessThan($value, $limit, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
null === $entry || static::lessThan($entry, $limit, $message);
}
}
/**
* @psalm-pure
*
* @param mixed $value
* @param mixed $limit
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function nullOrLessThanEq($value, $limit, $message = '')
{
null === $value || static::lessThanEq($value, $limit, $message);
}
/**
* @psalm-pure
*
* @param mixed $value
* @param mixed $limit
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allLessThanEq($value, $limit, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
static::lessThanEq($entry, $limit, $message);
}
}
/**
* @psalm-pure
*
* @param mixed $value
* @param mixed $limit
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allNullOrLessThanEq($value, $limit, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
null === $entry || static::lessThanEq($entry, $limit, $message);
}
}
/**
* @psalm-pure
*
* @param mixed $value
* @param mixed $min
* @param mixed $max
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function nullOrRange($value, $min, $max, $message = '')
{
null === $value || static::range($value, $min, $max, $message);
}
/**
* @psalm-pure
*
* @param mixed $value
* @param mixed $min
* @param mixed $max
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allRange($value, $min, $max, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
static::range($entry, $min, $max, $message);
}
}
/**
* @psalm-pure
*
* @param mixed $value
* @param mixed $min
* @param mixed $max
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allNullOrRange($value, $min, $max, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
null === $entry || static::range($entry, $min, $max, $message);
}
}
/**
* @psalm-pure
*
* @param mixed $value
* @param array $values
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function nullOrOneOf($value, $values, $message = '')
{
null === $value || static::oneOf($value, $values, $message);
}
/**
* @psalm-pure
*
* @param mixed $value
* @param array $values
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allOneOf($value, $values, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
static::oneOf($entry, $values, $message);
}
}
/**
* @psalm-pure
*
* @param mixed $value
* @param array $values
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allNullOrOneOf($value, $values, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
null === $entry || static::oneOf($entry, $values, $message);
}
}
/**
* @psalm-pure
*
* @param mixed $value
* @param array $values
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function nullOrInArray($value, $values, $message = '')
{
null === $value || static::inArray($value, $values, $message);
}
/**
* @psalm-pure
*
* @param mixed $value
* @param array $values
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allInArray($value, $values, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
static::inArray($entry, $values, $message);
}
}
/**
* @psalm-pure
*
* @param mixed $value
* @param array $values
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allNullOrInArray($value, $values, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
null === $entry || static::inArray($entry, $values, $message);
}
}
/**
* @psalm-pure
*
* @param string|null $value
* @param string $subString
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function nullOrContains($value, $subString, $message = '')
{
null === $value || static::contains($value, $subString, $message);
}
/**
* @psalm-pure
*
* @param iterable<string> $value
* @param string $subString
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allContains($value, $subString, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
static::contains($entry, $subString, $message);
}
}
/**
* @psalm-pure
*
* @param iterable<string|null> $value
* @param string $subString
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allNullOrContains($value, $subString, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
null === $entry || static::contains($entry, $subString, $message);
}
}
/**
* @psalm-pure
*
* @param string|null $value
* @param string $subString
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function nullOrNotContains($value, $subString, $message = '')
{
null === $value || static::notContains($value, $subString, $message);
}
/**
* @psalm-pure
*
* @param iterable<string> $value
* @param string $subString
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allNotContains($value, $subString, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
static::notContains($entry, $subString, $message);
}
}
/**
* @psalm-pure
*
* @param iterable<string|null> $value
* @param string $subString
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allNullOrNotContains($value, $subString, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
null === $entry || static::notContains($entry, $subString, $message);
}
}
/**
* @psalm-pure
*
* @param string|null $value
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function nullOrNotWhitespaceOnly($value, $message = '')
{
null === $value || static::notWhitespaceOnly($value, $message);
}
/**
* @psalm-pure
*
* @param iterable<string> $value
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allNotWhitespaceOnly($value, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
static::notWhitespaceOnly($entry, $message);
}
}
/**
* @psalm-pure
*
* @param iterable<string|null> $value
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allNullOrNotWhitespaceOnly($value, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
null === $entry || static::notWhitespaceOnly($entry, $message);
}
}
/**
* @psalm-pure
*
* @param string|null $value
* @param string $prefix
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function nullOrStartsWith($value, $prefix, $message = '')
{
null === $value || static::startsWith($value, $prefix, $message);
}
/**
* @psalm-pure
*
* @param iterable<string> $value
* @param string $prefix
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allStartsWith($value, $prefix, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
static::startsWith($entry, $prefix, $message);
}
}
/**
* @psalm-pure
*
* @param iterable<string|null> $value
* @param string $prefix
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allNullOrStartsWith($value, $prefix, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
null === $entry || static::startsWith($entry, $prefix, $message);
}
}
/**
* @psalm-pure
*
* @param string|null $value
* @param string $prefix
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function nullOrNotStartsWith($value, $prefix, $message = '')
{
null === $value || static::notStartsWith($value, $prefix, $message);
}
/**
* @psalm-pure
*
* @param iterable<string> $value
* @param string $prefix
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allNotStartsWith($value, $prefix, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
static::notStartsWith($entry, $prefix, $message);
}
}
/**
* @psalm-pure
*
* @param iterable<string|null> $value
* @param string $prefix
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allNullOrNotStartsWith($value, $prefix, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
null === $entry || static::notStartsWith($entry, $prefix, $message);
}
}
/**
* @psalm-pure
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function nullOrStartsWithLetter($value, $message = '')
{
null === $value || static::startsWithLetter($value, $message);
}
/**
* @psalm-pure
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allStartsWithLetter($value, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
static::startsWithLetter($entry, $message);
}
}
/**
* @psalm-pure
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allNullOrStartsWithLetter($value, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
null === $entry || static::startsWithLetter($entry, $message);
}
}
/**
* @psalm-pure
*
* @param string|null $value
* @param string $suffix
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function nullOrEndsWith($value, $suffix, $message = '')
{
null === $value || static::endsWith($value, $suffix, $message);
}
/**
* @psalm-pure
*
* @param iterable<string> $value
* @param string $suffix
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allEndsWith($value, $suffix, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
static::endsWith($entry, $suffix, $message);
}
}
/**
* @psalm-pure
*
* @param iterable<string|null> $value
* @param string $suffix
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allNullOrEndsWith($value, $suffix, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
null === $entry || static::endsWith($entry, $suffix, $message);
}
}
/**
* @psalm-pure
*
* @param string|null $value
* @param string $suffix
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function nullOrNotEndsWith($value, $suffix, $message = '')
{
null === $value || static::notEndsWith($value, $suffix, $message);
}
/**
* @psalm-pure
*
* @param iterable<string> $value
* @param string $suffix
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allNotEndsWith($value, $suffix, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
static::notEndsWith($entry, $suffix, $message);
}
}
/**
* @psalm-pure
*
* @param iterable<string|null> $value
* @param string $suffix
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allNullOrNotEndsWith($value, $suffix, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
null === $entry || static::notEndsWith($entry, $suffix, $message);
}
}
/**
* @psalm-pure
*
* @param string|null $value
* @param string $pattern
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function nullOrRegex($value, $pattern, $message = '')
{
null === $value || static::regex($value, $pattern, $message);
}
/**
* @psalm-pure
*
* @param iterable<string> $value
* @param string $pattern
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allRegex($value, $pattern, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
static::regex($entry, $pattern, $message);
}
}
/**
* @psalm-pure
*
* @param iterable<string|null> $value
* @param string $pattern
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allNullOrRegex($value, $pattern, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
null === $entry || static::regex($entry, $pattern, $message);
}
}
/**
* @psalm-pure
*
* @param string|null $value
* @param string $pattern
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function nullOrNotRegex($value, $pattern, $message = '')
{
null === $value || static::notRegex($value, $pattern, $message);
}
/**
* @psalm-pure
*
* @param iterable<string> $value
* @param string $pattern
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allNotRegex($value, $pattern, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
static::notRegex($entry, $pattern, $message);
}
}
/**
* @psalm-pure
*
* @param iterable<string|null> $value
* @param string $pattern
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allNullOrNotRegex($value, $pattern, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
null === $entry || static::notRegex($entry, $pattern, $message);
}
}
/**
* @psalm-pure
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function nullOrUnicodeLetters($value, $message = '')
{
null === $value || static::unicodeLetters($value, $message);
}
/**
* @psalm-pure
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allUnicodeLetters($value, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
static::unicodeLetters($entry, $message);
}
}
/**
* @psalm-pure
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allNullOrUnicodeLetters($value, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
null === $entry || static::unicodeLetters($entry, $message);
}
}
/**
* @psalm-pure
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function nullOrAlpha($value, $message = '')
{
null === $value || static::alpha($value, $message);
}
/**
* @psalm-pure
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allAlpha($value, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
static::alpha($entry, $message);
}
}
/**
* @psalm-pure
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allNullOrAlpha($value, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
null === $entry || static::alpha($entry, $message);
}
}
/**
* @psalm-pure
*
* @param string|null $value
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function nullOrDigits($value, $message = '')
{
null === $value || static::digits($value, $message);
}
/**
* @psalm-pure
*
* @param iterable<string> $value
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allDigits($value, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
static::digits($entry, $message);
}
}
/**
* @psalm-pure
*
* @param iterable<string|null> $value
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allNullOrDigits($value, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
null === $entry || static::digits($entry, $message);
}
}
/**
* @psalm-pure
*
* @param string|null $value
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function nullOrAlnum($value, $message = '')
{
null === $value || static::alnum($value, $message);
}
/**
* @psalm-pure
*
* @param iterable<string> $value
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allAlnum($value, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
static::alnum($entry, $message);
}
}
/**
* @psalm-pure
*
* @param iterable<string|null> $value
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allNullOrAlnum($value, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
null === $entry || static::alnum($entry, $message);
}
}
/**
* @psalm-pure
* @psalm-assert lowercase-string|null $value
*
* @param string|null $value
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function nullOrLower($value, $message = '')
{
null === $value || static::lower($value, $message);
}
/**
* @psalm-pure
* @psalm-assert iterable<lowercase-string> $value
*
* @param iterable<string> $value
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allLower($value, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
static::lower($entry, $message);
}
}
/**
* @psalm-pure
* @psalm-assert iterable<lowercase-string|null> $value
*
* @param iterable<string|null> $value
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allNullOrLower($value, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
null === $entry || static::lower($entry, $message);
}
}
/**
* @psalm-pure
*
* @param string|null $value
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function nullOrUpper($value, $message = '')
{
null === $value || static::upper($value, $message);
}
/**
* @psalm-pure
*
* @param iterable<string> $value
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allUpper($value, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
static::upper($entry, $message);
}
}
/**
* @psalm-pure
* @psalm-assert iterable<!lowercase-string|null> $value
*
* @param iterable<string|null> $value
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allNullOrUpper($value, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
null === $entry || static::upper($entry, $message);
}
}
/**
* @psalm-pure
*
* @param string|null $value
* @param int $length
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function nullOrLength($value, $length, $message = '')
{
null === $value || static::length($value, $length, $message);
}
/**
* @psalm-pure
*
* @param iterable<string> $value
* @param int $length
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allLength($value, $length, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
static::length($entry, $length, $message);
}
}
/**
* @psalm-pure
*
* @param iterable<string|null> $value
* @param int $length
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allNullOrLength($value, $length, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
null === $entry || static::length($entry, $length, $message);
}
}
/**
* @psalm-pure
*
* @param string|null $value
* @param int|float $min
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function nullOrMinLength($value, $min, $message = '')
{
null === $value || static::minLength($value, $min, $message);
}
/**
* @psalm-pure
*
* @param iterable<string> $value
* @param int|float $min
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allMinLength($value, $min, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
static::minLength($entry, $min, $message);
}
}
/**
* @psalm-pure
*
* @param iterable<string|null> $value
* @param int|float $min
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allNullOrMinLength($value, $min, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
null === $entry || static::minLength($entry, $min, $message);
}
}
/**
* @psalm-pure
*
* @param string|null $value
* @param int|float $max
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function nullOrMaxLength($value, $max, $message = '')
{
null === $value || static::maxLength($value, $max, $message);
}
/**
* @psalm-pure
*
* @param iterable<string> $value
* @param int|float $max
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allMaxLength($value, $max, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
static::maxLength($entry, $max, $message);
}
}
/**
* @psalm-pure
*
* @param iterable<string|null> $value
* @param int|float $max
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allNullOrMaxLength($value, $max, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
null === $entry || static::maxLength($entry, $max, $message);
}
}
/**
* @psalm-pure
*
* @param string|null $value
* @param int|float $min
* @param int|float $max
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function nullOrLengthBetween($value, $min, $max, $message = '')
{
null === $value || static::lengthBetween($value, $min, $max, $message);
}
/**
* @psalm-pure
*
* @param iterable<string> $value
* @param int|float $min
* @param int|float $max
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allLengthBetween($value, $min, $max, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
static::lengthBetween($entry, $min, $max, $message);
}
}
/**
* @psalm-pure
*
* @param iterable<string|null> $value
* @param int|float $min
* @param int|float $max
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allNullOrLengthBetween($value, $min, $max, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
null === $entry || static::lengthBetween($entry, $min, $max, $message);
}
}
/**
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function nullOrFileExists($value, $message = '')
{
null === $value || static::fileExists($value, $message);
}
/**
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allFileExists($value, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
static::fileExists($entry, $message);
}
}
/**
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allNullOrFileExists($value, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
null === $entry || static::fileExists($entry, $message);
}
}
/**
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function nullOrFile($value, $message = '')
{
null === $value || static::file($value, $message);
}
/**
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allFile($value, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
static::file($entry, $message);
}
}
/**
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allNullOrFile($value, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
null === $entry || static::file($entry, $message);
}
}
/**
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function nullOrDirectory($value, $message = '')
{
null === $value || static::directory($value, $message);
}
/**
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allDirectory($value, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
static::directory($entry, $message);
}
}
/**
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allNullOrDirectory($value, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
null === $entry || static::directory($entry, $message);
}
}
/**
* @param string|null $value
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function nullOrReadable($value, $message = '')
{
null === $value || static::readable($value, $message);
}
/**
* @param iterable<string> $value
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allReadable($value, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
static::readable($entry, $message);
}
}
/**
* @param iterable<string|null> $value
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allNullOrReadable($value, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
null === $entry || static::readable($entry, $message);
}
}
/**
* @param string|null $value
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function nullOrWritable($value, $message = '')
{
null === $value || static::writable($value, $message);
}
/**
* @param iterable<string> $value
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allWritable($value, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
static::writable($entry, $message);
}
}
/**
* @param iterable<string|null> $value
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allNullOrWritable($value, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
null === $entry || static::writable($entry, $message);
}
}
/**
* @psalm-assert class-string|null $value
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function nullOrClassExists($value, $message = '')
{
null === $value || static::classExists($value, $message);
}
/**
* @psalm-assert iterable<class-string> $value
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allClassExists($value, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
static::classExists($entry, $message);
}
}
/**
* @psalm-assert iterable<class-string|null> $value
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allNullOrClassExists($value, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
null === $entry || static::classExists($entry, $message);
}
}
/**
* @psalm-pure
* @psalm-template ExpectedType of object
* @psalm-param class-string<ExpectedType> $class
* @psalm-assert class-string<ExpectedType>|ExpectedType|null $value
*
* @param mixed $value
* @param string|object $class
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function nullOrSubclassOf($value, $class, $message = '')
{
null === $value || static::subclassOf($value, $class, $message);
}
/**
* @psalm-pure
* @psalm-template ExpectedType of object
* @psalm-param class-string<ExpectedType> $class
* @psalm-assert iterable<class-string<ExpectedType>|ExpectedType> $value
*
* @param mixed $value
* @param string|object $class
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allSubclassOf($value, $class, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
static::subclassOf($entry, $class, $message);
}
}
/**
* @psalm-pure
* @psalm-template ExpectedType of object
* @psalm-param class-string<ExpectedType> $class
* @psalm-assert iterable<class-string<ExpectedType>|ExpectedType|null> $value
*
* @param mixed $value
* @param string|object $class
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allNullOrSubclassOf($value, $class, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
null === $entry || static::subclassOf($entry, $class, $message);
}
}
/**
* @psalm-assert class-string|null $value
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function nullOrInterfaceExists($value, $message = '')
{
null === $value || static::interfaceExists($value, $message);
}
/**
* @psalm-assert iterable<class-string> $value
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allInterfaceExists($value, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
static::interfaceExists($entry, $message);
}
}
/**
* @psalm-assert iterable<class-string|null> $value
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allNullOrInterfaceExists($value, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
null === $entry || static::interfaceExists($entry, $message);
}
}
/**
* @psalm-pure
* @psalm-template ExpectedType of object
* @psalm-param class-string<ExpectedType> $interface
* @psalm-assert class-string<ExpectedType>|null $value
*
* @param mixed $value
* @param mixed $interface
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function nullOrImplementsInterface($value, $interface, $message = '')
{
null === $value || static::implementsInterface($value, $interface, $message);
}
/**
* @psalm-pure
* @psalm-template ExpectedType of object
* @psalm-param class-string<ExpectedType> $interface
* @psalm-assert iterable<class-string<ExpectedType>> $value
*
* @param mixed $value
* @param mixed $interface
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allImplementsInterface($value, $interface, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
static::implementsInterface($entry, $interface, $message);
}
}
/**
* @psalm-pure
* @psalm-template ExpectedType of object
* @psalm-param class-string<ExpectedType> $interface
* @psalm-assert iterable<class-string<ExpectedType>|null> $value
*
* @param mixed $value
* @param mixed $interface
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allNullOrImplementsInterface($value, $interface, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
null === $entry || static::implementsInterface($entry, $interface, $message);
}
}
/**
* @psalm-pure
* @psalm-param class-string|object|null $classOrObject
*
* @param string|object|null $classOrObject
* @param mixed $property
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function nullOrPropertyExists($classOrObject, $property, $message = '')
{
null === $classOrObject || static::propertyExists($classOrObject, $property, $message);
}
/**
* @psalm-pure
* @psalm-param iterable<class-string|object> $classOrObject
*
* @param iterable<string|object> $classOrObject
* @param mixed $property
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allPropertyExists($classOrObject, $property, $message = '')
{
static::isIterable($classOrObject);
foreach ($classOrObject as $entry) {
static::propertyExists($entry, $property, $message);
}
}
/**
* @psalm-pure
* @psalm-param iterable<class-string|object|null> $classOrObject
*
* @param iterable<string|object|null> $classOrObject
* @param mixed $property
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allNullOrPropertyExists($classOrObject, $property, $message = '')
{
static::isIterable($classOrObject);
foreach ($classOrObject as $entry) {
null === $entry || static::propertyExists($entry, $property, $message);
}
}
/**
* @psalm-pure
* @psalm-param class-string|object|null $classOrObject
*
* @param string|object|null $classOrObject
* @param mixed $property
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function nullOrPropertyNotExists($classOrObject, $property, $message = '')
{
null === $classOrObject || static::propertyNotExists($classOrObject, $property, $message);
}
/**
* @psalm-pure
* @psalm-param iterable<class-string|object> $classOrObject
*
* @param iterable<string|object> $classOrObject
* @param mixed $property
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allPropertyNotExists($classOrObject, $property, $message = '')
{
static::isIterable($classOrObject);
foreach ($classOrObject as $entry) {
static::propertyNotExists($entry, $property, $message);
}
}
/**
* @psalm-pure
* @psalm-param iterable<class-string|object|null> $classOrObject
*
* @param iterable<string|object|null> $classOrObject
* @param mixed $property
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allNullOrPropertyNotExists($classOrObject, $property, $message = '')
{
static::isIterable($classOrObject);
foreach ($classOrObject as $entry) {
null === $entry || static::propertyNotExists($entry, $property, $message);
}
}
/**
* @psalm-pure
* @psalm-param class-string|object|null $classOrObject
*
* @param string|object|null $classOrObject
* @param mixed $method
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function nullOrMethodExists($classOrObject, $method, $message = '')
{
null === $classOrObject || static::methodExists($classOrObject, $method, $message);
}
/**
* @psalm-pure
* @psalm-param iterable<class-string|object> $classOrObject
*
* @param iterable<string|object> $classOrObject
* @param mixed $method
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allMethodExists($classOrObject, $method, $message = '')
{
static::isIterable($classOrObject);
foreach ($classOrObject as $entry) {
static::methodExists($entry, $method, $message);
}
}
/**
* @psalm-pure
* @psalm-param iterable<class-string|object|null> $classOrObject
*
* @param iterable<string|object|null> $classOrObject
* @param mixed $method
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allNullOrMethodExists($classOrObject, $method, $message = '')
{
static::isIterable($classOrObject);
foreach ($classOrObject as $entry) {
null === $entry || static::methodExists($entry, $method, $message);
}
}
/**
* @psalm-pure
* @psalm-param class-string|object|null $classOrObject
*
* @param string|object|null $classOrObject
* @param mixed $method
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function nullOrMethodNotExists($classOrObject, $method, $message = '')
{
null === $classOrObject || static::methodNotExists($classOrObject, $method, $message);
}
/**
* @psalm-pure
* @psalm-param iterable<class-string|object> $classOrObject
*
* @param iterable<string|object> $classOrObject
* @param mixed $method
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allMethodNotExists($classOrObject, $method, $message = '')
{
static::isIterable($classOrObject);
foreach ($classOrObject as $entry) {
static::methodNotExists($entry, $method, $message);
}
}
/**
* @psalm-pure
* @psalm-param iterable<class-string|object|null> $classOrObject
*
* @param iterable<string|object|null> $classOrObject
* @param mixed $method
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allNullOrMethodNotExists($classOrObject, $method, $message = '')
{
static::isIterable($classOrObject);
foreach ($classOrObject as $entry) {
null === $entry || static::methodNotExists($entry, $method, $message);
}
}
/**
* @psalm-pure
*
* @param array|null $array
* @param string|int $key
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function nullOrKeyExists($array, $key, $message = '')
{
null === $array || static::keyExists($array, $key, $message);
}
/**
* @psalm-pure
*
* @param iterable<array> $array
* @param string|int $key
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allKeyExists($array, $key, $message = '')
{
static::isIterable($array);
foreach ($array as $entry) {
static::keyExists($entry, $key, $message);
}
}
/**
* @psalm-pure
*
* @param iterable<array|null> $array
* @param string|int $key
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allNullOrKeyExists($array, $key, $message = '')
{
static::isIterable($array);
foreach ($array as $entry) {
null === $entry || static::keyExists($entry, $key, $message);
}
}
/**
* @psalm-pure
*
* @param array|null $array
* @param string|int $key
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function nullOrKeyNotExists($array, $key, $message = '')
{
null === $array || static::keyNotExists($array, $key, $message);
}
/**
* @psalm-pure
*
* @param iterable<array> $array
* @param string|int $key
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allKeyNotExists($array, $key, $message = '')
{
static::isIterable($array);
foreach ($array as $entry) {
static::keyNotExists($entry, $key, $message);
}
}
/**
* @psalm-pure
*
* @param iterable<array|null> $array
* @param string|int $key
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allNullOrKeyNotExists($array, $key, $message = '')
{
static::isIterable($array);
foreach ($array as $entry) {
null === $entry || static::keyNotExists($entry, $key, $message);
}
}
/**
* @psalm-pure
* @psalm-assert array-key|null $value
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function nullOrValidArrayKey($value, $message = '')
{
null === $value || static::validArrayKey($value, $message);
}
/**
* @psalm-pure
* @psalm-assert iterable<array-key> $value
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allValidArrayKey($value, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
static::validArrayKey($entry, $message);
}
}
/**
* @psalm-pure
* @psalm-assert iterable<array-key|null> $value
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allNullOrValidArrayKey($value, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
null === $entry || static::validArrayKey($entry, $message);
}
}
/**
* @param Countable|array|null $array
* @param int $number
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function nullOrCount($array, $number, $message = '')
{
null === $array || static::count($array, $number, $message);
}
/**
* @param iterable<Countable|array> $array
* @param int $number
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allCount($array, $number, $message = '')
{
static::isIterable($array);
foreach ($array as $entry) {
static::count($entry, $number, $message);
}
}
/**
* @param iterable<Countable|array|null> $array
* @param int $number
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allNullOrCount($array, $number, $message = '')
{
static::isIterable($array);
foreach ($array as $entry) {
null === $entry || static::count($entry, $number, $message);
}
}
/**
* @param Countable|array|null $array
* @param int|float $min
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function nullOrMinCount($array, $min, $message = '')
{
null === $array || static::minCount($array, $min, $message);
}
/**
* @param iterable<Countable|array> $array
* @param int|float $min
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allMinCount($array, $min, $message = '')
{
static::isIterable($array);
foreach ($array as $entry) {
static::minCount($entry, $min, $message);
}
}
/**
* @param iterable<Countable|array|null> $array
* @param int|float $min
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allNullOrMinCount($array, $min, $message = '')
{
static::isIterable($array);
foreach ($array as $entry) {
null === $entry || static::minCount($entry, $min, $message);
}
}
/**
* @param Countable|array|null $array
* @param int|float $max
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function nullOrMaxCount($array, $max, $message = '')
{
null === $array || static::maxCount($array, $max, $message);
}
/**
* @param iterable<Countable|array> $array
* @param int|float $max
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allMaxCount($array, $max, $message = '')
{
static::isIterable($array);
foreach ($array as $entry) {
static::maxCount($entry, $max, $message);
}
}
/**
* @param iterable<Countable|array|null> $array
* @param int|float $max
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allNullOrMaxCount($array, $max, $message = '')
{
static::isIterable($array);
foreach ($array as $entry) {
null === $entry || static::maxCount($entry, $max, $message);
}
}
/**
* @param Countable|array|null $array
* @param int|float $min
* @param int|float $max
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function nullOrCountBetween($array, $min, $max, $message = '')
{
null === $array || static::countBetween($array, $min, $max, $message);
}
/**
* @param iterable<Countable|array> $array
* @param int|float $min
* @param int|float $max
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allCountBetween($array, $min, $max, $message = '')
{
static::isIterable($array);
foreach ($array as $entry) {
static::countBetween($entry, $min, $max, $message);
}
}
/**
* @param iterable<Countable|array|null> $array
* @param int|float $min
* @param int|float $max
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allNullOrCountBetween($array, $min, $max, $message = '')
{
static::isIterable($array);
foreach ($array as $entry) {
null === $entry || static::countBetween($entry, $min, $max, $message);
}
}
/**
* @psalm-pure
* @psalm-assert list|null $array
*
* @param mixed $array
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function nullOrIsList($array, $message = '')
{
null === $array || static::isList($array, $message);
}
/**
* @psalm-pure
* @psalm-assert iterable<list> $array
*
* @param mixed $array
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allIsList($array, $message = '')
{
static::isIterable($array);
foreach ($array as $entry) {
static::isList($entry, $message);
}
}
/**
* @psalm-pure
* @psalm-assert iterable<list|null> $array
*
* @param mixed $array
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allNullOrIsList($array, $message = '')
{
static::isIterable($array);
foreach ($array as $entry) {
null === $entry || static::isList($entry, $message);
}
}
/**
* @psalm-pure
* @psalm-assert non-empty-list|null $array
*
* @param mixed $array
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function nullOrIsNonEmptyList($array, $message = '')
{
null === $array || static::isNonEmptyList($array, $message);
}
/**
* @psalm-pure
* @psalm-assert iterable<non-empty-list> $array
*
* @param mixed $array
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allIsNonEmptyList($array, $message = '')
{
static::isIterable($array);
foreach ($array as $entry) {
static::isNonEmptyList($entry, $message);
}
}
/**
* @psalm-pure
* @psalm-assert iterable<non-empty-list|null> $array
*
* @param mixed $array
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allNullOrIsNonEmptyList($array, $message = '')
{
static::isIterable($array);
foreach ($array as $entry) {
null === $entry || static::isNonEmptyList($entry, $message);
}
}
/**
* @psalm-pure
* @psalm-template T
* @psalm-param mixed|array<T>|null $array
* @psalm-assert array<string, T>|null $array
*
* @param mixed $array
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function nullOrIsMap($array, $message = '')
{
null === $array || static::isMap($array, $message);
}
/**
* @psalm-pure
* @psalm-template T
* @psalm-param iterable<mixed|array<T>> $array
* @psalm-assert iterable<array<string, T>> $array
*
* @param mixed $array
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allIsMap($array, $message = '')
{
static::isIterable($array);
foreach ($array as $entry) {
static::isMap($entry, $message);
}
}
/**
* @psalm-pure
* @psalm-template T
* @psalm-param iterable<mixed|array<T>|null> $array
* @psalm-assert iterable<array<string, T>|null> $array
*
* @param mixed $array
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allNullOrIsMap($array, $message = '')
{
static::isIterable($array);
foreach ($array as $entry) {
null === $entry || static::isMap($entry, $message);
}
}
/**
* @psalm-pure
* @psalm-template T
* @psalm-param mixed|array<T>|null $array
*
* @param mixed $array
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function nullOrIsNonEmptyMap($array, $message = '')
{
null === $array || static::isNonEmptyMap($array, $message);
}
/**
* @psalm-pure
* @psalm-template T
* @psalm-param iterable<mixed|array<T>> $array
*
* @param mixed $array
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allIsNonEmptyMap($array, $message = '')
{
static::isIterable($array);
foreach ($array as $entry) {
static::isNonEmptyMap($entry, $message);
}
}
/**
* @psalm-pure
* @psalm-template T
* @psalm-param iterable<mixed|array<T>|null> $array
* @psalm-assert iterable<array<string, T>|null> $array
* @psalm-assert iterable<!empty|null> $array
*
* @param mixed $array
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allNullOrIsNonEmptyMap($array, $message = '')
{
static::isIterable($array);
foreach ($array as $entry) {
null === $entry || static::isNonEmptyMap($entry, $message);
}
}
/**
* @psalm-pure
*
* @param string|null $value
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function nullOrUuid($value, $message = '')
{
null === $value || static::uuid($value, $message);
}
/**
* @psalm-pure
*
* @param iterable<string> $value
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allUuid($value, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
static::uuid($entry, $message);
}
}
/**
* @psalm-pure
*
* @param iterable<string|null> $value
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allNullOrUuid($value, $message = '')
{
static::isIterable($value);
foreach ($value as $entry) {
null === $entry || static::uuid($entry, $message);
}
}
/**
* @psalm-param class-string<Throwable> $class
*
* @param Closure|null $expression
* @param string $class
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function nullOrThrows($expression, $class = 'Exception', $message = '')
{
null === $expression || static::throws($expression, $class, $message);
}
/**
* @psalm-param class-string<Throwable> $class
*
* @param iterable<Closure> $expression
* @param string $class
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allThrows($expression, $class = 'Exception', $message = '')
{
static::isIterable($expression);
foreach ($expression as $entry) {
static::throws($entry, $class, $message);
}
}
/**
* @psalm-param class-string<Throwable> $class
*
* @param iterable<Closure|null> $expression
* @param string $class
* @param string $message
*
* @throws InvalidArgumentException
*
* @return void
*/
public static function allNullOrThrows($expression, $class = 'Exception', $message = '')
{
static::isIterable($expression);
foreach ($expression as $entry) {
null === $entry || static::throws($entry, $class, $message);
}
}
}
assert/README.md 0000644 00000037316 14736103027 0007341 0 ustar 00 Webmozart Assert
================
[](https://packagist.org/packages/webmozart/assert)
[](https://packagist.org/packages/webmozart/assert)
This library contains efficient assertions to test the input and output of
your methods. With these assertions, you can greatly reduce the amount of coding
needed to write a safe implementation.
All assertions in the [`Assert`] class throw an `Webmozart\Assert\InvalidArgumentException` if
they fail.
FAQ
---
**What's the difference to [beberlei/assert]?**
This library is heavily inspired by Benjamin Eberlei's wonderful [assert package],
but fixes a usability issue with error messages that can't be fixed there without
breaking backwards compatibility.
This package features usable error messages by default. However, you can also
easily write custom error messages:
```
Assert::string($path, 'The path is expected to be a string. Got: %s');
```
In [beberlei/assert], the ordering of the `%s` placeholders is different for
every assertion. This package, on the contrary, provides consistent placeholder
ordering for all assertions:
* `%s`: The tested value as string, e.g. `"/foo/bar"`.
* `%2$s`, `%3$s`, ...: Additional assertion-specific values, e.g. the
minimum/maximum length, allowed values, etc.
Check the source code of the assertions to find out details about the additional
available placeholders.
Installation
------------
Use [Composer] to install the package:
```bash
composer require webmozart/assert
```
Example
-------
```php
use Webmozart\Assert\Assert;
class Employee
{
public function __construct($id)
{
Assert::integer($id, 'The employee ID must be an integer. Got: %s');
Assert::greaterThan($id, 0, 'The employee ID must be a positive integer. Got: %s');
}
}
```
If you create an employee with an invalid ID, an exception is thrown:
```php
new Employee('foobar');
// => Webmozart\Assert\InvalidArgumentException:
// The employee ID must be an integer. Got: string
new Employee(-10);
// => Webmozart\Assert\InvalidArgumentException:
// The employee ID must be a positive integer. Got: -10
```
Assertions
----------
The [`Assert`] class provides the following assertions:
### Type Assertions
Method | Description
-------------------------------------------------------- | --------------------------------------------------
`string($value, $message = '')` | Check that a value is a string
`stringNotEmpty($value, $message = '')` | Check that a value is a non-empty string
`integer($value, $message = '')` | Check that a value is an integer
`integerish($value, $message = '')` | Check that a value casts to an integer
`positiveInteger($value, $message = '')` | Check that a value is a positive (non-zero) integer
`float($value, $message = '')` | Check that a value is a float
`numeric($value, $message = '')` | Check that a value is numeric
`natural($value, $message= ''')` | Check that a value is a non-negative integer
`boolean($value, $message = '')` | Check that a value is a boolean
`scalar($value, $message = '')` | Check that a value is a scalar
`object($value, $message = '')` | Check that a value is an object
`resource($value, $type = null, $message = '')` | Check that a value is a resource
`isCallable($value, $message = '')` | Check that a value is a callable
`isArray($value, $message = '')` | Check that a value is an array
`isTraversable($value, $message = '')` (deprecated) | Check that a value is an array or a `\Traversable`
`isIterable($value, $message = '')` | Check that a value is an array or a `\Traversable`
`isCountable($value, $message = '')` | Check that a value is an array or a `\Countable`
`isInstanceOf($value, $class, $message = '')` | Check that a value is an `instanceof` a class
`isInstanceOfAny($value, array $classes, $message = '')` | Check that a value is an `instanceof` at least one class on the array of classes
`notInstanceOf($value, $class, $message = '')` | Check that a value is not an `instanceof` a class
`isAOf($value, $class, $message = '')` | Check that a value is of the class or has one of its parents
`isAnyOf($value, array $classes, $message = '')` | Check that a value is of at least one of the classes or has one of its parents
`isNotA($value, $class, $message = '')` | Check that a value is not of the class or has not one of its parents
`isArrayAccessible($value, $message = '')` | Check that a value can be accessed as an array
`uniqueValues($values, $message = '')` | Check that the given array contains unique values
### Comparison Assertions
Method | Description
----------------------------------------------- | ------------------------------------------------------------------
`true($value, $message = '')` | Check that a value is `true`
`false($value, $message = '')` | Check that a value is `false`
`notFalse($value, $message = '')` | Check that a value is not `false`
`null($value, $message = '')` | Check that a value is `null`
`notNull($value, $message = '')` | Check that a value is not `null`
`isEmpty($value, $message = '')` | Check that a value is `empty()`
`notEmpty($value, $message = '')` | Check that a value is not `empty()`
`eq($value, $value2, $message = '')` | Check that a value equals another (`==`)
`notEq($value, $value2, $message = '')` | Check that a value does not equal another (`!=`)
`same($value, $value2, $message = '')` | Check that a value is identical to another (`===`)
`notSame($value, $value2, $message = '')` | Check that a value is not identical to another (`!==`)
`greaterThan($value, $value2, $message = '')` | Check that a value is greater than another
`greaterThanEq($value, $value2, $message = '')` | Check that a value is greater than or equal to another
`lessThan($value, $value2, $message = '')` | Check that a value is less than another
`lessThanEq($value, $value2, $message = '')` | Check that a value is less than or equal to another
`range($value, $min, $max, $message = '')` | Check that a value is within a range
`inArray($value, array $values, $message = '')` | Check that a value is one of a list of values
`oneOf($value, array $values, $message = '')` | Check that a value is one of a list of values (alias of `inArray`)
### String Assertions
You should check that a value is a string with `Assert::string()` before making
any of the following assertions.
Method | Description
--------------------------------------------------- | -----------------------------------------------------------------
`contains($value, $subString, $message = '')` | Check that a string contains a substring
`notContains($value, $subString, $message = '')` | Check that a string does not contain a substring
`startsWith($value, $prefix, $message = '')` | Check that a string has a prefix
`notStartsWith($value, $prefix, $message = '')` | Check that a string does not have a prefix
`startsWithLetter($value, $message = '')` | Check that a string starts with a letter
`endsWith($value, $suffix, $message = '')` | Check that a string has a suffix
`notEndsWith($value, $suffix, $message = '')` | Check that a string does not have a suffix
`regex($value, $pattern, $message = '')` | Check that a string matches a regular expression
`notRegex($value, $pattern, $message = '')` | Check that a string does not match a regular expression
`unicodeLetters($value, $message = '')` | Check that a string contains Unicode letters only
`alpha($value, $message = '')` | Check that a string contains letters only
`digits($value, $message = '')` | Check that a string contains digits only
`alnum($value, $message = '')` | Check that a string contains letters and digits only
`lower($value, $message = '')` | Check that a string contains lowercase characters only
`upper($value, $message = '')` | Check that a string contains uppercase characters only
`length($value, $length, $message = '')` | Check that a string has a certain number of characters
`minLength($value, $min, $message = '')` | Check that a string has at least a certain number of characters
`maxLength($value, $max, $message = '')` | Check that a string has at most a certain number of characters
`lengthBetween($value, $min, $max, $message = '')` | Check that a string has a length in the given range
`uuid($value, $message = '')` | Check that a string is a valid UUID
`ip($value, $message = '')` | Check that a string is a valid IP (either IPv4 or IPv6)
`ipv4($value, $message = '')` | Check that a string is a valid IPv4
`ipv6($value, $message = '')` | Check that a string is a valid IPv6
`email($value, $message = '')` | Check that a string is a valid e-mail address
`notWhitespaceOnly($value, $message = '')` | Check that a string contains at least one non-whitespace character
### File Assertions
Method | Description
----------------------------------- | --------------------------------------------------
`fileExists($value, $message = '')` | Check that a value is an existing path
`file($value, $message = '')` | Check that a value is an existing file
`directory($value, $message = '')` | Check that a value is an existing directory
`readable($value, $message = '')` | Check that a value is a readable path
`writable($value, $message = '')` | Check that a value is a writable path
### Object Assertions
Method | Description
----------------------------------------------------- | --------------------------------------------------
`classExists($value, $message = '')` | Check that a value is an existing class name
`subclassOf($value, $class, $message = '')` | Check that a class is a subclass of another
`interfaceExists($value, $message = '')` | Check that a value is an existing interface name
`implementsInterface($value, $class, $message = '')` | Check that a class implements an interface
`propertyExists($value, $property, $message = '')` | Check that a property exists in a class/object
`propertyNotExists($value, $property, $message = '')` | Check that a property does not exist in a class/object
`methodExists($value, $method, $message = '')` | Check that a method exists in a class/object
`methodNotExists($value, $method, $message = '')` | Check that a method does not exist in a class/object
### Array Assertions
Method | Description
-------------------------------------------------- | ------------------------------------------------------------------
`keyExists($array, $key, $message = '')` | Check that a key exists in an array
`keyNotExists($array, $key, $message = '')` | Check that a key does not exist in an array
`validArrayKey($key, $message = '')` | Check that a value is a valid array key (int or string)
`count($array, $number, $message = '')` | Check that an array contains a specific number of elements
`minCount($array, $min, $message = '')` | Check that an array contains at least a certain number of elements
`maxCount($array, $max, $message = '')` | Check that an array contains at most a certain number of elements
`countBetween($array, $min, $max, $message = '')` | Check that an array has a count in the given range
`isList($array, $message = '')` | Check that an array is a non-associative list
`isNonEmptyList($array, $message = '')` | Check that an array is a non-associative list, and not empty
`isMap($array, $message = '')` | Check that an array is associative and has strings as keys
`isNonEmptyMap($array, $message = '')` | Check that an array is associative and has strings as keys, and is not empty
### Function Assertions
Method | Description
------------------------------------------- | -----------------------------------------------------------------------------------------------------
`throws($closure, $class, $message = '')` | Check that a function throws a certain exception. Subclasses of the exception class will be accepted.
### Collection Assertions
All of the above assertions can be prefixed with `all*()` to test the contents
of an array or a `\Traversable`:
```php
Assert::allIsInstanceOf($employees, 'Acme\Employee');
```
### Nullable Assertions
All of the above assertions can be prefixed with `nullOr*()` to run the
assertion only if it the value is not `null`:
```php
Assert::nullOrString($middleName, 'The middle name must be a string or null. Got: %s');
```
### Extending Assert
The `Assert` class comes with a few methods, which can be overridden to change the class behaviour. You can also extend it to
add your own assertions.
#### Overriding methods
Overriding the following methods in your assertion class allows you to change the behaviour of the assertions:
* `public static function __callStatic($name, $arguments)`
* This method is used to 'create' the `nullOr` and `all` versions of the assertions.
* `protected static function valueToString($value)`
* This method is used for error messages, to convert the value to a string value for displaying. You could use this for representing a value object with a `__toString` method for example.
* `protected static function typeToString($value)`
* This method is used for error messages, to convert the a value to a string representing its type.
* `protected static function strlen($value)`
* This method is used to calculate string length for relevant methods, using the `mb_strlen` if available and useful.
* `protected static function reportInvalidArgument($message)`
* This method is called when an assertion fails, with the specified error message. Here you can throw your own exception, or log something.
## Static analysis support
Where applicable, assertion functions are annotated to support Psalm's
[Assertion syntax](https://psalm.dev/docs/annotating_code/assertion_syntax/).
A dedicated [PHPStan Plugin](https://github.com/phpstan/phpstan-webmozart-assert) is
required for proper type support.
Authors
-------
* [Bernhard Schussek] a.k.a. [@webmozart]
* [The Community Contributors]
Contribute
----------
Contributions to the package are always welcome!
* Report any bugs or issues you find on the [issue tracker].
* You can grab the source code at the package's [Git repository].
License
-------
All contents of this package are licensed under the [MIT license].
[beberlei/assert]: https://github.com/beberlei/assert
[assert package]: https://github.com/beberlei/assert
[Composer]: https://getcomposer.org
[Bernhard Schussek]: https://webmozarts.com
[The Community Contributors]: https://github.com/webmozart/assert/graphs/contributors
[issue tracker]: https://github.com/webmozart/assert/issues
[Git repository]: https://github.com/webmozart/assert
[@webmozart]: https://twitter.com/webmozart
[MIT license]: LICENSE
[`Assert`]: src/Assert.php
assert/CHANGELOG.md 0000644 00000013623 14736103027 0007666 0 ustar 00 Changelog
=========
## UNRELEASED
## 1.11.0
### Added
* Added explicit (non magic) `allNullOr*` methods, with `@psalm-assert` annotations, for better Psalm support.
### Changed
* Trait methods will now check the assertion themselves, instead of using `__callStatic`
* `isList` will now deal correctly with (modified) lists that contain `NaN`
* `reportInvalidArgument` now has a return type of `never`.
### Removed
* Removed `symfony/polyfill-ctype` as a dependency, and require `ext-cytpe` instead.
* You can still require the `symfony/polyfill-ctype` in your project if you need it, as it provides `ext-ctype`
## 1.10.0
### Added
* On invalid assertion, we throw a `Webmozart\Assert\InvalidArgumentException`
* Added `Assert::positiveInteger()`
### Changed
* Using a trait with real implementations of `all*()` and `nullOr*()` methods to improve psalm compatibility.
### Removed
* Support for PHP <7.2
## 1.9.1
## Fixed
* provisional support for PHP 8.0
## 1.9.0
* added better Psalm support for `all*` & `nullOr*` methods
* These methods are now understood by Psalm through a mixin. You may need a newer version of Psalm in order to use this
* added `@psalm-pure` annotation to `Assert::notFalse()`
* added more `@psalm-assert` annotations where appropriate
## Changed
* the `all*` & `nullOr*` methods are now declared on an interface, instead of `@method` annotations.
This interface is linked to the `Assert` class with a `@mixin` annotation. Most IDE's have supported this
for a long time, and you should not lose any autocompletion capabilities. PHPStan has supported this since
version `0.12.20`. This package is marked incompatible (with a composer conflict) with phpstan version prior to that.
If you do not use PHPStan than this does not matter.
## 1.8.0
### Added
* added `Assert::notStartsWith()`
* added `Assert::notEndsWith()`
* added `Assert::inArray()`
* added `@psalm-pure` annotations to pure assertions
### Fixed
* Exception messages of comparisons between `DateTime(Immutable)` objects now display their date & time.
* Custom Exception messages for `Assert::count()` now use the values to render the exception message.
## 1.7.0 (2020-02-14)
### Added
* added `Assert::notFalse()`
* added `Assert::isAOf()`
* added `Assert::isAnyOf()`
* added `Assert::isNotA()`
## 1.6.0 (2019-11-24)
### Added
* added `Assert::validArrayKey()`
* added `Assert::isNonEmptyList()`
* added `Assert::isNonEmptyMap()`
* added `@throws InvalidArgumentException` annotations to all methods that throw.
* added `@psalm-assert` for the list type to the `isList` assertion.
### Fixed
* `ResourceBundle` & `SimpleXMLElement` now pass the `isCountable` assertions.
They are countable, without implementing the `Countable` interface.
* The doc block of `range` now has the proper variables.
* An empty array will now pass `isList` and `isMap`. As it is a valid form of both.
If a non-empty variant is needed, use `isNonEmptyList` or `isNonEmptyMap`.
### Changed
* Removed some `@psalm-assert` annotations, that were 'side effect' assertions See:
* [#144](https://github.com/webmozart/assert/pull/144)
* [#145](https://github.com/webmozart/assert/issues/145)
* [#146](https://github.com/webmozart/assert/pull/146)
* [#150](https://github.com/webmozart/assert/pull/150)
* If you use Psalm, the minimum version needed is `3.6.0`. Which is enforced through a composer conflict.
If you don't use Psalm, then this has no impact.
## 1.5.0 (2019-08-24)
### Added
* added `Assert::uniqueValues()`
* added `Assert::unicodeLetters()`
* added: `Assert::email()`
* added support for [Psalm](https://github.com/vimeo/psalm), by adding `@psalm-assert` annotations where appropriate.
### Fixed
* `Assert::endsWith()` would not give the correct result when dealing with a multibyte suffix.
* `Assert::length(), minLength, maxLength, lengthBetween` would not give the correct result when dealing with multibyte characters.
**NOTE**: These 2 changes may break your assertions if you relied on the fact that multibyte characters didn't behave correctly.
### Changed
* The names of some variables have been updated to better reflect what they are.
* All function calls are now in their FQN form, slightly increasing performance.
* Tests are now properly ran against HHVM-3.30 and PHP nightly.
### Deprecation
* deprecated `Assert::isTraversable()` in favor of `Assert::isIterable()`
* This was already done in 1.3.0, but it was only done through a silenced `trigger_error`. It is now annotated as well.
## 1.4.0 (2018-12-25)
### Added
* added `Assert::ip()`
* added `Assert::ipv4()`
* added `Assert::ipv6()`
* added `Assert::notRegex()`
* added `Assert::interfaceExists()`
* added `Assert::isList()`
* added `Assert::isMap()`
* added polyfill for ctype
### Fixed
* Special case when comparing objects implementing `__toString()`
## 1.3.0 (2018-01-29)
### Added
* added `Assert::minCount()`
* added `Assert::maxCount()`
* added `Assert::countBetween()`
* added `Assert::isCountable()`
* added `Assert::notWhitespaceOnly()`
* added `Assert::natural()`
* added `Assert::notContains()`
* added `Assert::isArrayAccessible()`
* added `Assert::isInstanceOfAny()`
* added `Assert::isIterable()`
### Fixed
* `stringNotEmpty` will no longer report "0" is an empty string
### Deprecation
* deprecated `Assert::isTraversable()` in favor of `Assert::isIterable()`
## 1.2.0 (2016-11-23)
* added `Assert::throws()`
* added `Assert::count()`
* added extension point `Assert::reportInvalidArgument()` for custom subclasses
## 1.1.0 (2016-08-09)
* added `Assert::object()`
* added `Assert::propertyExists()`
* added `Assert::propertyNotExists()`
* added `Assert::methodExists()`
* added `Assert::methodNotExists()`
* added `Assert::uuid()`
## 1.0.2 (2015-08-24)
* integrated Style CI
* add tests for minimum package dependencies on Travis CI
## 1.0.1 (2015-05-12)
* added support for PHP 5.3.3
## 1.0.0 (2015-05-12)
* first stable release
## 1.0.0-beta (2015-03-19)
* first beta release
assert/LICENSE 0000644 00000002074 14736103027 0007060 0 ustar 00 The MIT License (MIT)
Copyright (c) 2014 Bernhard Schussek
Permission is hereby granted, free of charge, to any person obtaining a copy of
this software and associated documentation files (the "Software"), to deal in
the Software without restriction, including without limitation the rights to
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
the Software, and to permit persons to whom the Software is furnished to do so,
subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.