Merge branch '1.x' into 'master'

1.x

See merge request olive/PHP/map!4

.gitignore

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

README.md

@@ -2,21 +2,18 @@
 
 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(KeyType::STRING, ValueType::STRING);
+        parent::__construct(GenericMap::STRING, GenericMap::STRING);
         $this->map->putAll($values);
     }
 }
@@ -26,10 +23,8 @@ or
 
 ```php
 use Olivebbs\Map\GenericMap;
-use Olivebbs\Map\Enum\ValueType;
-use Olivebbs\Map\Enum\KeyType;
 
-$myIntMap = new GenericMap(KeyType::INT, ValueType::INT); 
+$myIntMap = new GenericMap(GenericMap::INT, GenericMap::INT); 
 ```
 Then use it.
 ```php 

composer.json

@@ -2,13 +2,12 @@
     "name": "olive/map",
     "description": "Generic map for PHP",
     "type": "library",
-    "keywords": ["map", "hashmap", "hash-map", "data", "data structure", "array", "arrayaccess"],
     "require": {
         "php": ">=8.1",
         "php-ds/php-ds": "^1.4"
     },
     "require-dev": {
-        "friendsofphp/php-cs-fixer": "^3.13",
+        "friendsofphp/php-cs-fixer": "^3.8",
         "phpunit/phpunit": "^9.5"
     },
     "license": "MPL-2.0",

src/Olivebbs/Map/CharMap.php

@@ -28,15 +28,13 @@
 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(keyType: KeyType::CHAR, valueType: ValueType::CHAR);
+        parent::__construct(keyType: self::CHAR, valueType: self::CHAR);
 
         $this->map->putAll(values: $initialValues);
     }

src/Olivebbs/Map/Enum/KeyType.php

@@ -1,37 +0,0 @@
-<?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

@@ -1,41 +0,0 @@
-<?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

@@ -32,42 +32,56 @@ use function class_exists;
 use Countable;
 use Ds\Map;
 use function enum_exists;
+use function in_array;
 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 sprintf;
+use function strtolower;
+use TypeError;
+use ValueError;
 
 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 ENUM = 'enum';
+    public const ANY = 'any';
+
     protected Map $map;
 
-    private readonly string $valueTypeValue;
-    private readonly string $keyTypeValue;
-
-    public function __construct(protected KeyType $keyType = KeyType::ANY, protected object|string $valueType = ValueType::ANY)
+    public function __construct(protected string $keyType = self::ANY, protected string $valueType = self::ANY)
     {
-        $this->keyTypeValue = $this->keyType->value;
-        $this->valueTypeValue = is_string(value: $this->valueType) ? $this->valueType : $this->valueType->value;
+        $this->keyType = strtolower(string: $keyType);
+
+        $this->valueType = class_exists(class: $valueType) ? $valueType : strtolower(string: $valueType);
+
+        if (!$this->isValidKeyType(type: $this->keyType)) {
+            throw new InvalidArgumentException(message: sprintf('Invalid key type (%s)', $this->keyType));
+        }
 
         if (!$this->isValidValueType(type: $this->valueType)) {
-            throw new InvalidArgumentException(message: sprintf('Invalid value type (%s)', $this->valueTypeValue));
+            throw new InvalidArgumentException(message: sprintf('Invalid value type (%s)', $this->valueType));
         }
 
         $this->map = new Map();
     }
 
-    public function getKeyType(): KeyType
+    public function getKeyType(): string
     {
         return $this->keyType;
     }
 
-    public function getValueType(): object|string
+    public function getValueType(): string
     {
         return $this->valueType;
     }
@@ -101,7 +115,7 @@ class GenericMap implements ArrayAccess, Countable
      */
     public function offsetSet(mixed $offset, mixed $value): void
     {
-        $this->checkTypes(offset: $offset, value: $value);
+        $this->checkTypes($offset, $value);
 
         $this->map->offsetSet(offset: $offset, value: $value);
     }
@@ -138,8 +152,8 @@ class GenericMap implements ArrayAccess, Countable
     protected function assertInitialValues(array $initialValues): bool
     {
         foreach ($initialValues as $key => $value) {
-            if (!$this->checkType($this->keyType, $key) || !$this->checkType($this->valueType, $value)) {
-                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));
+            if (!$this->checkType(type: $this->keyType, var: $key) || !$this->checkType(type: $this->valueType, var: $value)) {
+                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, $this->valueType));
             }
         }
         
@@ -153,42 +167,63 @@ class GenericMap implements ArrayAccess, Countable
         }
 
         if (!$this->checkType(type: $this->keyType, var: $offset)) {
-            throw new InvalidArgumentException(message: sprintf('Key should be of value %s.', $this->keyTypeValue));
+            throw new TypeError(message: sprintf('Key should be of value %s.', $this->keyType));
         }
 
         if (null !== $value && !$this->checkType(type: $this->valueType, var: $value)) {
-            throw new InvalidArgumentException(message: sprintf('Value should be of type %s.', $this->valueTypeValue));
+            throw new ValueError(message: sprintf('Value should be of type %s.', $this->valueType));
         }
     }
 
     /**
      * @codeCoverageIgnore
-     * @param KeyType|ValueType|string $type
+     * @param string $type
      * @param mixed  $var
      *
      * @return bool
      */
-    private function checkType(KeyType|ValueType|string $type, mixed $var): bool
+    private function checkType(string $type, mixed $var): bool
     {
         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,
+            self::OBJECT => is_object(value: $var),
+            self::CALLABLE => is_callable(value: $var),
+            self::ARRAY => is_array(value: $var),
+            self::INT, self::INTEGER => is_int(value: $var),
+            self::STRING => is_string(value: $var),
+            self::CHAR => is_string(value: $var) && (function_exists('mb_strlen') ? mb_strlen(string: $var) === 1 : strlen(string: $var) === 1),
+            self::ENUM => is_object(value: $var) && enum_exists(enum: $var::class),
+            self::ANY => true,
             default => $var instanceof $type,
         };
     }
 
-    private function isValidValueType(object|string $type): bool
+    private function isValidKeyType(string $type): bool
     {
-        if (is_string(value: $type) && class_exists(class: $type)) {
+        return in_array(needle: $type, haystack: [
+            self::INT,
+            self::INTEGER,
+            self::STRING,
+            self::CHAR,
+            self::ANY,
+        ], strict: true);
+    }
+
+    private function isValidValueType(string $type): bool
+    {
+        if (class_exists(class: $type)) {
             return true;
         }
 
-        return $type instanceof ValueType;
+        return in_array(needle: $type, haystack: [
+          self::OBJECT,
+          self::CALLABLE,
+          self::ARRAY,
+          self::INT,
+          self::INTEGER,
+          self::STRING,
+          self::CHAR,
+          self::ENUM,
+          self::ANY,
+        ], strict: true);
     }
 }

src/Olivebbs/Map/ImmutableMap.php

@@ -27,15 +27,13 @@
 
 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(
-        KeyType $keyType,
-        object|string $valueType,
+        string $keyType,
+        string $valueType,
         array $values
     ) {
         parent::__construct(keyType: $keyType, valueType: $valueType);
@@ -54,7 +52,7 @@ class ImmutableMap extends GenericMap
         throw new ImmutableMapException(message: sprintf('Cannot unset values in %s', __CLASS__));
     }
 
-    public static function create(KeyType $keyType, ValueType $valueType, array $values): static
+    public static function create(string $keyType, string $valueType, array $values): static
     {
         return new static(keyType: $keyType, valueType: $valueType, values: $values);
     }

src/Olivebbs/Map/IntCharMap.php

@@ -27,15 +27,13 @@
 
 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(keyType:KeyType::INT, valueType: ValueType::CHAR);
+        parent::__construct(keyType: self::INT, valueType: self::CHAR);
 
         $this->map->putAll(values: $initialValues);
     }

tests/GenericMapTest.php

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

tests/ImmutableMapTest.php

@@ -27,10 +27,9 @@
 
 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;
 
@@ -38,14 +37,14 @@ class ImmutableMapTest extends TestCase
 {
     public function testOffsetUnset(): void
     {
-        $immutableMap = ImmutableMap::create(KeyType::INTEGER, ValueType::CHAR, range('A', 'Z'));
+        $immutableMap = ImmutableMap::create(GenericMap::INTEGER, GenericMap::CHAR, range('A', 'Z'));
         $this->expectException(ImmutableMapException::class);
         unset($immutableMap[0]);
     }
 
     public function testOffsetSet(): void
     {
-        $immutableMap = ImmutableMap::create(KeyType::INTEGER, ValueType::CHAR, range('A', 'Z'));
+        $immutableMap = ImmutableMap::create(GenericMap::INTEGER, GenericMap::CHAR, range('A', 'Z'));
         $this->expectException(ImmutableMapException::class);
         $immutableMap[0] = 1;
     }
@@ -59,6 +58,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(KeyType::INT, ValueType::STRING, $values);
+        $immutableMap = ImmutableMap::create(GenericMap::INT, GenericMap::STRING, $values);
     }
 }