Merge remote-tracking branch 'refs/remotes/origin/1.x' into 1.x

Updated composer keywords

See merge request olive/PHP/map!7

.gitignore

@@ -1,5 +1,5 @@
 .idea/
 vendor/
-
 .php_cs.cache
 .phpunit.cache/
+.php-cs-fixer.cache

.gitlab-ci.yml

@@ -15,7 +15,7 @@ before_script:
       apt-get update -yqq && apt-get upgrade -yqq && apt-get install -yqq git libzip-dev unzip zip libpcre3-dev && docker-php-ext-install zip && pecl install xdebug && docker-php-ext-enable xdebug
     fi
   - > 
-    if [ "$CI_JOB_NAME" == "test:7.4" ] || [ "$CI_JOB_NAME" == "test:8.0" ]; then
+    if [ "$CI_JOB_NAME" == "test:8.1" ]; then
         pecl install ds && docker-php-ext-enable ds
     fi
   - >
@@ -23,36 +23,20 @@ before_script:
       curl -sS https://getcomposer.org/installer | php
       php composer.phar install
     fi
-test:7.4:
+test:8.1:
   only:
   - branches
   tags:
   - default
-  image: php:7.4
+  image: php:8.1
   script:
   - vendor/bin/phpunit --configuration phpunit.xml --coverage-text --colors=never
-test:7.4-without-ext-ds:
+test:8.1-without-ext-ds:
   only:
   - branches
   tags:
   - default
-  image: php:7.4
-  script:
-  - vendor/bin/phpunit --configuration phpunit.xml --coverage-text --colors=never
-test:8.0:
-  only:
-  - branches
-  tags:
-  - default
-  image: php:8.0
-  script:
-  - vendor/bin/phpunit --configuration phpunit.xml --coverage-text --colors=never
-test:8.0-without-ext-ds:
-  only:
-  - branches
-  tags:
-  - default
-  image: php:8.0
+  image: php:8.1
   script:
   - vendor/bin/phpunit --configuration phpunit.xml --coverage-text --colors=never
 stages:

.php-cs-fixer.php

@@ -0,0 +1,77 @@
+<?php declare(strict_types=1);
+
+/*
+ * Copyright (c) 2020  https://rewiv.com sikofitt@gmail.com
+ *
+ * This file is a part of Olive BBS
+ *
+ * This Source Code Form is subject to the
+ * terms of the Mozilla Public License, v. 2.0.
+ *
+ * If a copy of the MPL was not distributed with this file,
+ * You can obtain one at https://mozilla.org/MPL/2.0/.
+ *
+ *         ___                   ___    ___
+ *        (   ).-.              (   )  (   )
+ *    .--. | |( __)___  ___ .--. | |.-. | |.-.     .--.
+ *   /    \| |(''"(   )(   /    \| /   \| /   \  /  _  \
+ *  |  .-. | | | | | |  | |  .-. |  .-. |  .-. |. .' `. ;
+ *  | |  | | | | | | |  | |  | | | |  | | |  | || '   | |
+ *  | |  | | | | | | |  | |  |/  | |  | | |  | |_\_`.(___)
+ *  | |  | | | | | | |  | |  ' _.| |  | | |  | (   ). '.
+ *  | '  | | | | | ' '  ; |  .'.-| '  | | '  | || |  `\ |
+ *  '  `-' | | | |  \ `' /'  `-' ' `-' ;' `-' ; ; '._,' '
+ *   `.__.(___(___)  '_.'  `.__.' `.__.  `.__.   '.___.'
+ *
+ */
+
+$header = '';
+
+if (file_exists(__DIR__.'/header.txt')) {
+    $header = file_get_contents('header.txt');
+}
+return (new \PhpCsFixer\Config())
+    ->setRiskyAllowed(true)
+    ->setRules([
+        '@PSR2' => true,
+        '@PHP80Migration' => true,
+        '@PHP80Migration:risky' => true,
+        '@PHP81Migration' => true,
+        'header_comment' => ['header' => $header],
+        'ordered_class_elements' => true,
+        'ordered_imports' => true,
+        'no_mixed_echo_print' => ['use' => 'print'],
+        'strict_param' => true,
+        'strict_comparison' => true,
+        'single_import_per_statement' => false,
+        'phpdoc_order' => true,
+        'array_syntax' => ['syntax' => 'short'],
+        'phpdoc_add_missing_param_annotation' => true,
+        'psr_autoloading' => true,
+        'phpdoc_var_without_name' => false,
+        'no_unused_imports' => true,
+        'no_useless_else' => true,
+        'no_useless_return' => true,
+        'no_extra_blank_lines' => [
+            'tokens' => [
+                'break',
+                'continue',
+                'extra',
+                'return',
+                'throw',
+                'parenthesis_brace_block',
+                'square_brace_block',
+                'curly_brace_block',
+            ],
+        ],
+    ])->setFinder(
+        (new \PhpCsFixer\Finder())
+            ->ignoreDotFiles(true)
+            ->ignoreVCS(true)
+            ->name('*.php')
+            ->in([
+                'src',
+                'tests',
+                __DIR__,
+            ])
+    );

.php_cs.dist

@@ -1,58 +0,0 @@
-<?php
-
-$header = '';
-
-if(file_exists(__DIR__.'/header.txt')) {
-    $header = file_get_contents('header.txt');
-}
-
-return PhpCsFixer\Config::create()
-  ->setRiskyAllowed(true)
-  ->setRules(
-    [
-      '@PSR2' => true,
-      '@PHP70Migration' => true,
-      '@PHP70Migration:risky' => true,
-      '@PHP71Migration' => true,
-      '@PHP71Migration:risky' => true,
-      '@PHP73Migration' => true,
-      '@PHP74Migration' => true,
-      '@PHP74Migration:risky' => true,
-      '@PHP80Migration' => true,
-      '@PHP80Migration:risky' => true,
-      'header_comment' => ['header' => $header],
-      'ordered_class_elements' => true,
-      'ordered_imports' => true,
-      'no_mixed_echo_print' => ['use' => 'print'],
-      'strict_param' => true,
-      'strict_comparison' => true,
-      'single_import_per_statement' => false,
-      'phpdoc_order' => true,
-      'array_syntax' => ['syntax' => 'short'],
-      'phpdoc_add_missing_param_annotation' => true,
-      'psr4' => true,
-      'phpdoc_var_without_name' => false,
- 	'no_unused_imports' => true,
-	'no_useless_else' => true,
-	'no_useless_return' => true,
-       'no_extra_consecutive_blank_lines' => [
-        'break',
-        'continue',
-        'extra',
-        'return',
-        'throw',
-        'parenthesis_brace_block',
-        'square_brace_block',
-        'curly_brace_block',
-      ],
-    ]
-  )->setFinder(
-    PhpCsFixer\Finder::create()
-      ->ignoreDotFiles(true)
-      ->ignoreVCS(true)
-      ->name('*.php')
-      ->in([
-        'src',
-	'tests',
-      ])
-  );

README.md

@@ -2,18 +2,21 @@
 
 Very simple typed map class.
 
+
 Includes IntCharMap and CharMap as examples.  It is best to extend `Olivebbs\Map\GenericMap `for your uses.
 
 ### Example
 
 ```php
 use Olivebbs\Map\GenericMap;
+use Olivebbs\Map\Enum\ValueType;
+use Olivebbs\Map\Enum\KeyType;
 
 final class MyStringMap extends GenericMap 
 {
     public function __construct(array $values)
     {
-        parent::__construct(GenericMap::STRING, GenericMap::STRING);
+        parent::__construct(KeyType::STRING, ValueType::STRING);
         $this->map->putAll($values);
     }
 }
@@ -23,8 +26,10 @@ or
 
 ```php
 use Olivebbs\Map\GenericMap;
+use Olivebbs\Map\Enum\ValueType;
+use Olivebbs\Map\Enum\KeyType;
 
-$myIntMap = new GenericMap(GenericMap::INT, GenericMap::INT); 
+$myIntMap = new GenericMap(KeyType::INT, ValueType::INT); 
 ```
 Then use it.
 ```php 

composer.json

@@ -1,14 +1,14 @@
 {
-    "name": "olivebbs/map",
+    "name": "olive/map",
     "description": "Generic map for PHP",
     "type": "library",
+    "keywords": ["map", "hashmap", "hash-map", "data", "data structure", "array", "arrayaccess"],
     "require": {
-        "php": ">=7.4",
-        "php-ds/php-ds": "^1.3",
-        "symfony/polyfill-php80": "^1.22"
+        "php": ">=8.1",
+        "php-ds/php-ds": "^1.4"
     },
     "require-dev": {
-        "friendsofphp/php-cs-fixer": "^2.18",
+        "friendsofphp/php-cs-fixer": "^3.13",
         "phpunit/phpunit": "^9.5"
     },
     "license": "MPL-2.0",
@@ -19,7 +19,7 @@
         }
     ],
     "suggest": {
-         "ext-ds": "ext-ds"   
+         "ext-ds": "To use the Data structure extension instead of polyfill."
     },
   "autoload": {
     "psr-4": {

src/Olivebbs/Map/CharMap.php

@@ -28,20 +28,23 @@
 namespace Olivebbs\Map;
 
 use function array_combine;
+use Olivebbs\Map\Enum\KeyType;
+use Olivebbs\Map\Enum\ValueType;
 use function str_split;
 
 class CharMap extends GenericMap
 {
     public function __construct(array $initialValues = [])
     {
-        parent::__construct(self::CHAR, self::CHAR);
+        parent::__construct(keyType: KeyType::CHAR, valueType: ValueType::CHAR);
 
-        $this->map->putAll($initialValues);
+        $this->map->putAll(values: $initialValues);
     }
 
-    public static function fromString(string $string): CharMap
+    public static function fromString(string $string): static
     {
-        $values = str_split($string);
-        return new self(array_combine($values, $values));
+        $values = str_split(string: $string);
+
+        return new static(initialValues: array_combine(keys: $values, values: $values));
     }
 }

src/Olivebbs/Map/Enum/KeyType.php

@@ -0,0 +1,37 @@
+<?php declare(strict_types=1);
+
+/*
+ * Copyright (c) 2020  https://rewiv.com sikofitt@gmail.com
+ *
+ * This file is a part of Olive BBS
+ *
+ * This Source Code Form is subject to the
+ * terms of the Mozilla Public License, v. 2.0.
+ *
+ * If a copy of the MPL was not distributed with this file,
+ * You can obtain one at https://mozilla.org/MPL/2.0/.
+ *
+ *         ___                   ___    ___
+ *        (   ).-.              (   )  (   )
+ *    .--. | |( __)___  ___ .--. | |.-. | |.-.     .--.
+ *   /    \| |(''"(   )(   /    \| /   \| /   \  /  _  \
+ *  |  .-. | | | | | |  | |  .-. |  .-. |  .-. |. .' `. ;
+ *  | |  | | | | | | |  | |  | | | |  | | |  | || '   | |
+ *  | |  | | | | | | |  | |  |/  | |  | | |  | |_\_`.(___)
+ *  | |  | | | | | | |  | |  ' _.| |  | | |  | (   ). '.
+ *  | '  | | | | | ' '  ; |  .'.-| '  | | '  | || |  `\ |
+ *  '  `-' | | | |  \ `' /'  `-' ' `-' ;' `-' ; ; '._,' '
+ *   `.__.(___(___)  '_.'  `.__.' `.__.  `.__.   '.___.'
+ *
+ */
+
+namespace Olivebbs\Map\Enum;
+
+enum KeyType : string
+{
+    case INT = 'int';
+    case INTEGER = 'integer';  // Shouldn't really use, just for compatibility.
+    case STRING = 'string';
+    case CHAR = 'char';
+    case ANY = 'any';
+}

src/Olivebbs/Map/Enum/ValueType.php

@@ -0,0 +1,41 @@
+<?php declare(strict_types=1);
+
+/*
+ * Copyright (c) 2020  https://rewiv.com sikofitt@gmail.com
+ *
+ * This file is a part of Olive BBS
+ *
+ * This Source Code Form is subject to the
+ * terms of the Mozilla Public License, v. 2.0.
+ *
+ * If a copy of the MPL was not distributed with this file,
+ * You can obtain one at https://mozilla.org/MPL/2.0/.
+ *
+ *         ___                   ___    ___
+ *        (   ).-.              (   )  (   )
+ *    .--. | |( __)___  ___ .--. | |.-. | |.-.     .--.
+ *   /    \| |(''"(   )(   /    \| /   \| /   \  /  _  \
+ *  |  .-. | | | | | |  | |  .-. |  .-. |  .-. |. .' `. ;
+ *  | |  | | | | | | |  | |  | | | |  | | |  | || '   | |
+ *  | |  | | | | | | |  | |  |/  | |  | | |  | |_\_`.(___)
+ *  | |  | | | | | | |  | |  ' _.| |  | | |  | (   ). '.
+ *  | '  | | | | | ' '  ; |  .'.-| '  | | '  | || |  `\ |
+ *  '  `-' | | | |  \ `' /'  `-' ' `-' ;' `-' ; ; '._,' '
+ *   `.__.(___(___)  '_.'  `.__.' `.__.  `.__.   '.___.'
+ *
+ */
+
+namespace Olivebbs\Map\Enum;
+
+enum ValueType : string
+{
+    case OBJECT = 'object';
+    case CALLABLE = 'callable';
+    case ARRAY = 'array';
+    case INT = 'int';
+    case INTEGER = 'integer';
+    case STRING = 'string';
+    case CHAR = 'char';
+    case ENUM = 'enum';
+    case ANY = 'any';
+}

src/Olivebbs/Map/GenericMap.php

@@ -28,57 +28,46 @@
 namespace Olivebbs\Map;
 
 use ArrayAccess;
+use function class_exists;
 use Countable;
 use Ds\Map;
+use function enum_exists;
 use function is_array;
 use function is_callable;
 use function is_int;
 use function is_object;
 use function is_string;
+use function mb_strlen;
+use Olivebbs\Map\Enum\KeyType;
+use Olivebbs\Map\Enum\ValueType;
 use Olivebbs\Map\Exception\InvalidArgumentException;
-
-use function strtolower;
-use TypeError;
-use ValueError;
+use function sprintf;
 
 class GenericMap implements ArrayAccess, Countable
 {
-    public const OBJECT = 'object';
-    public const CALLABLE = 'callable';
-    public const ARRAY = 'array';
-    public const INT = 'int';
-    public const INTEGER = 'integer';
-    public const STRING = 'string';
-    public const CHAR = 'char';
-    public const ANY = 'any';
-
     protected Map $map;
-    protected string $keyType;
-    protected string $valueType;
 
-    public function __construct(string $keyType = self::ANY, string $valueType = self::ANY)
+    private readonly string $valueTypeValue;
+    private readonly string $keyTypeValue;
+
+    public function __construct(protected KeyType $keyType = KeyType::ANY, protected object|string $valueType = ValueType::ANY)
     {
-        $this->keyType = strtolower($keyType);
+        $this->keyTypeValue = $this->keyType->value;
+        $this->valueTypeValue = is_string(value: $this->valueType) ? $this->valueType : $this->valueType->value;
 
-        $this->valueType = class_exists($valueType) ? $valueType : strtolower($valueType);
-
-        if (!$this->isValidKeyType($this->keyType)) {
-            throw new InvalidArgumentException(sprintf('Invalid key type (%s)', $this->keyType));
-        }
-
-        if (!$this->isValidValueType($this->valueType)) {
-            throw new InvalidArgumentException(sprintf('Invalid value type (%s)', $this->valueType));
+        if (!$this->isValidValueType(type: $this->valueType)) {
+            throw new InvalidArgumentException(message: sprintf('Invalid value type (%s)', $this->valueTypeValue));
         }
 
         $this->map = new Map();
     }
 
-    public function getKeyType(): string
+    public function getKeyType(): KeyType
     {
         return $this->keyType;
     }
 
-    public function getValueType(): string
+    public function getValueType(): object|string
     {
         return $this->valueType;
     }
@@ -86,71 +75,45 @@ class GenericMap implements ArrayAccess, Countable
     /**
      * @inheritDoc
      */
-    public function offsetExists($offset): bool
+    public function offsetExists(mixed $offset): bool
     {
-        if (is_array($offset) || is_object($offset)) {
-            throw new InvalidArgumentException('Map keys cannot be objects or arrays');
-        }
+        $this->checkTypes(offset: $offset);
 
-        if (!$this->checkType($this->keyType, $offset)) {
-            throw new TypeError(sprintf('Key should be of value %s.', $this->keyType));
-        }
-
-        return $this->map->offsetExists($offset);
+        return $this->map->offsetExists(offset: $offset);
     }
 
     /**
      * @inheritDoc
      */
-    public function offsetGet($offset)
+    public function offsetGet(mixed $offset): mixed
     {
-        if (is_array($offset) || is_object($offset)) {
-            throw new InvalidArgumentException('Map keys cannot be objects or arrays');
-        }
+        $this->checkTypes(offset: $offset);
 
-        if (!$this->checkType($this->keyType, $offset)) {
-            throw new TypeError(sprintf('Key should be of value %s.', $this->keyType));
-        }
-        if (!$this->map->offsetExists($offset)) {
+        if (!$this->map->offsetExists(offset: $offset)) {
             return null;
         }
-        return $this->map->offsetGet($offset);
+
+        return $this->map->offsetGet(offset: $offset);
     }
 
     /**
      * @inheritDoc
      */
-    public function offsetSet($offset, $value): void
+    public function offsetSet(mixed $offset, mixed $value): void
     {
-        if (is_array($offset) || is_object($offset)) {
-            throw new InvalidArgumentException('Map keys cannot be objects or arrays');
-        }
+        $this->checkTypes(offset: $offset, value: $value);
 
-        if (!$this->checkType($this->keyType, $offset)) {
-            throw new TypeError(sprintf('Key should be of value %s.', $this->keyType));
-        }
-
-        if (!$this->checkType($this->valueType, $value)) {
-            throw new ValueError(sprintf('Value should be of type %s.', $this->valueType));
-        }
-
-        $this->map->offsetSet($offset, $value);
+        $this->map->offsetSet(offset: $offset, value: $value);
     }
 
     /**
      * @inheritDoc
      */
-    public function offsetUnset($offset): void
+    public function offsetUnset(mixed $offset): void
     {
-        if (is_array($offset) || is_object($offset)) {
-            throw new InvalidArgumentException('Map keys cannot be objects or arrays');
-        }
+        $this->checkTypes(offset: $offset);
 
-        if (!$this->checkType($this->keyType, $offset)) {
-            throw new TypeError(sprintf('Key should be of value %s.', $this->keyType));
-        }
-
-        $this->map->offsetUnset($offset);
+        $this->map->offsetUnset(offset: $offset);
     }
 
     /**
@@ -176,68 +139,56 @@ class GenericMap implements ArrayAccess, Countable
     {
         foreach ($initialValues as $key => $value) {
             if (!$this->checkType($this->keyType, $key) || !$this->checkType($this->valueType, $value)) {
-                throw new InvalidArgumentException(sprintf('Invalid types for map [%s => %s], they should be [%s => %s]', get_debug_type($key), get_debug_type($value), $this->keyType, $this->valueType));
+                throw new InvalidArgumentException(message: sprintf('Invalid types for map [%s => %s], they should be [%s => %s]', get_debug_type(value: $key), get_debug_type(value: $value), $this->keyType->value, is_string($this->valueType) ? $this->valueType : $this->valueType->value));
             }
         }
         
         return true;
     }
 
+    private function checkTypes(mixed $offset, mixed $value = null): void
+    {
+        if (is_array(value: $offset) || is_object(value: $offset)) {
+            throw new InvalidArgumentException(message: 'Map keys cannot be objects or arrays');
+        }
+
+        if (!$this->checkType(type: $this->keyType, var: $offset)) {
+            throw new InvalidArgumentException(message: sprintf('Key should be of value %s.', $this->keyTypeValue));
+        }
+
+        if (null !== $value && !$this->checkType(type: $this->valueType, var: $value)) {
+            throw new InvalidArgumentException(message: sprintf('Value should be of type %s.', $this->valueTypeValue));
+        }
+    }
+
     /**
      * @codeCoverageIgnore
-     * @param string $type
-     * @param        $var
+     * @param KeyType|ValueType|string $type
+     * @param mixed $var
      *
      * @return bool
      */
-    private function checkType(string $type, $var): bool
+    private function checkType(KeyType|ValueType|string $type, mixed $var): bool
     {
-        switch ($type) {
-            case self::OBJECT:
-                return is_object($var);
-            case self::CALLABLE:
-                return is_callable($var);
-            case self::ARRAY:
-                return is_array($var);
-            case self::INT:
-            case self::INTEGER:
-                return is_int($var);
-            case self::STRING:
-                return is_string($var);
-            case self::CHAR:
-                return is_string($var) && \mb_strlen($var) === 1;
-            case self::ANY:
-                return true;
-            default:
-                return $var instanceof $type;
-        }
-    }
-    private function isValidKeyType(string $type): bool
-    {
-        return in_array($type, [
-            self::INT,
-            self::INTEGER,
-            self::STRING,
-            self::CHAR,
-            self::ANY,
-        ], true);
+        return match ($type) {
+            ValueType::OBJECT => is_object(value: $var),
+            ValueType::CALLABLE => is_callable(value: $var),
+            ValueType::ARRAY => is_array(value: $var),
+            KeyType::INT, KeyType::INTEGER, ValueType::INT, ValueType::INTEGER => is_int(value: $var),
+            KeyType::STRING, ValueType::STRING => is_string(value: $var),
+            KeyType::CHAR, ValueType::CHAR => is_string(value: $var) && (function_exists('mb_strlen') ? mb_strlen(string: $var) === 1 : strlen(string: $var) === 1),
+            ValueType::ENUM => is_object(value: $var) && enum_exists(enum: $var::class),
+            KeyType::ANY, ValueType::ANY => true,
+            default => $var instanceof $type,
+        };
     }
 
-    private function isValidValueType(string $type): bool
+    private function isValidValueType(object|string $type): bool
     {
-        if (class_exists($type)) {
+        if (is_string(value: $type) && class_exists(class: $type)) {
             return true;
         }
 
-        return in_array($type, [
-          self::OBJECT,
-          self::CALLABLE,
-          self::ARRAY,
-          self::INT,
-          self::INTEGER,
-          self::STRING,
-          self::CHAR,
-          self::ANY,
-        ], true);
+        return $type instanceof ValueType;
     }
 }

src/Olivebbs/Map/ImmutableMap.php

@@ -27,33 +27,35 @@
 
 namespace Olivebbs\Map;
 
+use Olivebbs\Map\Enum\KeyType;
+use Olivebbs\Map\Enum\ValueType;
 use Olivebbs\Map\Exception\ImmutableMapException;
 
 class ImmutableMap extends GenericMap
 {
     private function __construct(
-      ?string $keyType,
-      ?string $valueType,
+        KeyType $keyType,
+        object|string $valueType,
         array $values
     ) {
-        parent::__construct($keyType, $valueType);
+        parent::__construct(keyType: $keyType, valueType: $valueType);
 
-        $this->assertInitialValues($values);
-        $this->map->putAll($values);
+        $this->assertInitialValues(initialValues: $values);
+        $this->map->putAll(values: $values);
     }
 
-    public function offsetSet($offset, $value): void
+    public function offsetSet(mixed $offset, mixed $value): void
     {
-        throw new ImmutableMapException(sprintf('Cannot change values in %s', __CLASS__));
+        throw new ImmutableMapException(message: sprintf('Cannot change values in %s', __CLASS__));
     }
 
-    public function offsetUnset($offset): void
+    public function offsetUnset(mixed $offset): void
     {
-        throw new ImmutableMapException(sprintf('Cannot unset values in %s', __CLASS__));
+        throw new ImmutableMapException(message: sprintf('Cannot unset values in %s', __CLASS__));
     }
 
-    public static function create(string $keyType, string $valueType, array $values): ImmutableMap
+    public static function create(KeyType $keyType, ValueType $valueType, array $values): static
     {
-        return new self($keyType, $valueType, $values);
+        return new static(keyType: $keyType, valueType: $valueType, values: $values);
     }
 }

src/Olivebbs/Map/IntCharMap.php

@@ -27,20 +27,22 @@
 
 namespace Olivebbs\Map;
 
+use Olivebbs\Map\Enum\KeyType;
+use Olivebbs\Map\Enum\ValueType;
 use function str_split;
 
 class IntCharMap extends GenericMap
 {
     public function __construct(array $initialValues = [])
     {
-        parent::__construct(self::INT, self::CHAR);
+        parent::__construct(keyType:KeyType::INT, valueType: ValueType::CHAR);
 
-        $this->map->putAll($initialValues);
+        $this->map->putAll(values: $initialValues);
     }
 
-    public static function fromString(string $string): IntCharMap
+    public static function fromString(string $string): static
     {
-        $values = str_split($string);
-        return new self($values);
+        $values = str_split(string: $string);
+        return new static(initialValues: $values);
     }
 }

tests/GenericMapTest.php

@@ -27,10 +27,13 @@
 
 namespace Olivebbs\Tests\Map;
 
+use Olivebbs\Map\Enum\KeyType;
+use Olivebbs\Map\Enum\ValueType;
 use Olivebbs\Map\Exception\InvalidArgumentException;
 use Olivebbs\Map\GenericMap;
 use PHPUnit\Framework\TestCase;
-use ValueError;
+use SplObjectStorage;
+use stdClass;
 
 class GenericMapTest extends TestCase
 {
@@ -46,13 +49,13 @@ class GenericMapTest extends TestCase
     
     public function testHashMap(): void
     {
-        $genericHashMap = new GenericMap(GenericMap::INT, GenericMap::INT);
+        $genericHashMap = new GenericMap(KeyType::INT, ValueType::INT);
         foreach (range(0, 9) as $range) {
             $genericHashMap[$range] = $range;
         }
 
-        self::assertSame(GenericMap::INT, $this->genericMap->getKeyType());
-        self::assertSame(GenericMap::INT, $this->genericMap->getValueType());
+        self::assertSame(KeyType::INT, $this->genericMap->getKeyType());
+        self::assertSame(ValueType::INT, $this->genericMap->getValueType());
         self::assertCount(10, $this->genericMap);
         self::assertEquals(10, $this->genericMap->count());
         $array = array_combine(range(0, 9), range(0, 9));
@@ -64,15 +67,15 @@ class GenericMapTest extends TestCase
         unset($this->genericMap[1]);
         self::assertNull($this->genericMap[1]);
 
-        $this->expectException(\TypeError::class);
+        $this->expectException(InvalidArgumentException::class);
         $this->genericMap['H'] = 1;
     }
 
     public function testInvalidArgumentExceptionThrowsIsset(): void
     {
-        $genericHashMap = new GenericMap(GenericMap::ANY, GenericMap::ANY);
+        $genericHashMap = new GenericMap(KeyType::ANY, ValueType::ANY);
         $this->expectException(InvalidArgumentException::class);
-        $obj = new \stdClass();
+        $obj = new stdClass();
         /** @noinspection PhpExpressionResultUnusedInspection */
         isset($genericHashMap[$obj]);
     }
@@ -80,23 +83,17 @@ class GenericMapTest extends TestCase
     public function testTypeErrorThrowsIsset(): void
     {
         $genericMap = $this->getGenericMap();
-        $this->expectException(\TypeError::class);
+        $this->expectException(InvalidArgumentException::class);
 
         /** @noinspection PhpExpressionResultUnusedInspection */
         isset($genericMap['C']);
     }
-    public function testInvalidArgumentExceptionThrowsOnArrayOrObject(): void
-    {
-        $this->expectException(InvalidArgumentException::class);
-        $this->expectExceptionMessage('Invalid key type (array)');
-        $genericMap = new GenericMap(GenericMap::ARRAY, GenericMap::ARRAY);
-    }
 
     public function testOffsetGetThrowsInvalidArgumentException(): void
     {
         $genericMap = $this->getGenericMap();
         $this->expectException(InvalidArgumentException::class);
-        $obj = new \stdClass();
+        $obj = new stdClass();
         $test = $genericMap[$obj];
     }
 
@@ -104,7 +101,7 @@ class GenericMapTest extends TestCase
     {
         $genericMap = $this->getGenericMap();
         $this->expectException(InvalidArgumentException::class);
-        $obj = new \stdClass();
+        $obj = new stdClass();
         $genericMap[$obj] = 1;
     }
 
@@ -112,14 +109,14 @@ class GenericMapTest extends TestCase
     {
         $genericMap = $this->getGenericMap();
         $this->expectException(InvalidArgumentException::class);
-        $obj = new \stdClass();
+        $obj = new stdClass();
         unset($genericMap[$obj]);
     }
 
     public function testOffsetSetThrowsValueErrorException(): void
     {
         $genericMap = $this->getGenericMap();
-        $this->expectException(ValueError::class);
+        $this->expectException(InvalidArgumentException::class);
 
         $genericMap[0] = 'string';
     }
@@ -128,7 +125,7 @@ class GenericMapTest extends TestCase
     {
         $this->resetGenericMap();
 
-        $this->expectException(\TypeError::class);
+        $this->expectException(InvalidArgumentException::class);
 
         unset($this->genericMap['C']);
     }
@@ -136,7 +133,7 @@ class GenericMapTest extends TestCase
     public function testOffsetGetThrowsTypeErrorException(): void
     {
         $this->resetGenericMap();
-        $this->expectException(\TypeError::class);
+        $this->expectException(InvalidArgumentException::class);
 
         $test = $this->genericMap['C'];
     }
@@ -144,14 +141,14 @@ class GenericMapTest extends TestCase
     public function testThrowInvalidArgumentExceptionOnConstructValue(): void
     {
         $this->expectException(InvalidArgumentException::class);
-        $genericMap = new GenericMap(GenericMap::CHAR, 'test');
+        $genericMap = new GenericMap(KeyType::CHAR, 'test');
     }
 
     public function testUsingClassAsValue(): void
     {
-        $genericMap = new GenericMap(GenericMap::INT, \SplObjectStorage::class);
-        $splObject = new \SplObjectStorage();
-        $stdClass = new \stdClass();
+        $genericMap = new GenericMap(KeyType::INT, SplObjectStorage::class);
+        $splObject = new SplObjectStorage();
+        $stdClass = new stdClass();
         $splObject->attach($stdClass);
         $genericMap[0] = $splObject;
         self::assertSame($splObject, $genericMap[0]);
@@ -160,13 +157,29 @@ class GenericMapTest extends TestCase
 
     public function testObjectCantBeUsedAsKeyWithAny(): void
     {
-        $genericMap = new GenericMap(GenericMap::ANY, GenericMap::ANY);
-        $object = new \SplObjectStorage();
+        $genericMap = new GenericMap(KeyType::ANY, ValueType::ANY);
+        $object = new SplObjectStorage();
         $this->expectException(InvalidArgumentException::class);
         $this->expectExceptionMessage('Map keys cannot be objects or arrays');
         $genericMap[$object] = 1;
     }
 
+    public function testEnumMap(): void
+    {
+        $enumMap = new class(TestEnum::cases()) extends GenericMap {
+            public function __construct(array $values = [])
+            {
+                parent::__construct(KeyType::INT, ValueType::ENUM);
+                $this->assertInitialValues($values);
+                $this->map->putAll($values);
+            }
+        };
+
+        self::assertCount(8, $enumMap->toArray());
+        self::assertSame(TestEnum::a, $enumMap[0]);
+        self::assertSame(TestEnum::h, $enumMap[7]);
+    }
+
     private function resetGenericMap(): void
     {
         $this->genericMap = $this->getGenericMap();
@@ -174,6 +187,6 @@ class GenericMapTest extends TestCase
 
     private function getGenericMap(): GenericMap
     {
-        return new GenericMap(GenericMap::INT, GenericMap::INT);
+        return new GenericMap(KeyType::INT, ValueType::INT);
     }
 }

tests/ImmutableMapTest.php

@@ -27,9 +27,10 @@
 
 namespace Olivebbs\Tests\Map;
 
+use Olivebbs\Map\Enum\KeyType;
+use Olivebbs\Map\Enum\ValueType;
 use Olivebbs\Map\Exception\ImmutableMapException;
 use Olivebbs\Map\Exception\InvalidArgumentException;
-use Olivebbs\Map\GenericMap;
 use Olivebbs\Map\ImmutableMap;
 use PHPUnit\Framework\TestCase;
 
@@ -37,14 +38,14 @@ class ImmutableMapTest extends TestCase
 {
     public function testOffsetUnset(): void
     {
-        $immutableMap = ImmutableMap::create(GenericMap::INTEGER, GenericMap::CHAR, range('A', 'Z'));
+        $immutableMap = ImmutableMap::create(KeyType::INTEGER, ValueType::CHAR, range('A', 'Z'));
         $this->expectException(ImmutableMapException::class);
         unset($immutableMap[0]);
     }
 
     public function testOffsetSet(): void
     {
-        $immutableMap = ImmutableMap::create(GenericMap::INTEGER, GenericMap::CHAR, range('A', 'Z'));
+        $immutableMap = ImmutableMap::create(KeyType::INTEGER, ValueType::CHAR, range('A', 'Z'));
         $this->expectException(ImmutableMapException::class);
         $immutableMap[0] = 1;
     }
@@ -58,6 +59,6 @@ class ImmutableMapTest extends TestCase
         ];
         $this->expectException(InvalidArgumentException::class);
         $this->expectExceptionMessage('Invalid types for map [string => int], they should be [int => string]');
-        $immutableMap = ImmutableMap::create(GenericMap::INT, GenericMap::STRING, $values);
+        $immutableMap = ImmutableMap::create(KeyType::INT, ValueType::STRING, $values);
     }
 }

tests/TestEnum.php

@@ -0,0 +1,40 @@
+<?php declare(strict_types=1);
+
+/*
+ * Copyright (c) 2020  https://rewiv.com sikofitt@gmail.com
+ *
+ * This file is a part of Olive BBS
+ *
+ * This Source Code Form is subject to the
+ * terms of the Mozilla Public License, v. 2.0.
+ *
+ * If a copy of the MPL was not distributed with this file,
+ * You can obtain one at https://mozilla.org/MPL/2.0/.
+ *
+ *         ___                   ___    ___
+ *        (   ).-.              (   )  (   )
+ *    .--. | |( __)___  ___ .--. | |.-. | |.-.     .--.
+ *   /    \| |(''"(   )(   /    \| /   \| /   \  /  _  \
+ *  |  .-. | | | | | |  | |  .-. |  .-. |  .-. |. .' `. ;
+ *  | |  | | | | | | |  | |  | | | |  | | |  | || '   | |
+ *  | |  | | | | | | |  | |  |/  | |  | | |  | |_\_`.(___)
+ *  | |  | | | | | | |  | |  ' _.| |  | | |  | (   ). '.
+ *  | '  | | | | | ' '  ; |  .'.-| '  | | '  | || |  `\ |
+ *  '  `-' | | | |  \ `' /'  `-' ' `-' ;' `-' ; ; '._,' '
+ *   `.__.(___(___)  '_.'  `.__.' `.__.  `.__.   '.___.'
+ *
+ */
+
+namespace Olivebbs\Tests\Map;
+
+enum TestEnum
+{
+    case a;
+    case b;
+    case c;
+    case d;
+    case e;
+    case f;
+    case g;
+    case h;
+}