Php 8.0 compatibility

.github/workflows/php.yml

@@ -15,7 +15,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        php-versions: ['7.1', '7.2', '7.3', '7.4']
+        php-versions: ['7.3', '7.4', '8.0']
     name: Testing with PHP ${{ matrix.php-versions }}
 
     steps:

composer.json

@@ -3,7 +3,7 @@
   "description": "Collections library for php language",
   "minimum-stability": "dev",
   "license": "MIT",
-  "version": "1.0.9",
+  "version": "1.1.7",
   "authors": [
     {
       "name": "Maxim Sokolovsky",
@@ -19,11 +19,11 @@
     }
   ],
   "require": {
-    "php": ">=7.1",
+    "php": "^7.3 || ~8.0",
     "ext-json": "*"
   },
   "require-dev": {
-    "phpunit/phpunit": "^7.5"
+    "phpunit/phpunit": "^9.5"
   },
   "suggest": {
     "phpbench/phpbench": "Uses only for benchmark purposes"

src/WS/Utils/Collections/CollectionFactory.php

@@ -5,7 +5,10 @@
 
 namespace WS\Utils\Collections;
 
+use Iterator;
+use IteratorAggregate;
 use RuntimeException;
+use WS\Utils\Collections\Exception\UnsupportedException;
 
 class CollectionFactory
 {
@@ -37,7 +40,7 @@ public static function generate(int $times, ?callable $generator = null): Collec
     /**
      * Generate collection of int numbers between $from and $to. If $to arg is absent $from - is count of numbers
      * @param int $from
-     * @param int $to
+     * @param int|null $to
      * @return Collection
      */
     public static function numbers(int $from, ?int $to = null): Collection
@@ -68,11 +71,25 @@ public static function fromStrict(array $values): Collection
         return new ArrayStrictList($values);
     }
 
+    /**
+     * @throws UnsupportedException
+     */
     public static function fromIterable(iterable $iterable): Collection
     {
         $list = ArrayList::of();
+        $count = 0;
+        $lastItem = null;
+
         foreach ($iterable as $item) {
+            if ($count <= 1) {
+                $isObject = is_object($item);
+                if ($item === $lastItem && $isObject) {
+                    return self::createIterableCollection($iterable);
+                }
+                $lastItem = $item;
+            }
             $list->add($item);
+            $count++;
         }
 
         return $list;
@@ -82,4 +99,16 @@ public static function empty(): Collection
     {
         return ArrayList::of();
     }
+
+    private static function createIterableCollection(iterable $iterable): IteratorCollection
+    {
+        if ($iterable instanceof IteratorAggregate) {
+            /** @noinspection PhpUnhandledExceptionInspection */
+            $iterable = $iterable->getIterator();
+        }
+        if (!$iterable instanceof Iterator) {
+            throw new UnsupportedException('Only Iterator interface can be applied to IteratorCollection');
+        }
+        return new IteratorCollection($iterable);
+    }
 }

src/WS/Utils/Collections/Exception/UnsupportedException.php

@@ -0,0 +1,9 @@
+<?php
+
+namespace WS\Utils\Collections\Exception;
+
+use RuntimeException;
+
+class UnsupportedException extends RuntimeException
+{
+}

src/WS/Utils/Collections/Functions/Reorganizers.php

@@ -90,23 +90,14 @@ public static function random(int $count = 1): Closure
     public static function chunk(int $size): Closure
     {
         return static function (Collection $collection) use ($size): Collection {
-            $chunkCollection = self::collectionConstructor();
-            $currentChunk = self::collectionConstructor();
-            $pointer = $size;
-            $collection
-                ->stream()
-                ->each(static function ($el) use ($size, $chunkCollection, & $currentChunk, & $pointer) {
-                    $pointer--;
-                    $currentChunk->add($el);
-
-                    if ($pointer === 0) {
-                        $chunkCollection->add($currentChunk);
-                        $currentChunk = self::collectionConstructor();
-                        $pointer = $size;
-                    }
-                })
-            ;
-            return $chunkCollection;
+            $array = $collection->toArray();
+            $chunkedArray = array_chunk($array, $size);
+            $result = self::collectionConstructor();
+            foreach ($chunkedArray as $items) {
+                $result->add(self::collectionConstructor($items));
+            };
+
+            return $result;
         };
     }
 

src/WS/Utils/Collections/IteratorCollection.php

@@ -0,0 +1,135 @@
+<?php
+
+namespace WS\Utils\Collections;
+
+use Iterator;
+use WS\Utils\Collections\Exception\UnsupportedException;
+
+/**
+ * Collection which support Traversable interface
+ */
+class IteratorCollection implements Collection
+{
+
+    /**
+     * @var Iterator
+     */
+    private $iterator;
+
+    public function __construct(Iterator $iterator)
+    {
+        $this->iterator = $iterator;
+    }
+
+    /**
+     * @throws UnsupportedException
+     * @codeCoverageIgnore
+     */
+    public function add($element): bool
+    {
+        throw new UnsupportedException();
+    }
+
+    /**
+     * @throws UnsupportedException
+     * @codeCoverageIgnore
+     */
+    public function addAll(iterable $elements): bool
+    {
+        throw new UnsupportedException();
+    }
+
+    /**
+     * @throws UnsupportedException
+     * @codeCoverageIgnore
+     */
+    public function merge(Collection $collection): bool
+    {
+        throw new UnsupportedException();
+    }
+
+    /**
+     * @throws UnsupportedException
+     * @codeCoverageIgnore
+     */
+    public function clear(): void
+    {
+        throw new UnsupportedException();
+    }
+
+    /**
+     * @throws UnsupportedException
+     * @codeCoverageIgnore
+     */
+    public function remove($element): bool
+    {
+        throw new UnsupportedException();
+    }
+
+    /**
+     * @throws UnsupportedException
+     * @codeCoverageIgnore
+     */
+    public function contains($element): bool
+    {
+        throw new UnsupportedException();
+    }
+
+    /**
+     * @throws UnsupportedException
+     * @codeCoverageIgnore
+     */
+    public function equals(Collection $collection): bool
+    {
+        throw new UnsupportedException();
+    }
+
+    public function size(): int
+    {
+        $this->iterator->rewind();
+        $count = 0;
+        while ($this->iterator->valid()) {
+            $this->iterator->next();
+            $count++;
+        }
+
+        return $count;
+    }
+
+    /**
+     * @codeCoverageIgnore
+     * @return bool
+     */
+    public function isEmpty(): bool
+    {
+        return $this->size() === 0;
+    }
+
+    public function stream(): Stream
+    {
+        return new IteratorStream($this);
+    }
+
+    /**
+     * @codeCoverageIgnore
+     * @return array
+     */
+    public function toArray(): array
+    {
+        throw new UnsupportedException();
+    }
+
+    /**
+     * @codeCoverageIgnore
+     * @return Collection
+     */
+    public function copy(): Collection
+    {
+        throw new UnsupportedException();
+    }
+
+    public function getIterator()
+    {
+        return $this->iterator;
+    }
+}