Merge pull request #18 from linna/b3.0.0

B3.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: 7.1
+       php: 8.1
     tests:
             override:
                 -

.travis.yml

@@ -6,15 +6,39 @@ 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/).
 
-## [v2.0.1](https://github.com/linna/typed-array/compare/v2.0.0...v2.0.1) - 2019-03-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
+- `ArrayOfArrays` class
+- `ArrayOfBooleans` class
+- `ArrayOfCallable` class
+- `ArrayOfClasses` class
+- `ArrayOfFloats` class
+- `ArrayOfIntegers` class
+- `ArrayOfObjects` class
+- `ArrayOfStrings` class
+
+### Changed
+- namespace from `Linna` to `Linna\TypedArrayObject`
+- type chek is performed als on method `ArrayObject->append()`
+
+### removed
+- `Linna\TypedArray` class
+
+## [v2.0.1](https://github.com/linna/typed-array/compare/v2.0.0...v2.0.1) - 2020-03-23
 
 ### Added
 - php 7.3 support
+- php 7.4 support
 
 ### Changed
 - `.scrutinizer.yml` updated for use phpunit from `vendor` directory
 - Merge pull request #14 from peter279k/enhance_stuffs with code enhancements
 
+### Removed
+- Travis CI usage for test build.
+
 ## [v2.0.0](https://github.com/linna/typed-array/compare/v1.0.5...v2.0.0) - 2018-08-13
 
 ### Changed

CHANGELOG.md

@@ -12,7 +12,7 @@
 
 <div align="center">
 
-[![Build Status](https://travis-ci.org/linna/typed-array.svg?branch=master)](https://travis-ci.org/linna/typed-array)
+[![Tests](https://github.com/linna/typed-array/actions/workflows/tests.yml/badge.svg)](https://github.com/linna/typed-array/actions/workflows/tests.yml)
 [![Scrutinizer Code Quality](https://scrutinizer-ci.com/g/linna/typed-array/badges/quality-score.png?b=master)](https://scrutinizer-ci.com/g/linna/typed-array/?branch=master)
 [![Code Coverage](https://scrutinizer-ci.com/g/linna/typed-array/badges/coverage.png?b=master)](https://scrutinizer-ci.com/g/linna/typed-array/?branch=master)
 [![StyleCI](https://styleci.io/repos/93407083/shield?branch=master&style=flat)](https://styleci.io/repos/93407083)
@@ -23,58 +23,86 @@
 This package provide typed arrays for php as extension of native [ArrayObject](http://php.net/manual/en/class.arrayobject.php).  
 
 ## Requirements
-This package require php 7.1
+This package require php 8.0
 
 ## Installation
 With composer:
 ```
 composer require linna/typed-array
 ```
 
+## Classes
+
+| Name                  | Native Type Handled | Description                                          |
+|-----------------------|---------------------|------------------------------------------------------|
+| `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\TypedArray;
+use Linna\TypedArrayObject\ArrayOfIntegers;
+use Linna\TypedArrayObject\ArrayOfClasses;
 
 //correct, only int passed to constructor.
-$intArray = new TypedArray('int', [1, 2, 3, 4]);
+$intArray = new ArrayOfIntegers([1, 2, 3, 4]);
 
 //correct, int assigned
 $intArray[] = 5;
-
-//throw InvalidArgumentException, string assigned.
+//throw InvalidArgumentException, string assigned, int expected.
 $intArray[] = 'a';
 
+//correct, int used
+$intArray->append(5);
+//throw InvalidArgumentException, string used, int expected.
+$intArray->append('a');
+
 //throw InvalidArgumentException, mixed array passed to constructor.
-$otherIntArray = new TypedArray('int', [1, 'a', 3, 4]);
+$otherIntArray = new ArrayOfIntegers([1, 'a', 3, 4]);
 
 //correct, only Foo class instances passed to constructor.
-$fooArray = new TypedArray(Foo::class, [
+$fooArray = new ArrayOfClasses(Foo::class, [
     new Foo(),
     new Foo()
 ]);
 
 //correct, Foo() instance assigned.
 $fooArray[] = new Foo();
-
 //throw InvalidArgumentException, Bar() instance assigned.
 $fooArray[] = new Bar();
 
+//correct, Foo() instance used.
+$fooArray->append(new Foo());
+//throw InvalidArgumentException, Bar() instance used, Foo() instance expected.
+$fooArray->append(new Bar());
+
 //throw InvalidArgumentException, mixed array of instances passed to constructor.
-$otherFooArray = new TypedArray(Foo::class, [
+$otherFooArray = new ArrayOfClasses(Foo::class, [
     new Foo(),
     new Bar()
 ]);
 ```
 
 > **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. Do milliseconds really matters?
+
+![Array Speed Test](array-speed-test-v3.png)
+
 ## Performance consideration for v2.0
 Compared to first version of the library, this version is a bit slower because after merging `TypedObjectArray` with `TypedArray`,
 there are more code that be executed when new instance is created and on assign operations.
 
 ![Array Speed Test](array-speed-test-v2.png)
 
-## Performance consideration
+## Performance consideration for v1.0
 Compared to the parent class [ArrayObject](http://php.net/manual/en/class.arrayobject.php) typed arrays are slower on writing
 approximately from 6x to 8x. The slowness is due to not native `__construct()` and not native `offsetSet()`.  
 Other operations do not have a speed difference with the native ArrayObject.

README.md

@@ -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
         }
     }
 }

array-speed-test-v3.png

@@ -17,28 +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")
     {
-        //to avoid foreach, compare sizes of array
-        //before and after apply a filter :)
-        if (\count($input) > \count(\array_filter($input, 'is_string'))) {
-            throw new InvalidArgumentException(self::EXC_MESSAGE);
+        //check for invalid values inside provided array
+        //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);
     }
@@ -57,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);
     }
 
     /**
@@ -76,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);
     }
 }