phan 설치
This commit is contained in:
+12
@@ -0,0 +1,12 @@
|
||||
root = true
|
||||
|
||||
[*]
|
||||
charset=utf-8
|
||||
end_of_line=lf
|
||||
trim_trailing_whitespace=true
|
||||
insert_final_newline=true
|
||||
indent_style=space
|
||||
indent_size=4
|
||||
|
||||
[*.yml]
|
||||
indent_size=2
|
||||
Vendored
+155
@@ -0,0 +1,155 @@
|
||||
Changelog
|
||||
=========
|
||||
|
||||
## UNRELEASED
|
||||
|
||||
|
||||
## 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(Immutalbe)` 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 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
|
||||
Vendored
+20
@@ -0,0 +1,20 @@
|
||||
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.
|
||||
Vendored
+283
@@ -0,0 +1,283 @@
|
||||
Webmozart Assert
|
||||
================
|
||||
|
||||
[](https://travis-ci.org/webmozart/assert)
|
||||
[](https://ci.appveyor.com/project/webmozart/assert/branch/master)
|
||||
[](https://scrutinizer-ci.com/g/webmozart/assert/?branch=master)
|
||||
[](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 `\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:
|
||||
|
||||
```
|
||||
$ 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');
|
||||
// => InvalidArgumentException:
|
||||
// The employee ID must be an integer. Got: string
|
||||
|
||||
new Employee(-10);
|
||||
// => 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
|
||||
`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` a 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 a at least one of the class 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 contains 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.
|
||||
|
||||
|
||||
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
|
||||
+36
@@ -0,0 +1,36 @@
|
||||
{
|
||||
"name": "webmozart/assert",
|
||||
"description": "Assertions to validate method input/output with nice error messages.",
|
||||
"keywords": [
|
||||
"assert",
|
||||
"check",
|
||||
"validate"
|
||||
],
|
||||
"license": "MIT",
|
||||
"authors": [
|
||||
{
|
||||
"name": "Bernhard Schussek",
|
||||
"email": "bschussek@gmail.com"
|
||||
}
|
||||
],
|
||||
"require": {
|
||||
"php": "^5.3.3 || ^7.0",
|
||||
"symfony/polyfill-ctype": "^1.8"
|
||||
},
|
||||
"require-dev": {
|
||||
"phpunit/phpunit": "^4.8.36 || ^7.5.13"
|
||||
},
|
||||
"conflict": {
|
||||
"vimeo/psalm": "<3.9.1"
|
||||
},
|
||||
"autoload": {
|
||||
"psr-4": {
|
||||
"Webmozart\\Assert\\": "src/"
|
||||
}
|
||||
},
|
||||
"autoload-dev": {
|
||||
"psr-4": {
|
||||
"Webmozart\\Assert\\Tests\\": "tests/"
|
||||
}
|
||||
}
|
||||
}
|
||||
Vendored
+16
@@ -0,0 +1,16 @@
|
||||
<?xml version="1.0"?>
|
||||
<psalm
|
||||
totallyTyped="true"
|
||||
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
|
||||
xmlns="https://getpsalm.org/schema/config"
|
||||
xsi:schemaLocation="https://getpsalm.org/schema/config ci/vendor/vimeo/psalm/config.xsd"
|
||||
phpVersion="7.3"
|
||||
>
|
||||
<projectFiles>
|
||||
<directory name="tests/static-analysis" />
|
||||
<ignoreFiles>
|
||||
<directory name="vendor" />
|
||||
</ignoreFiles>
|
||||
</projectFiles>
|
||||
|
||||
</psalm>
|
||||
+2226
@@ -0,0 +1,2226 @@
|
||||
<?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 InvalidArgumentException;
|
||||
use ResourceBundle;
|
||||
use SimpleXMLElement;
|
||||
use Throwable;
|
||||
use Traversable;
|
||||
|
||||
/**
|
||||
* Efficient assertions to validate the input/output of your methods.
|
||||
*
|
||||
* @method static void nullOrString($value, $message = '')
|
||||
* @method static void nullOrStringNotEmpty($value, $message = '')
|
||||
* @method static void nullOrInteger($value, $message = '')
|
||||
* @method static void nullOrIntegerish($value, $message = '')
|
||||
* @method static void nullOrFloat($value, $message = '')
|
||||
* @method static void nullOrNumeric($value, $message = '')
|
||||
* @method static void nullOrNatural($value, $message = '')
|
||||
* @method static void nullOrBoolean($value, $message = '')
|
||||
* @method static void nullOrScalar($value, $message = '')
|
||||
* @method static void nullOrObject($value, $message = '')
|
||||
* @method static void nullOrResource($value, $type = null, $message = '')
|
||||
* @method static void nullOrIsCallable($value, $message = '')
|
||||
* @method static void nullOrIsArray($value, $message = '')
|
||||
* @method static void nullOrIsTraversable($value, $message = '')
|
||||
* @method static void nullOrIsArrayAccessible($value, $message = '')
|
||||
* @method static void nullOrIsCountable($value, $message = '')
|
||||
* @method static void nullOrIsIterable($value, $message = '')
|
||||
* @method static void nullOrIsInstanceOf($value, $class, $message = '')
|
||||
* @method static void nullOrNotInstanceOf($value, $class, $message = '')
|
||||
* @method static void nullOrIsInstanceOfAny($value, $classes, $message = '')
|
||||
* @method static void nullOrIsAOf($value, $classes, $message = '')
|
||||
* @method static void nullOrIsAnyOf($value, $classes, $message = '')
|
||||
* @method static void nullOrIsNotA($value, $classes, $message = '')
|
||||
* @method static void nullOrIsEmpty($value, $message = '')
|
||||
* @method static void nullOrNotEmpty($value, $message = '')
|
||||
* @method static void nullOrTrue($value, $message = '')
|
||||
* @method static void nullOrFalse($value, $message = '')
|
||||
* @method static void nullOrNotFalse($value, $message = '')
|
||||
* @method static void nullOrIp($value, $message = '')
|
||||
* @method static void nullOrIpv4($value, $message = '')
|
||||
* @method static void nullOrIpv6($value, $message = '')
|
||||
* @method static void nullOrEmail($value, $message = '')
|
||||
* @method static void nullOrUniqueValues($values, $message = '')
|
||||
* @method static void nullOrEq($value, $expect, $message = '')
|
||||
* @method static void nullOrNotEq($value, $expect, $message = '')
|
||||
* @method static void nullOrSame($value, $expect, $message = '')
|
||||
* @method static void nullOrNotSame($value, $expect, $message = '')
|
||||
* @method static void nullOrGreaterThan($value, $limit, $message = '')
|
||||
* @method static void nullOrGreaterThanEq($value, $limit, $message = '')
|
||||
* @method static void nullOrLessThan($value, $limit, $message = '')
|
||||
* @method static void nullOrLessThanEq($value, $limit, $message = '')
|
||||
* @method static void nullOrRange($value, $min, $max, $message = '')
|
||||
* @method static void nullOrOneOf($value, $values, $message = '')
|
||||
* @method static void nullOrInArray($value, $values, $message = '')
|
||||
* @method static void nullOrContains($value, $subString, $message = '')
|
||||
* @method static void nullOrNotContains($value, $subString, $message = '')
|
||||
* @method static void nullOrNotWhitespaceOnly($value, $message = '')
|
||||
* @method static void nullOrStartsWith($value, $prefix, $message = '')
|
||||
* @method static void nullOrNotStartsWith($value, $prefix, $message = '')
|
||||
* @method static void nullOrStartsWithLetter($value, $message = '')
|
||||
* @method static void nullOrEndsWith($value, $suffix, $message = '')
|
||||
* @method static void nullOrNotEndsWith($value, $suffix, $message = '')
|
||||
* @method static void nullOrRegex($value, $pattern, $message = '')
|
||||
* @method static void nullOrNotRegex($value, $pattern, $message = '')
|
||||
* @method static void nullOrUnicodeLetters($value, $message = '')
|
||||
* @method static void nullOrAlpha($value, $message = '')
|
||||
* @method static void nullOrDigits($value, $message = '')
|
||||
* @method static void nullOrAlnum($value, $message = '')
|
||||
* @method static void nullOrLower($value, $message = '')
|
||||
* @method static void nullOrUpper($value, $message = '')
|
||||
* @method static void nullOrLength($value, $length, $message = '')
|
||||
* @method static void nullOrMinLength($value, $min, $message = '')
|
||||
* @method static void nullOrMaxLength($value, $max, $message = '')
|
||||
* @method static void nullOrLengthBetween($value, $min, $max, $message = '')
|
||||
* @method static void nullOrFileExists($value, $message = '')
|
||||
* @method static void nullOrFile($value, $message = '')
|
||||
* @method static void nullOrDirectory($value, $message = '')
|
||||
* @method static void nullOrReadable($value, $message = '')
|
||||
* @method static void nullOrWritable($value, $message = '')
|
||||
* @method static void nullOrClassExists($value, $message = '')
|
||||
* @method static void nullOrSubclassOf($value, $class, $message = '')
|
||||
* @method static void nullOrInterfaceExists($value, $message = '')
|
||||
* @method static void nullOrImplementsInterface($value, $interface, $message = '')
|
||||
* @method static void nullOrPropertyExists($value, $property, $message = '')
|
||||
* @method static void nullOrPropertyNotExists($value, $property, $message = '')
|
||||
* @method static void nullOrMethodExists($value, $method, $message = '')
|
||||
* @method static void nullOrMethodNotExists($value, $method, $message = '')
|
||||
* @method static void nullOrKeyExists($value, $key, $message = '')
|
||||
* @method static void nullOrKeyNotExists($value, $key, $message = '')
|
||||
* @method static void nullOrValidArrayKey($value, $message = '')
|
||||
* @method static void nullOrCount($value, $key, $message = '')
|
||||
* @method static void nullOrMinCount($value, $min, $message = '')
|
||||
* @method static void nullOrMaxCount($value, $max, $message = '')
|
||||
* @method static void nullOrIsList($value, $message = '')
|
||||
* @method static void nullOrIsNonEmptyList($value, $message = '')
|
||||
* @method static void nullOrIsMap($value, $message = '')
|
||||
* @method static void nullOrIsNonEmptyMap($value, $message = '')
|
||||
* @method static void nullOrCountBetween($value, $min, $max, $message = '')
|
||||
* @method static void nullOrUuid($values, $message = '')
|
||||
* @method static void nullOrThrows($expression, $class = 'Exception', $message = '')
|
||||
* @method static void allString($values, $message = '')
|
||||
* @method static void allStringNotEmpty($values, $message = '')
|
||||
* @method static void allInteger($values, $message = '')
|
||||
* @method static void allIntegerish($values, $message = '')
|
||||
* @method static void allFloat($values, $message = '')
|
||||
* @method static void allNumeric($values, $message = '')
|
||||
* @method static void allNatural($values, $message = '')
|
||||
* @method static void allBoolean($values, $message = '')
|
||||
* @method static void allScalar($values, $message = '')
|
||||
* @method static void allObject($values, $message = '')
|
||||
* @method static void allResource($values, $type = null, $message = '')
|
||||
* @method static void allIsCallable($values, $message = '')
|
||||
* @method static void allIsArray($values, $message = '')
|
||||
* @method static void allIsTraversable($values, $message = '')
|
||||
* @method static void allIsArrayAccessible($values, $message = '')
|
||||
* @method static void allIsCountable($values, $message = '')
|
||||
* @method static void allIsIterable($values, $message = '')
|
||||
* @method static void allIsInstanceOf($values, $class, $message = '')
|
||||
* @method static void allNotInstanceOf($values, $class, $message = '')
|
||||
* @method static void allIsInstanceOfAny($values, $classes, $message = '')
|
||||
* @method static void allIsAOf($values, $class, $message = '')
|
||||
* @method static void allIsAnyOf($values, $class, $message = '')
|
||||
* @method static void allIsNotA($values, $class, $message = '')
|
||||
* @method static void allNull($values, $message = '')
|
||||
* @method static void allNotNull($values, $message = '')
|
||||
* @method static void allIsEmpty($values, $message = '')
|
||||
* @method static void allNotEmpty($values, $message = '')
|
||||
* @method static void allTrue($values, $message = '')
|
||||
* @method static void allFalse($values, $message = '')
|
||||
* @method static void allNotFalse($values, $message = '')
|
||||
* @method static void allIp($values, $message = '')
|
||||
* @method static void allIpv4($values, $message = '')
|
||||
* @method static void allIpv6($values, $message = '')
|
||||
* @method static void allEmail($values, $message = '')
|
||||
* @method static void allUniqueValues($values, $message = '')
|
||||
* @method static void allEq($values, $expect, $message = '')
|
||||
* @method static void allNotEq($values, $expect, $message = '')
|
||||
* @method static void allSame($values, $expect, $message = '')
|
||||
* @method static void allNotSame($values, $expect, $message = '')
|
||||
* @method static void allGreaterThan($values, $limit, $message = '')
|
||||
* @method static void allGreaterThanEq($values, $limit, $message = '')
|
||||
* @method static void allLessThan($values, $limit, $message = '')
|
||||
* @method static void allLessThanEq($values, $limit, $message = '')
|
||||
* @method static void allRange($values, $min, $max, $message = '')
|
||||
* @method static void allOneOf($values, $values, $message = '')
|
||||
* @method static void allInArray($values, $values, $message = '')
|
||||
* @method static void allContains($values, $subString, $message = '')
|
||||
* @method static void allNotContains($values, $subString, $message = '')
|
||||
* @method static void allNotWhitespaceOnly($values, $message = '')
|
||||
* @method static void allStartsWith($values, $prefix, $message = '')
|
||||
* @method static void allNotStartsWith($values, $prefix, $message = '')
|
||||
* @method static void allStartsWithLetter($values, $message = '')
|
||||
* @method static void allEndsWith($values, $suffix, $message = '')
|
||||
* @method static void allNotEndsWith($values, $suffix, $message = '')
|
||||
* @method static void allRegex($values, $pattern, $message = '')
|
||||
* @method static void allNotRegex($values, $pattern, $message = '')
|
||||
* @method static void allUnicodeLetters($values, $message = '')
|
||||
* @method static void allAlpha($values, $message = '')
|
||||
* @method static void allDigits($values, $message = '')
|
||||
* @method static void allAlnum($values, $message = '')
|
||||
* @method static void allLower($values, $message = '')
|
||||
* @method static void allUpper($values, $message = '')
|
||||
* @method static void allLength($values, $length, $message = '')
|
||||
* @method static void allMinLength($values, $min, $message = '')
|
||||
* @method static void allMaxLength($values, $max, $message = '')
|
||||
* @method static void allLengthBetween($values, $min, $max, $message = '')
|
||||
* @method static void allFileExists($values, $message = '')
|
||||
* @method static void allFile($values, $message = '')
|
||||
* @method static void allDirectory($values, $message = '')
|
||||
* @method static void allReadable($values, $message = '')
|
||||
* @method static void allWritable($values, $message = '')
|
||||
* @method static void allClassExists($values, $message = '')
|
||||
* @method static void allSubclassOf($values, $class, $message = '')
|
||||
* @method static void allInterfaceExists($values, $message = '')
|
||||
* @method static void allImplementsInterface($values, $interface, $message = '')
|
||||
* @method static void allPropertyExists($values, $property, $message = '')
|
||||
* @method static void allPropertyNotExists($values, $property, $message = '')
|
||||
* @method static void allMethodExists($values, $method, $message = '')
|
||||
* @method static void allMethodNotExists($values, $method, $message = '')
|
||||
* @method static void allKeyExists($values, $key, $message = '')
|
||||
* @method static void allKeyNotExists($values, $key, $message = '')
|
||||
* @method static void allValidArrayKey($values, $message = '')
|
||||
* @method static void allCount($values, $key, $message = '')
|
||||
* @method static void allMinCount($values, $min, $message = '')
|
||||
* @method static void allMaxCount($values, $max, $message = '')
|
||||
* @method static void allCountBetween($values, $min, $max, $message = '')
|
||||
* @method static void allIsList($values, $message = '')
|
||||
* @method static void allIsNonEmptyList($values, $message = '')
|
||||
* @method static void allIsMap($values, $message = '')
|
||||
* @method static void allIsNonEmptyMap($values, $message = '')
|
||||
* @method static void allUuid($values, $message = '')
|
||||
* @method static void allThrows($expressions, $class = 'Exception', $message = '')
|
||||
*
|
||||
* @since 1.0
|
||||
*
|
||||
* @author Bernhard Schussek <bschussek@gmail.com>
|
||||
*/
|
||||
class Assert
|
||||
{
|
||||
/**
|
||||
* @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 string $value
|
||||
* @psalm-assert !empty $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 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 int $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', '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 his parents %2$s. Got: %s',
|
||||
static::typeToString($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 his parents other than %2$s. Got: %s',
|
||||
static::typeToString($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 any of instance of this class or to this class among his parents other than %2$s. Got: %s',
|
||||
static::typeToString($value),
|
||||
\implode(', ', \array_map(array('static', 'valueToString'), $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-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', '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)
|
||||
));
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @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)
|
||||
));
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @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 (!\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 (\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) || $array !== \array_values($array)) {
|
||||
static::reportInvalidArgument(
|
||||
$message ?: 'Expected list - non-associative array.'
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @psalm-pure
|
||||
* @psalm-assert list $array
|
||||
* @psalm-assert !empty $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>
|
||||
*
|
||||
* @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', $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', $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
|
||||
*/
|
||||
protected static function reportInvalidArgument($message)
|
||||
{
|
||||
throw new InvalidArgumentException($message);
|
||||
}
|
||||
|
||||
private function __construct()
|
||||
{
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user