diff options
Diffstat (limited to 'srcs/phpmyadmin/vendor/dasprid/enum')
21 files changed, 1519 insertions, 0 deletions
diff --git a/srcs/phpmyadmin/vendor/dasprid/enum/.coveralls.yml b/srcs/phpmyadmin/vendor/dasprid/enum/.coveralls.yml new file mode 100644 index 0000000..bc71b62 --- /dev/null +++ b/srcs/phpmyadmin/vendor/dasprid/enum/.coveralls.yml @@ -0,0 +1,2 @@ +coverage_clover: clover.xml +json_path: coveralls-upload.json diff --git a/srcs/phpmyadmin/vendor/dasprid/enum/.travis.yml b/srcs/phpmyadmin/vendor/dasprid/enum/.travis.yml new file mode 100644 index 0000000..e4c6453 --- /dev/null +++ b/srcs/phpmyadmin/vendor/dasprid/enum/.travis.yml @@ -0,0 +1,41 @@ +sudo: false + +language: php + +cache: + directories: + - $HOME/.composer/cache + - $HOME/.local + - vendor + +matrix: + fast_finish: true + include: + - php: 7.1 + env: + - EXECUTE_CS_CHECK=true + - EXECUTE_TEST_COVERALLS=true + - PATH="$HOME/.local/bin:$PATH" + - php: nightly + allow_failures: + - php: nightly + +before_install: + - if [[ $EXECUTE_TEST_COVERALLS != 'true' ]]; then phpenv config-rm xdebug.ini || return 0 ; fi + - composer self-update + - if [[ $EXECUTE_TEST_COVERALLS == 'true' ]]; then composer require --dev --no-update satooshi/php-coveralls:dev-master ; fi + +install: + - travis_retry composer install --no-interaction + - composer info -i + +script: + - if [[ $EXECUTE_TEST_COVERALLS == 'true' ]]; then vendor/bin/phpunit --coverage-clover clover.xml ; fi + - if [[ $EXECUTE_TEST_COVERALLS != 'true' ]]; then vendor/bin/phpunit ; fi + - if [[ $EXECUTE_CS_CHECK == 'true' ]]; then vendor/bin/phpcs ; fi + +after_script: + - if [[ $EXECUTE_TEST_COVERALLS == 'true' ]]; then vendor/bin/coveralls ; fi + +notifications: + email: true diff --git a/srcs/phpmyadmin/vendor/dasprid/enum/README.md b/srcs/phpmyadmin/vendor/dasprid/enum/README.md new file mode 100644 index 0000000..9e9ca12 --- /dev/null +++ b/srcs/phpmyadmin/vendor/dasprid/enum/README.md @@ -0,0 +1,164 @@ +# PHP 7.1 enums + +[](https://travis-ci.org/DASPRiD/Enum) +[](https://coveralls.io/github/DASPRiD/Enum?branch=master) +[](https://packagist.org/packages/dasprid/enum) +[](https://packagist.org/packages/dasprid/enum) +[](https://packagist.org/packages/dasprid/enum) + +It is a well known fact that PHP is missing a basic enum type, ignoring the rather incomplete `SplEnum` implementation +which is only available as a PECL extension. There are also quite a few other userland enum implementations around, +but all of them have one or another compromise. This library tries to close that gap as far as PHP allows it to. + +## Usage + +### Basics + +At its core, there is the `DASPRiD\Enum\AbstractEnum` class, which by default will work with constants like any other +enum implementation you might know. The first clear difference is that you should define all the constants as protected +(so nobody outside your class can read them but the `AbstractEnum` can still do so). The other even mightier difference +is that, for simple enums, the value of the constant doesn't matter at all. Let's have a look at a simple example: + +```php +use DASPRiD\Enum\AbstractEnum; + +/** + * @method static self MONDAY() + * @method static self TUESDAY() + * @method static self WEDNESDAY() + * @method static self THURSDAY() + * @method static self FRIDAY() + * @method static self SATURDAY() + * @method static self SUNDAY() + */ +final class WeekDay extends AbstractEnum +{ + protected const MONDAY = null; + protected const TUESDAY = null; + protected const WEDNESDAY = null; + protected const THURSDAY = null; + protected const FRIDAY = null; + protected const SATURDAY = null; + protected const SUNDAY = null; +} +``` + +If you need to provide constants for either internal use or public use, you can mark them as either private or public, +in which case they will be ignored by the enum, which only considers protected constants as valid values. As you can +see, we specifically defined the generated magic methods in a class level doc block, so anyone using this class will +automatically have proper auto-completion in their IDE. Now since you have defined the enum, you can simply use it like +that: + +```php +function tellItLikeItIs(WeekDay $weekDay) +{ + switch ($weekDay) { + case WeekDay::MONDAY(): + echo 'Mondays are bad.'; + break; + + case WeekDay::FRIDAY(): + echo 'Fridays are better.'; + break; + + case WeekDay::SATURDAY(): + case WeekDay::SUNDAY(): + echo 'Weekends are best.'; + break; + + default: + echo 'Midweek days are so-so.'; + } +} + +tellItLikeItIs(WeekDay::MONDAY()); +tellItLikeItIs(WeekDay::WEDNESDAY()); +tellItLikeItIs(WeekDay::FRIDAY()); +tellItLikeItIs(WeekDay::SATURDAY()); +tellItLikeItIs(WeekDay::SUNDAY()); +``` + +### More complex example + +Of course, all enums are singletons, which are not cloneable or serializable. Thus you can be sure that there is always +just one instance of the same type. Of course, the values of constants are not completely useless, let's have a look at +a more complex example: + +```php +use DASPRiD\Enum\AbstractEnum; + +/** + * @method static self MERCURY() + * @method static self VENUS() + * @method static self EARTH() + * @method static self MARS() + * @method static self JUPITER() + * @method static self SATURN() + * @method static self URANUS() + * @method static self NEPTUNE() + */ +final class Planet extends AbstractEnum +{ + protected const MERCURY = [3.303e+23, 2.4397e6]; + protected const VENUS = [4.869e+24, 6.0518e6]; + protected const EARTH = [5.976e+24, 6.37814e6]; + protected const MARS = [6.421e+23, 3.3972e6]; + protected const JUPITER = [1.9e+27, 7.1492e7]; + protected const SATURN = [5.688e+26, 6.0268e7]; + protected const URANUS = [8.686e+25, 2.5559e7]; + protected const NEPTUNE = [1.024e+26, 2.4746e7]; + + /** + * Universal gravitational constant. + * + * @var float + */ + private const G = 6.67300E-11; + + /** + * Mass in kilograms. + * + * @var float + */ + private $mass; + + /** + * Radius in meters. + * + * @var float + */ + private $radius; + + protected function __construct(float $mass, float $radius) + { + $this->mass = $mass; + $this->radius = $radius; + } + + public function mass() : float + { + return $this->mass; + } + + public function radius() : float + { + return $this->radius; + } + + public function surfaceGravity() : float + { + return self::G * $this->mass / ($this->radius * $this->radius); + } + + public function surfaceWeight(float $otherMass) : float + { + return $otherMass * $this->surfaceGravity(); + } +} + +$myMass = 80; + +foreach (Planet::values() as $planet) { + printf("Your weight on %s is %f\n", $planet, $planet->surfaceWeight($myMass)); +} +``` diff --git a/srcs/phpmyadmin/vendor/dasprid/enum/composer.json b/srcs/phpmyadmin/vendor/dasprid/enum/composer.json new file mode 100644 index 0000000..41184d3 --- /dev/null +++ b/srcs/phpmyadmin/vendor/dasprid/enum/composer.json @@ -0,0 +1,30 @@ +{ + "name": "dasprid/enum", + "description": "PHP 7.1 enum implementation", + "license": "BSD-2-Clause", + "authors": [ + { + "name": "Ben Scholzen 'DASPRiD'", + "homepage": "https://dasprids.de/", + "email": "mail@dasprids.de" + } + ], + "keywords": [ + "enum", + "map" + ], + "require-dev": { + "phpunit/phpunit": "^6.4", + "squizlabs/php_codesniffer": "^3.1" + }, + "autoload": { + "psr-4": { + "DASPRiD\\Enum\\": "src/" + } + }, + "autoload-dev": { + "psr-4": { + "DASPRiD\\EnumTest\\": "test/" + } + } +} diff --git a/srcs/phpmyadmin/vendor/dasprid/enum/phpcs.xml b/srcs/phpmyadmin/vendor/dasprid/enum/phpcs.xml new file mode 100644 index 0000000..a184db8 --- /dev/null +++ b/srcs/phpmyadmin/vendor/dasprid/enum/phpcs.xml @@ -0,0 +1,30 @@ +<?xml version="1.0"?> +<ruleset name="Enum coding standard"> + <description>Enum coding standard</description> + + <!-- display progress --> + <arg value="p"/> + <arg name="colors"/> + <arg name="parallel" value="75"/> + + <!-- inherit rules from: --> + <rule ref="PSR2"/> + <rule ref="Squiz.Strings.DoubleQuoteUsage"/> + <rule ref="Generic.PHP.DisallowShortOpenTag"/> + <rule ref="Generic.Arrays.DisallowLongArraySyntax"/> + <rule ref="Generic.Formatting.SpaceAfterNot"/> + <rule ref="Squiz.WhiteSpace.OperatorSpacing"> + <properties> + <property name="ignoreNewlines" value="true"/> + </properties> + </rule> + <rule ref="Squiz.WhiteSpace.SuperfluousWhitespace"> + <properties> + <property name="ignoreBlankLines" value="false"/> + </properties> + </rule> + + <!-- Paths to check --> + <file>src</file> + <file>test</file> +</ruleset> diff --git a/srcs/phpmyadmin/vendor/dasprid/enum/phpunit.xml.dist b/srcs/phpmyadmin/vendor/dasprid/enum/phpunit.xml.dist new file mode 100644 index 0000000..307a430 --- /dev/null +++ b/srcs/phpmyadmin/vendor/dasprid/enum/phpunit.xml.dist @@ -0,0 +1,17 @@ +<?xml version="1.0" encoding="UTF-8"?> +<phpunit xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" + xsi:noNamespaceSchemaLocation="vendor/phpunit/phpunit/phpunit.xsd" + bootstrap="vendor/autoload.php" + colors="true"> + <testsuites> + <testsuite name="DASPRiD\\Enum Tests"> + <directory>./test</directory> + </testsuite> + </testsuites> + + <filter> + <whitelist processUncoveredFilesFromWhitelist="true"> + <directory suffix=".php">src</directory> + </whitelist> + </filter> +</phpunit> diff --git a/srcs/phpmyadmin/vendor/dasprid/enum/src/AbstractEnum.php b/srcs/phpmyadmin/vendor/dasprid/enum/src/AbstractEnum.php new file mode 100644 index 0000000..bc36119 --- /dev/null +++ b/srcs/phpmyadmin/vendor/dasprid/enum/src/AbstractEnum.php @@ -0,0 +1,241 @@ +<?php +declare(strict_types = 1); + +namespace DASPRiD\Enum; + +use DASPRiD\Enum\Exception\CloneNotSupportedException; +use DASPRiD\Enum\Exception\IllegalArgumentException; +use DASPRiD\Enum\Exception\MismatchException; +use DASPRiD\Enum\Exception\SerializeNotSupportedException; +use DASPRiD\Enum\Exception\UnserializeNotSupportedException; +use ReflectionClass; + +abstract class AbstractEnum +{ + /** + * @var string + */ + private $name; + + /** + * @var int + */ + private $ordinal; + + /** + * @var array<string, array<string, static>> + */ + private static $values = []; + + /** + * @var array<string, bool> + */ + private static $allValuesLoaded = []; + + /** + * @var array<string, array> + */ + private static $constants = []; + + /** + * The constructor is private by default to avoid arbitrary enum creation. + * + * When creating your own constructor for a parameterized enum, make sure to declare it as protected, so that + * the static methods are able to construct it. Avoid making it public, as that would allow creation of + * non-singleton enum instances. + */ + private function __construct() + { + } + + /** + * Magic getter which forwards all calls to {@see self::valueOf()}. + * + * @return static + */ + final public static function __callStatic(string $name, array $arguments) : self + { + return static::valueOf($name); + } + + /** + * Returns an enum with the specified name. + * + * The name must match exactly an identifier used to declare an enum in this type (extraneous whitespace characters + * are not permitted). + * + * @return static + * @throws IllegalArgumentException if the enum has no constant with the specified name + */ + final public static function valueOf(string $name) : self + { + if (isset(self::$values[static::class][$name])) { + return self::$values[static::class][$name]; + } + + $constants = self::constants(); + + if (array_key_exists($name, $constants)) { + return self::createValue($name, $constants[$name][0], $constants[$name][1]); + } + + throw new IllegalArgumentException(sprintf('No enum constant %s::%s', static::class, $name)); + } + + /** + * @return static + */ + final private static function createValue(string $name, int $ordinal, array $arguments) : self + { + $instance = new static(...$arguments); + $instance->name = $name; + $instance->ordinal = $ordinal; + self::$values[static::class][$name] = $instance; + return $instance; + } + + /** + * Obtains all possible types defined by this enum. + * + * @return static[] + */ + final public static function values() : array + { + if (isset(self::$allValuesLoaded[static::class])) { + return self::$values[static::class]; + } + + if (! isset(self::$values[static::class])) { + self::$values[static::class] = []; + } + + foreach (self::constants() as $name => $constant) { + if (array_key_exists($name, self::$values[static::class])) { + continue; + } + + static::createValue($name, $constant[0], $constant[1]); + } + + uasort(self::$values[static::class], function (self $a, self $b) { + return $a->ordinal() <=> $b->ordinal(); + }); + + self::$allValuesLoaded[static::class] = true; + return self::$values[static::class]; + } + + final private static function constants() : array + { + if (isset(self::$constants[static::class])) { + return self::$constants[static::class]; + } + + self::$constants[static::class] = []; + $reflectionClass = new ReflectionClass(static::class); + $ordinal = -1; + + foreach ($reflectionClass->getReflectionConstants() as $reflectionConstant) { + if (! $reflectionConstant->isProtected()) { + continue; + } + + $value = $reflectionConstant->getValue(); + + self::$constants[static::class][$reflectionConstant->name] = [ + ++$ordinal, + is_array($value) ? $value : [] + ]; + } + + return self::$constants[static::class]; + } + + /** + * Returns the name of this enum constant, exactly as declared in its enum declaration. + * + * Most programmers should use the {@see self::__toString()} method in preference to this one, as the toString + * method may return a more user-friendly name. This method is designed primarily for use in specialized situations + * where correctness depends on getting the exact name, which will not vary from release to release. + */ + final public function name() : string + { + return $this->name; + } + + /** + * Returns the ordinal of this enumeration constant (its position in its enum declaration, where the initial + * constant is assigned an ordinal of zero). + * + * Most programmers will have no use for this method. It is designed for use by sophisticated enum-based data + * structures. + */ + final public function ordinal() : int + { + return $this->ordinal; + } + + /** + * Compares this enum with the specified object for order. + * + * Returns negative integer, zero or positive integer as this object is less than, equal to or greater than the + * specified object. + * + * Enums are only comparable to other enums of the same type. The natural order implemented by this method is the + * order in which the constants are declared. + * + * @throws MismatchException if the passed enum is not of the same type + */ + final public function compareTo(self $other) : int + { + if (! $other instanceof static) { + throw new MismatchException(sprintf( + 'The passed enum %s is not of the same type as %s', + get_class($other), + static::class + )); + } + + return $this->ordinal - $other->ordinal; + } + + /** + * Forbid cloning enums. + * + * @throws CloneNotSupportedException + */ + final public function __clone() + { + throw new CloneNotSupportedException(); + } + + /** + * Forbid serializing enums. + * + * @throws SerializeNotSupportedException + */ + final public function __sleep() : void + { + throw new SerializeNotSupportedException(); + } + + /** + * Forbid unserializing enums. + * + * @throws UnserializeNotSupportedException + */ + final public function __wakeup() : void + { + throw new UnserializeNotSupportedException(); + } + + /** + * Turns the enum into a string representation. + * + * You may override this method to give a more user-friendly version. + */ + public function __toString() : string + { + return $this->name; + } +} diff --git a/srcs/phpmyadmin/vendor/dasprid/enum/src/EnumMap.php b/srcs/phpmyadmin/vendor/dasprid/enum/src/EnumMap.php new file mode 100644 index 0000000..77c5f35 --- /dev/null +++ b/srcs/phpmyadmin/vendor/dasprid/enum/src/EnumMap.php @@ -0,0 +1,375 @@ +<?php +declare(strict_types = 1); + +namespace DASPRiD\Enum; + +use DASPRiD\Enum\Exception\ExpectationException; +use DASPRiD\Enum\Exception\IllegalArgumentException; +use IteratorAggregate; +use Serializable; +use Traversable; + +/** + * A specialized map implementation for use with enum type keys. + * + * All of the keys in an enum map must come from a single enum type that is specified, when the map is created. Enum + * maps are represented internally as arrays. This representation is extremely compact and efficient. + * + * Enum maps are maintained in the natural order of their keys (the order in which the enum constants are declared). + * This is reflected in the iterators returned by the collection views {@see self::getIterator()} and + * {@see self::values()}. + * + * Iterators returned by the collection views are not consistent: They may or may not show the effects of modifications + * to the map that occur while the iteration is in progress. + */ +final class EnumMap implements Serializable, IteratorAggregate +{ + /** + * The class name of the key. + * + * @var string + */ + private $keyType; + + /** + * The type of the value. + * + * @var string + */ + private $valueType; + + /** + * @var bool + */ + private $allowNullValues; + + /** + * All of the constants comprising the enum, cached for performance. + * + * @var array<int, AbstractEnum> + */ + private $keyUniverse; + + /** + * Array representation of this map. The ith element is the value to which universe[i] is currently mapped, or null + * if it isn't mapped to anything, or NullValue if it's mapped to null. + * + * @var array<int, mixed> + */ + private $values; + + /** + * @var int + */ + private $size = 0; + + /** + * Creates a new enum map. + * + * @param string $keyType the type of the keys, must extend AbstractEnum + * @param string $valueType the type of the values + * @param bool $allowNullValues whether to allow null values + * @throws IllegalArgumentException when key type does not extend AbstractEnum + */ + public function __construct(string $keyType, string $valueType, bool $allowNullValues) + { + if (! is_subclass_of($keyType, AbstractEnum::class)) { + throw new IllegalArgumentException(sprintf( + 'Class %s does not extend %s', + $keyType, + AbstractEnum::class + )); + } + + $this->keyType = $keyType; + $this->valueType = $valueType; + $this->allowNullValues = $allowNullValues; + $this->keyUniverse = $keyType::values(); + $this->values = array_fill(0, count($this->keyUniverse), null); + } + + /** + * Checks whether the map types match the supplied ones. + * + * You should call this method when an EnumMap is passed to you and you want to ensure that it's made up of the + * correct types. + * + * @throws ExpectationException when supplied key type mismatches local key type + * @throws ExpectationException when supplied value type mismatches local value type + * @throws ExpectationException when the supplied map allows null values, abut should not + */ + public function expect(string $keyType, string $valueType, bool $allowNullValues) : void + { + if ($keyType !== $this->keyType) { + throw new ExpectationException(sprintf( + 'Callee expected an EnumMap with key type %s, but got %s', + $keyType, + $this->keyType + )); + } + + if ($valueType !== $this->valueType) { + throw new ExpectationException(sprintf( + 'Callee expected an EnumMap with value type %s, but got %s', + $keyType, + $this->keyType + )); + } + + if ($allowNullValues !== $this->allowNullValues) { + throw new ExpectationException(sprintf( + 'Callee expected an EnumMap with nullable flag %s, but got %s', + ($allowNullValues ? 'true' : 'false'), + ($this->allowNullValues ? 'true' : 'false') + )); + } + } + + /** + * Returns the number of key-value mappings in this map. + */ + public function size() : int + { + return $this->size; + } + + /** + * Returns true if this map maps one or more keys to the specified value. + */ + public function containsValue($value) : bool + { + return in_array($this->maskNull($value), $this->values, true); + } + + /** + * Returns true if this map contains a mapping for the specified key. + */ + public function containsKey(AbstractEnum $key) : bool + { + $this->checkKeyType($key); + return null !== $this->values[$key->ordinal()]; + } + + /** + * Returns the value to which the specified key is mapped, or null if this map contains no mapping for the key. + * + * More formally, if this map contains a mapping from a key to a value, then this method returns the value; + * otherwise it returns null (there can be at most one such mapping). + * + * A return value of null does not necessarily indicate that the map contains no mapping for the key; it's also + * possible that hte map explicitly maps the key to null. The {@see self::containsKey()} operation may be used to + * distinguish these two cases. + * + * @return mixed + */ + public function get(AbstractEnum $key) + { + $this->checkKeyType($key); + return $this->unmaskNull($this->values[$key->ordinal()]); + } + + /** + * Associates the specified value with the specified key in this map. + * + * If the map previously contained a mapping for this key, the old value is replaced. + * + * @return mixed the previous value associated with the specified key, or null if there was no mapping for the key. + * (a null return can also indicate that the map previously associated null with the specified key.) + * @throws IllegalArgumentException when the passed values does not match the internal value type + */ + public function put(AbstractEnum $key, $value) + { + $this->checkKeyType($key); + + if (! $this->isValidValue($value)) { + throw new IllegalArgumentException(sprintf('Value is not of type %s', $this->valueType)); + } + + $index = $key->ordinal(); + $oldValue = $this->values[$index]; + $this->values[$index] = $this->maskNull($value); + + if (null === $oldValue) { + ++$this->size; + } + + return $this->unmaskNull($oldValue); + } + + /** + * Removes the mapping for this key frm this map if present. + * + * @return mixed the previous value associated with the specified key, or null if there was no mapping for the key. + * (a null return can also indicate that the map previously associated null with the specified key.) + */ + public function remove(AbstractEnum $key) + { + $this->checkKeyType($key); + + $index = $key->ordinal(); + $oldValue = $this->values[$index]; + $this->values[$index] = null; + + if (null !== $oldValue) { + --$this->size; + } + + return $this->unmaskNull($oldValue); + } + + /** + * Removes all mappings from this map. + */ + public function clear() : void + { + $this->values = array_fill(0, count($this->keyUniverse), null); + $this->size = 0; + } + + /** + * Compares the specified map with this map for quality. + * + * Returns true if the two maps represent the same mappings. + */ + public function equals(self $other) : bool + { + if ($this === $other) { + return true; + } + + if ($this->size !== $other->size) { + return false; + } + + return $this->values === $other->values; + } + + /** + * Returns the values contained in this map. + * + * The array will contain the values in the order their corresponding keys appear in the map, which is their natural + * order (the order in which the num constants are declared). + */ + public function values() : array + { + return array_values(array_map(function ($value) { + return $this->unmaskNull($value); + }, array_filter($this->values, function ($value) : bool { + return null !== $value; + }))); + } + + public function serialize() : string + { + $values = []; + + foreach ($this->values as $ordinal => $value) { + if (null === $value) { + continue; + } + + $values[$ordinal] = $this->unmaskNull($value); + } + + return serialize([ + 'keyType' => $this->keyType, + 'valueType' => $this->valueType, + 'allowNullValues' => $this->allowNullValues, + 'values' => $values, + ]); + } + + public function unserialize($serialized) : void + { + $data = unserialize($serialized); + $this->__construct($data['keyType'], $data['valueType'], $data['allowNullValues']); + + foreach ($this->keyUniverse as $key) { + if (array_key_exists($key->ordinal(), $data['values'])) { + $this->put($key, $data['values'][$key->ordinal()]); + } + } + } + + public function getIterator() : Traversable + { + foreach ($this->keyUniverse as $key) { + if (null === $this->values[$key->ordinal()]) { + continue; + } + + yield $key => $this->unmaskNull($this->values[$key->ordinal()]); + } + } + + private function maskNull($value) + { + if (null === $value) { + return NullValue::instance(); + } + + return $value; + } + + private function unmaskNull($value) + { + if ($value instanceof NullValue) { + return null; + } + + return $value; + } + + /** + * @throws IllegalArgumentException when the passed key does not match the internal key type + */ + private function checkKeyType(AbstractEnum $key) : void + { + if (get_class($key) !== $this->keyType) { + throw new IllegalArgumentException(sprintf( + 'Object of type %s is not the same type as %s', + get_class($key), + $this->keyType + )); + } + } + + private function isValidValue($value) : bool + { + if (null === $value) { + if ($this->allowNullValues) { + return true; + } + + return false; + } + + switch ($this->valueType) { + case 'mixed': + return true; + + case 'bool': + case 'boolean': + return is_bool($value); + + case 'int': + case 'integer': + return is_int($value); + + case 'float': + case 'double': + return is_float($value); + + case 'string': + return is_string($value); + + case 'object': + return is_object($value); + + case 'array': + return is_array($value); + } + + return $value instanceof $this->valueType; + } +} diff --git a/srcs/phpmyadmin/vendor/dasprid/enum/src/Exception/CloneNotSupportedException.php b/srcs/phpmyadmin/vendor/dasprid/enum/src/Exception/CloneNotSupportedException.php new file mode 100644 index 0000000..4b37dbe --- /dev/null +++ b/srcs/phpmyadmin/vendor/dasprid/enum/src/Exception/CloneNotSupportedException.php @@ -0,0 +1,10 @@ +<?php +declare(strict_types = 1); + +namespace DASPRiD\Enum\Exception; + +use Exception; + +final class CloneNotSupportedException extends Exception implements ExceptionInterface +{ +} diff --git a/srcs/phpmyadmin/vendor/dasprid/enum/src/Exception/ExceptionInterface.php b/srcs/phpmyadmin/vendor/dasprid/enum/src/Exception/ExceptionInterface.php new file mode 100644 index 0000000..16a6005 --- /dev/null +++ b/srcs/phpmyadmin/vendor/dasprid/enum/src/Exception/ExceptionInterface.php @@ -0,0 +1,10 @@ +<?php +declare(strict_types = 1); + +namespace DASPRiD\Enum\Exception; + +use Throwable; + +interface ExceptionInterface extends Throwable +{ +} diff --git a/srcs/phpmyadmin/vendor/dasprid/enum/src/Exception/ExpectationException.php b/srcs/phpmyadmin/vendor/dasprid/enum/src/Exception/ExpectationException.php new file mode 100644 index 0000000..bddfc90 --- /dev/null +++ b/srcs/phpmyadmin/vendor/dasprid/enum/src/Exception/ExpectationException.php @@ -0,0 +1,10 @@ +<?php +declare(strict_types = 1); + +namespace DASPRiD\Enum\Exception; + +use Exception; + +final class ExpectationException extends Exception implements ExceptionInterface +{ +} diff --git a/srcs/phpmyadmin/vendor/dasprid/enum/src/Exception/IllegalArgumentException.php b/srcs/phpmyadmin/vendor/dasprid/enum/src/Exception/IllegalArgumentException.php new file mode 100644 index 0000000..72b8f73 --- /dev/null +++ b/srcs/phpmyadmin/vendor/dasprid/enum/src/Exception/IllegalArgumentException.php @@ -0,0 +1,10 @@ +<?php +declare(strict_types = 1); + +namespace DASPRiD\Enum\Exception; + +use Exception; + +final class IllegalArgumentException extends Exception implements ExceptionInterface +{ +} diff --git a/srcs/phpmyadmin/vendor/dasprid/enum/src/Exception/MismatchException.php b/srcs/phpmyadmin/vendor/dasprid/enum/src/Exception/MismatchException.php new file mode 100644 index 0000000..1ca87d5 --- /dev/null +++ b/srcs/phpmyadmin/vendor/dasprid/enum/src/Exception/MismatchException.php @@ -0,0 +1,10 @@ +<?php +declare(strict_types = 1); + +namespace DASPRiD\Enum\Exception; + +use Exception; + +final class MismatchException extends Exception implements ExceptionInterface +{ +} diff --git a/srcs/phpmyadmin/vendor/dasprid/enum/src/Exception/SerializeNotSupportedException.php b/srcs/phpmyadmin/vendor/dasprid/enum/src/Exception/SerializeNotSupportedException.php new file mode 100644 index 0000000..8997a7e --- /dev/null +++ b/srcs/phpmyadmin/vendor/dasprid/enum/src/Exception/SerializeNotSupportedException.php @@ -0,0 +1,10 @@ +<?php +declare(strict_types = 1); + +namespace DASPRiD\Enum\Exception; + +use Exception; + +final class SerializeNotSupportedException extends Exception implements ExceptionInterface +{ +} diff --git a/srcs/phpmyadmin/vendor/dasprid/enum/src/Exception/UnserializeNotSupportedException.php b/srcs/phpmyadmin/vendor/dasprid/enum/src/Exception/UnserializeNotSupportedException.php new file mode 100644 index 0000000..13b0b49 --- /dev/null +++ b/srcs/phpmyadmin/vendor/dasprid/enum/src/Exception/UnserializeNotSupportedException.php @@ -0,0 +1,10 @@ +<?php +declare(strict_types = 1); + +namespace DASPRiD\Enum\Exception; + +use Exception; + +final class UnserializeNotSupportedException extends Exception implements ExceptionInterface +{ +} diff --git a/srcs/phpmyadmin/vendor/dasprid/enum/src/NullValue.php b/srcs/phpmyadmin/vendor/dasprid/enum/src/NullValue.php new file mode 100644 index 0000000..ab757ab --- /dev/null +++ b/srcs/phpmyadmin/vendor/dasprid/enum/src/NullValue.php @@ -0,0 +1,55 @@ +<?php +declare(strict_types = 1); + +namespace DASPRiD\Enum; + +use DASPRiD\Enum\Exception\CloneNotSupportedException; +use DASPRiD\Enum\Exception\SerializeNotSupportedException; +use DASPRiD\Enum\Exception\UnserializeNotSupportedException; + +final class NullValue +{ + /** + * @var self + */ + private static $instance; + + private function __construct() + { + } + + public static function instance() : self + { + return self::$instance ?: self::$instance = new self(); + } + + /** + * Forbid cloning enums. + * + * @throws CloneNotSupportedException + */ + final public function __clone() + { + throw new CloneNotSupportedException(); + } + + /** + * Forbid serializing enums. + * + * @throws SerializeNotSupportedException + */ + final public function __sleep() : void + { + throw new SerializeNotSupportedException(); + } + + /** + * Forbid unserializing enums. + * + * @throws UnserializeNotSupportedException + */ + final public function __wakeup() : void + { + throw new UnserializeNotSupportedException(); + } +} diff --git a/srcs/phpmyadmin/vendor/dasprid/enum/test/AbstractEnumTest.php b/srcs/phpmyadmin/vendor/dasprid/enum/test/AbstractEnumTest.php new file mode 100644 index 0000000..ddba7d3 --- /dev/null +++ b/srcs/phpmyadmin/vendor/dasprid/enum/test/AbstractEnumTest.php @@ -0,0 +1,121 @@ +<?php +declare(strict_types = 1); + +namespace DASPRiD\EnumTest; + +use DASPRiD\Enum\AbstractEnum; +use DASPRiD\Enum\Exception\CloneNotSupportedException; +use DASPRiD\Enum\Exception\IllegalArgumentException; +use DASPRiD\Enum\Exception\MismatchException; +use DASPRiD\Enum\Exception\SerializeNotSupportedException; +use DASPRiD\Enum\Exception\UnserializeNotSupportedException; +use PHPUnit\Framework\TestCase; +use ReflectionClass; + +final class AbstractEnumTest extends TestCase +{ + public function setUp() + { + $reflectionClass = new ReflectionClass(AbstractEnum::class); + + $constantsProperty = $reflectionClass->getProperty('constants'); + $constantsProperty->setAccessible(true); + $constantsProperty->setValue([]); + + $valuesProperty = $reflectionClass->getProperty('values'); + $valuesProperty->setAccessible(true); + $valuesProperty->setValue([]); + + $allValuesLoadedProperty = $reflectionClass->getProperty('allValuesLoaded'); + $allValuesLoadedProperty->setAccessible(true); + $allValuesLoadedProperty->setValue([]); + } + + public function testToString() : void + { + $weekday = WeekDay::FRIDAY(); + self::assertSame('FRIDAY', (string) $weekday); + } + + public function testName() : void + { + $this->assertSame('WEDNESDAY', WeekDay::WEDNESDAY()->name()); + } + + public function testOrdinal() : void + { + $this->assertSame(2, WeekDay::WEDNESDAY()->ordinal()); + } + + public function testSameInstanceIsReturned() : void + { + self::assertSame(WeekDay::FRIDAY(), WeekDay::FRIDAY()); + } + + public static function testValueOf() : void + { + self::assertSame(WeekDay::FRIDAY(), WeekDay::valueOf('FRIDAY')); + } + + public function testValueOfInvalidConstant() : void + { + $this->expectException(IllegalArgumentException::class); + WeekDay::valueOf('CATURDAY'); + } + + public function testExceptionOnCloneAttempt() : void + { + $this->expectException(CloneNotSupportedException::class); + clone WeekDay::FRIDAY(); + } + + public function testExceptionOnSerializeAttempt() : void + { + $this->expectException(SerializeNotSupportedException::class); + serialize(WeekDay::FRIDAY()); + } + + public function testExceptionOnUnserializeAttempt() : void + { + $this->expectException(UnserializeNotSupportedException::class); + unserialize('O:24:"DASPRiD\\EnumTest\\WeekDay":0:{}'); + } + + public function testReturnValueOfValuesIsSortedByOrdinal() : void + { + // Initialize some week days out of order + WeekDay::SATURDAY(); + WeekDay::TUESDAY(); + + $ordinals = array_values(array_map(function (WeekDay $weekDay) : int { + return $weekDay->ordinal(); + }, WeekDay::values())); + + self::assertSame([0, 1, 2, 3, 4, 5, 6], $ordinals); + + $cachedOrdinals = array_values(array_map(function (WeekDay $weekDay) : int { + return $weekDay->ordinal(); + }, WeekDay::values())); + $this->assertSame($ordinals, $cachedOrdinals); + } + + public function testCompareTo() : void + { + $this->assertSame(-4, WeekDay::WEDNESDAY()->compareTo(WeekDay::SUNDAY())); + $this->assertSame(4, WeekDay::SUNDAY()->compareTo(WeekDay::WEDNESDAY())); + $this->assertSame(0, WeekDay::WEDNESDAY()->compareTo(WeekDay::WEDNESDAY())); + } + + public function testCompareToWrongEnum() : void + { + $this->expectException(MismatchException::class); + WeekDay::MONDAY()->compareTo(Planet::EARTH()); + } + + public function testParameterizedEnum() : void + { + $planet = Planet::EARTH(); + $this->assertSame(5.976e+24, $planet->mass()); + $this->assertSame(6.37814e6, $planet->radius()); + } +} diff --git a/srcs/phpmyadmin/vendor/dasprid/enum/test/EnumMapTest.php b/srcs/phpmyadmin/vendor/dasprid/enum/test/EnumMapTest.php new file mode 100644 index 0000000..d51a86c --- /dev/null +++ b/srcs/phpmyadmin/vendor/dasprid/enum/test/EnumMapTest.php @@ -0,0 +1,243 @@ +<?php +declare(strict_types = 1); + +namespace DASPRiD\EnumTest; + +use DASPRiD\Enum\EnumMap; +use DASPRiD\Enum\Exception\ExpectationException; +use DASPRiD\Enum\Exception\IllegalArgumentException; +use PHPUnit\Framework\TestCase; +use stdClass; + +final class EnumMapTest extends TestCase +{ + public function testConstructionWithInvalidEnumType() : void + { + $this->expectException(IllegalArgumentException::class); + new EnumMap(stdClass::class, 'string', false); + } + + public function testUnexpectedKeyType() : void + { + $this->expectException(ExpectationException::class); + $map = new EnumMap(WeekDay::class, 'string', false); + $map->expect(Planet::class, 'string', false); + } + + public function testUnexpectedValueType() : void + { + $this->expectException(ExpectationException::class); + $map = new EnumMap(WeekDay::class, 'string', false); + $map->expect(WeekDay::class, 'int', false); + } + + public function testUnexpectedNullableValueType() : void + { + $this->expectException(ExpectationException::class); + $map = new EnumMap(WeekDay::class, 'string', true); + $map->expect(WeekDay::class, 'string', false); + } + + public function testExpectedTypes() : void + { + $map = new EnumMap(WeekDay::class, 'string', true); + $map->expect(WeekDay::class, 'string', true); + $this->addToAssertionCount(1); + } + + public function testSize() : void + { + $map = new EnumMap(WeekDay::class, 'string', true); + $this->assertSame(0, $map->size()); + $map->put(WeekDay::MONDAY(), 'foo'); + $this->assertSame(1, $map->size()); + } + + public function testContainsValue() : void + { + $map = new EnumMap(WeekDay::class, 'string', true); + $this->assertFalse($map->containsValue('foo')); + $map->put(WeekDay::TUESDAY(), 'foo'); + $this->assertTrue($map->containsValue('foo')); + $this->assertFalse($map->containsValue(null)); + $map->put(WeekDay::WEDNESDAY(), null); + $this->assertTrue($map->containsValue(null)); + } + + public function testContainsKey() : void + { + $map = new EnumMap(WeekDay::class, 'string', true); + $this->assertFalse($map->containsKey(WeekDay::TUESDAY())); + $map->put(WeekDay::TUESDAY(), 'foo'); + $this->assertTrue($map->containsKey(WeekDay::TUESDAY())); + $map->put(WeekDay::WEDNESDAY(), null); + $this->assertTrue($map->containsKey(WeekDay::WEDNESDAY())); + } + + public function testPutAndGet() : void + { + $map = new EnumMap(WeekDay::class, 'string', true); + $map->put(WeekDay::TUESDAY(), 'foo'); + $map->put(WeekDay::FRIDAY(), null); + $this->assertSame('foo', $map->get(WeekDay::TUESDAY())); + $this->assertSame(null, $map->get(WeekDay::WEDNESDAY())); + $this->assertSame(null, $map->get(WeekDay::FRIDAY())); + } + + public function testPutInvalidKey() : void + { + $this->expectException(IllegalArgumentException::class); + $map = new EnumMap(WeekDay::class, 'string', true); + $map->put(Planet::MARS(), 'foo'); + } + + public function invalidValues() : array + { + return [ + ['bool', null, false], + ['bool', 0], + ['boolean', 0], + ['int', 2.4], + ['integer', 5.3], + ['float', 3], + ['double', 7], + ['string', 1], + ['object', 1], + ['array', 1], + [stdClass::class, 1], + ]; + } + + /** + * @dataProvider invalidValues + * @param mixed $value + */ + public function testPutInvalidValue(string $valueType, $value, bool $allowNull = true) : void + { + $this->expectException(IllegalArgumentException::class); + $map = new EnumMap(WeekDay::class, $valueType, $allowNull); + $map->put(WeekDay::TUESDAY(), $value); + } + + public function validValues() : array + { + return [ + ['bool', null], + ['mixed', 'foo'], + ['mixed', 1], + ['mixed', new stdClass()], + ['bool', true], + ['boolean', false], + ['int', 1], + ['integer', 4], + ['float', 2.5], + ['double', 6.4], + ['string', 'foo'], + ['object', new stdClass()], + ['array', ['foo']], + [stdClass::class, new stdClass()], + ]; + } + + /** + * @dataProvider validValues + * @param mixed $value + */ + public function testPutValidValue(string $valueType, $value, bool $allowNull = true) : void + { + $map = new EnumMap(WeekDay::class, $valueType, $allowNull); + $map->put(WeekDay::TUESDAY(), $value); + $this->addToAssertionCount(1); + } + + public function testRemove() : void + { + $map = new EnumMap(WeekDay::class, 'string', true); + $map->put(WeekDay::TUESDAY(), 'foo'); + $map->remove(WeekDay::TUESDAY()); + $map->remove(WeekDay::WEDNESDAY()); + $this->assertSame(null, $map->get(WeekDay::TUESDAY())); + $this->assertSame(0, $map->size()); + } + + public function testClear() : void + { + $map = new EnumMap(WeekDay::class, 'string', true); + $map->put(WeekDay::TUESDAY(), 'foo'); + $map->clear(); + $this->assertSame(null, $map->get(WeekDay::TUESDAY())); + $this->assertSame(0, $map->size()); + } + + public function testEqualsWithSameInstance() : void + { + $map = new EnumMap(WeekDay::class, 'string', true); + $this->assertTrue($map->equals($map)); + } + + public function testEqualsWithDifferentSize() : void + { + $mapA = new EnumMap(WeekDay::class, 'string', true); + $mapB = new EnumMap(WeekDay::class, 'string', true); + $mapB->put(WeekDay::MONDAY(), 'foo'); + + $this->assertFalse($mapA->equals($mapB)); + } + + public function testEqualsWithDifferentValues() : void + { + $mapA = new EnumMap(WeekDay::class, 'string', true); + $mapA->put(WeekDay::MONDAY(), 'foo'); + $mapB = new EnumMap(WeekDay::class, 'string', true); + $mapB->put(WeekDay::MONDAY(), 'bar'); + + $this->assertFalse($mapA->equals($mapB)); + } + + public function testEqualsWithDifferentConstants() : void + { + $mapA = new EnumMap(WeekDay::class, 'string', true); + $mapA->put(WeekDay::MONDAY(), 'foo'); + $mapB = new EnumMap(WeekDay::class, 'string', true); + $mapB->put(WeekDay::TUESDAY(), 'foo'); + + $this->assertFalse($mapA->equals($mapB)); + } + + public function testValues() : void + { + $map = new EnumMap(WeekDay::class, 'string', true); + $this->assertSame([], $map->values()); + + $map->put(WeekDay::FRIDAY(), 'foo'); + $map->put(WeekDay::TUESDAY(), 'bar'); + $map->put(WeekDay::SUNDAY(), null); + + $this->assertSame(['bar', 'foo', null], $map->values()); + } + + public function testSerializeAndUnserialize() : void + { + $mapA = new EnumMap(WeekDay::class, 'string', true); + $mapA->put(WeekDay::MONDAY(), 'foo'); + $mapB = unserialize(serialize($mapA)); + + $this->assertTrue($mapA->equals($mapB)); + } + + public function testIterator() : void + { + $map = new EnumMap(WeekDay::class, 'string', true); + $map->put(WeekDay::FRIDAY(), 'foo'); + $map->put(WeekDay::TUESDAY(), 'bar'); + $map->put(WeekDay::SUNDAY(), null); + + $result = []; + + foreach ($map as $key => $value) { + $result[$key->ordinal()] = $value; + } + + $this->assertSame([1 => 'bar', 4 => 'foo', 6 => null], $result); + } +} diff --git a/srcs/phpmyadmin/vendor/dasprid/enum/test/NullValueTest.php b/srcs/phpmyadmin/vendor/dasprid/enum/test/NullValueTest.php new file mode 100644 index 0000000..9f70640 --- /dev/null +++ b/srcs/phpmyadmin/vendor/dasprid/enum/test/NullValueTest.php @@ -0,0 +1,31 @@ +<?php +declare(strict_types = 1); + +namespace DASPRiD\EnumTest; + +use DASPRiD\Enum\Exception\CloneNotSupportedException; +use DASPRiD\Enum\Exception\SerializeNotSupportedException; +use DASPRiD\Enum\Exception\UnserializeNotSupportedException; +use DASPRiD\Enum\NullValue; +use PHPUnit\Framework\TestCase; + +final class NullValueTest extends TestCase +{ + public function testExceptionOnCloneAttempt() : void + { + $this->expectException(CloneNotSupportedException::class); + clone NullValue::instance(); + } + + public function testExceptionOnSerializeAttempt() : void + { + $this->expectException(SerializeNotSupportedException::class); + serialize(NullValue::instance()); + } + + public function testExceptionOnUnserializeAttempt() : void + { + $this->expectException(UnserializeNotSupportedException::class); + unserialize('O:22:"DASPRiD\\Enum\\NullValue":0:{}'); + } +} diff --git a/srcs/phpmyadmin/vendor/dasprid/enum/test/Planet.php b/srcs/phpmyadmin/vendor/dasprid/enum/test/Planet.php new file mode 100644 index 0000000..3c44c1d --- /dev/null +++ b/srcs/phpmyadmin/vendor/dasprid/enum/test/Planet.php @@ -0,0 +1,73 @@ +<?php +declare(strict_types = 1); + +namespace DASPRiD\EnumTest; + +use DASPRiD\Enum\AbstractEnum; + +/** + * @method static self MERCURY() + * @method static self VENUS() + * @method static self EARTH() + * @method static self MARS() + * @method static self JUPITER() + * @method static self SATURN() + * @method static self URANUS() + * @method static self NEPTUNE() + */ +final class Planet extends AbstractEnum +{ + protected const MERCURY = [3.303e+23, 2.4397e6]; + protected const VENUS = [4.869e+24, 6.0518e6]; + protected const EARTH = [5.976e+24, 6.37814e6]; + protected const MARS = [6.421e+23, 3.3972e6]; + protected const JUPITER = [1.9e+27, 7.1492e7]; + protected const SATURN = [5.688e+26, 6.0268e7]; + protected const URANUS = [8.686e+25, 2.5559e7]; + protected const NEPTUNE = [1.024e+26, 2.4746e7]; + + /** + * Universal gravitational constant. + */ + private const G = 6.67300E-11; + + /** + * Mass in kilograms. + * + * @var float + */ + private $mass; + + /** + * Radius in meters. + * + * @var float + */ + private $radius; + + protected function __construct(float $mass, float $radius) + { + $this->mass = $mass; + $this->radius = $radius; + } + + public function mass() : float + { + return $this->mass; + } + + public function radius() : float + { + return $this->radius; + } + + public function surfaceGravity() : float + { + return self::G * $this->mass / ($this->radius * $this->radius); + } + + public function surfaceWeight(float $otherMass) : float + { + return $otherMass * $this->surfaceGravity(); + } +} diff --git a/srcs/phpmyadmin/vendor/dasprid/enum/test/WeekDay.php b/srcs/phpmyadmin/vendor/dasprid/enum/test/WeekDay.php new file mode 100644 index 0000000..70b8db5 --- /dev/null +++ b/srcs/phpmyadmin/vendor/dasprid/enum/test/WeekDay.php @@ -0,0 +1,26 @@ +<?php +declare(strict_types = 1); + +namespace DASPRiD\EnumTest; + +use DASPRiD\Enum\AbstractEnum; + +/** + * @method static self MONDAY() + * @method static self TUESDAY() + * @method static self WEDNESDAY() + * @method static self THURSDAY() + * @method static self FRIDAY() + * @method static self SATURDAY() + * @method static self SUNDAY() + */ +final class WeekDay extends AbstractEnum +{ + protected const MONDAY = null; + protected const TUESDAY = null; + protected const WEDNESDAY = null; + protected const THURSDAY = null; + protected const FRIDAY = null; + protected const SATURDAY = null; + protected const SUNDAY = null; +} |