v3.0.0 tests

Author: s3b4stian

.github/workflows/tests.yml

@@ -13,7 +13,7 @@ jobs:
     strategy:
       fail-fast: true
       matrix:
-        php: [7.4, 8.0]
+        php: [8.0, 8.1]
 
     name: PHP ${{ matrix.php }}
 

.gitignore

@@ -3,4 +3,5 @@ composer.lock
 clover.xml
 infection-log.txt
 vendor/
+.php-cs-fixer.cache
 .phpunit.result.cache

.php-cs-fixer.php

@@ -0,0 +1,15 @@
+<?php
+
+$config = new PhpCsFixer\Config();
+return $config
+    ->setRiskyAllowed(true)
+    ->setRules([
+        '@PSR12' => true,
+        'no_whitespace_in_blank_line' => true,
+        'return_type_declaration' => true,
+        'native_function_invocation' => ['include' => ['@all']],
+    ])
+    ->setFinder(PhpCsFixer\Finder::create()
+        ->exclude('vendor')
+        ->in(__DIR__)
+    );

.scrutinizer.yml

@@ -14,7 +14,7 @@ tools:
 
 build:
     environment:
-       php: 8.0
+       php: 8.1
     tests:
             override:
                 -

CHANGELOG.md

@@ -6,18 +6,18 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](http://keepachangelog.com/) 
 and this project adheres to [Semantic Versioning](http://semver.org/).
 
-## [v3.0.0](https://github.com/linna/typed-array/compare/v2.0.1...v3.0.0) - 2020-XX-XX
+## [v3.0.0](https://github.com/linna/typed-array/compare/v2.0.1...v3.0.0) - 2022-05-11
 
 ### Added
 - php 8.0 support
-- `ArrayArrayObject` class
-- `BoolArrayObject` class
-- `CallableArrayObject` class
-- `ClassArrayObject` class
-- `FloatArrayObject` class
-- `IntArrayObject` class
-- `ObjectArrayObject` class
-- `StringArrayObject` class
+- `ArrayOfArrays` class
+- `ArrayOfBooleans` class
+- `ArrayOfCallable` class
+- `ArrayOfClasses` class
+- `ArrayOfFloats` class
+- `ArrayOfIntegers` class
+- `ArrayOfObjects` class
+- `ArrayOfStrings` class
 
 ### Changed
 - namespace from `Linna` to `Linna\TypedArrayObject`

README.md

@@ -35,23 +35,23 @@ composer require linna/typed-array
 
 | Name                  | Native Type Handled | Description                                          |
 |-----------------------|---------------------|------------------------------------------------------|
-| `ArrayArrayObject`    | array               |                                                      |
-| `BoolArrayObject`     | bool                |                                                      |
-| `CallableArrayObject` | callable            |                                                      |
-| `ClassArrayObject`    | any existing class  | passed as first argument in constructor as `::class` |
-| `FloatArrayObject`    | float               |                                                      |
-| `IntArrayObject`      | int                 |                                                      |
-| `ObjectArrayObject`   | object              |                                                      |
-| `StringArrayObject`   | string              |                                                      |
+| `ArrayOfArrays`       | array               |                                                      |
+| `ArrayOfBooleans`     | bool                |                                                      |
+| `ArrayOfCallable`     | callable            |                                                      |
+| `ArrayOfClasses`      | any existing class  | passed as first argument in constructor as `::class` |
+| `ArrayOfFloats`       | float               |                                                      |
+| `ArrayOfIntegers`     | int                 |                                                      |
+| `ArrayOfObjects`      | object              |                                                      |
+| `ArrayOfStrings`      | string              |                                                      |
 
 
 ## Usage
 ```php
-use Linna\TypedArrayObject\IntArrayObject;
-use Linna\TypedArrayObject\ClassArrayObject;
+use Linna\TypedArrayObject\ArrayOfIntegers;
+use Linna\TypedArrayObject\ArrayOfClasses;
 
 //correct, only int passed to constructor.
-$intArray = new IntArrayObject([1, 2, 3, 4]);
+$intArray = new ArrayOfIntegers([1, 2, 3, 4]);
 
 //correct, int assigned
 $intArray[] = 5;
@@ -64,10 +64,10 @@ $intArray->append(5);
 $intArray->append('a');
 
 //throw InvalidArgumentException, mixed array passed to constructor.
-$otherIntArray = new IntArrayObject([1, 'a', 3, 4]);
+$otherIntArray = new ArrayOfIntegers([1, 'a', 3, 4]);
 
 //correct, only Foo class instances passed to constructor.
-$fooArray = new ClassArrayObject(Foo::class, [
+$fooArray = new ArrayOfClasses(Foo::class, [
     new Foo(),
     new Foo()
 ]);
@@ -83,7 +83,7 @@ $fooArray->append(new Foo());
 $fooArray->append(new Bar());
 
 //throw InvalidArgumentException, mixed array of instances passed to constructor.
-$otherFooArray = new ClassArrayObject(Foo::class, [
+$otherFooArray = new ArrayOfClasses(Foo::class, [
     new Foo(),
     new Bar()
 ]);
@@ -92,7 +92,7 @@ $otherFooArray = new ClassArrayObject(Foo::class, [
 > **Note:** Allowed types are: *array*, *bool*, *callable*, *float*, *int*, *object*, *string* and all existing classes.
 
 ## Performance consideration for v3.0
-Compared to previous versions of the library, this version is a bit faster because every types has it own class.
+Compared to previous versions of the library, this version is a bit faster because every types has it own class. Do milliseconds really matters?
 
 ![Array Speed Test](array-speed-test-v3.png)
 

array-speed-test-v3.png

@@ -15,7 +15,7 @@
         "issues": "https://github.com/linna/typed-array/issues"
     },
     "require": {
-        "php": ">=7.4"
+        "php": ">=8.0"
     },
     "require-dev": {
         "infection/infection": "^0.21",
@@ -29,7 +29,12 @@
     },
     "autoload-dev": {
         "psr-4": {
-            "Linna\\Tests\\": "tests/"
+            "Linna\\": "tests/Linna"
+        }
+    },
+    "config": {
+        "allow-plugins": {
+            "infection/extension-installer": true
         }
     }
 }

composer.json

@@ -17,33 +17,33 @@
 /**
  * Provide a way to create an array of string typed elements with php.
  */
-class StringArrayObject extends ArrayObject
+class AbstractArray extends ArrayObject
 {
-    public const EXC_MESSAGE = 'Elements passed must be of the type <string>.';
+    protected string $exceptionMessage;
+    protected string $func;
 
     /**
      * Class Contructor.
      *
-     * @param array  $input
-     * @param int    $flags
-     * @param string $iterator_class
+     * @param string        $func               function to check the array values
+     * @param array<mixed>  $input              array of values
+     * @param int           $flags              see array object on php site
+     * @param string        $iterator_class     see array object on php site
      *
      * @throws InvalidArgumentException If elements in the optional array parameter
      *                                  aren't of the configured type.
      */
-    public function __construct(array $input = [], int $flags = 0, string $iterator_class = "ArrayIterator")
+    public function __construct(string $func, array $input = [], int $flags = 0, string $iterator_class = "ArrayIterator")
     {
-        //get input array len
-        $count = \count($input);
         //check for invalid values inside provided array
-        //for is simple than previosu solution
-        for ($i = 0; $i < $count; $i++) {
-            if (\is_string($input[$i])) {
-                continue;
-            }
-            throw new InvalidArgumentException(self::EXC_MESSAGE);
+        //array_map returns an array of trues or false
+        //product of all trues return 1, only one false make result 0
+        if (!\array_product(\array_map($func, $input))) {
+            throw new InvalidArgumentException($this->exceptionMessage);
         }
 
+        $this->func = $func;
+
         //call parent constructor
         parent::__construct($input, $flags, $iterator_class);
     }
@@ -62,13 +62,11 @@ public function __construct(array $input = [], int $flags = 0, string $iterator_
      */
     public function offsetSet($index, $newval): void
     {
-        if (\is_string($newval)) {
-            parent::offsetSet($index, $newval);
-
-            return;
+        if (!($this->func)($newval)) {
+            throw new InvalidArgumentException($this->exceptionMessage);
         }
 
-        throw new InvalidArgumentException(self::EXC_MESSAGE);
+        parent::offsetSet($index, $newval);
     }
 
     /**
@@ -81,12 +79,10 @@ public function offsetSet($index, $newval): void
      */
     public function append($value): void
     {
-        if (\is_string($value)) {
-            parent::append($value);
-
-            return;
+        if (!($this->func)($value)) {
+            throw new InvalidArgumentException($this->exceptionMessage);
         }
 
-        throw new InvalidArgumentException(self::EXC_MESSAGE);
+        parent::append($value);
     }
 }