Yiisoft\Arrays\Collection\ArrayCollection

Complexity

Total Complexity

45

Size/Duplication

Total Lines	243
Duplicated Lines	0 %

Importance

Changes	4
Bugs	0	Features	0

18 Methods

Rating	Name	Duplication	Size	Complexity
A	offsetSet()	0	3	1
A	isMergable()	0	3	2
A	withModifiers()	0	5	1
A	__construct()	0	4	2
A	withAddedModifier()	0	3	1
B	mergeWith()	0	29	9
C	merge()	0	38	12
A	getModifiers()	0	3	1
A	count()	0	3	1
A	performArray()	0	12	4
A	getIterator()	0	3	1
A	withData()	0	5	1
A	offsetGet()	0	3	1
A	withModifier()	0	3	1
A	offsetUnset()	0	3	1
A	withAddedModifiers()	0	5	1
A	toArray()	0	12	4
A	offsetExists()	0	3	1

<?php

declare(strict_types=1);

namespace Yiisoft\Arrays\Collection;

use ArrayAccess;
use ArrayIterator;
use Countable;
use IteratorAggregate;
use Yiisoft\Arrays\Collection\Modifier\ModifierInterface\AfterMergeModifierInterface;
use Yiisoft\Arrays\Collection\Modifier\ModifierInterface\BeforeMergeModifierInterface;
use Yiisoft\Arrays\Collection\Modifier\ModifierInterface\DataModifierInterface;
use Yiisoft\Arrays\Collection\Modifier\ModifierInterface\ModifierInterface;

final class ArrayCollection implements ArrayAccess, IteratorAggregate, Countable
{
    private array $data;

    /**
     * @var array|null Result array cache
     */
    private ?array $array = null;

    /**
     * @var ModifierInterface[]
     */
    private array $modifiers;

    /**
     * @param array $data
     * @param ModifierInterface|ModifierInterface[] $modifiers
     */
    public function __construct(array $data = [], $modifiers = [])
    {
        $this->data = $data;
        $this->modifiers = is_array($modifiers) ? $modifiers : [$modifiers];
    }

    public function withData(array $data): self
    {
        $new = clone $this;
        $new->data = $data;
        return $new;
    }

    /**
     * @return ModifierInterface[]
     */
    public function getModifiers(): array
    {
        return $this->modifiers;
    }

    public function withModifier(ModifierInterface ...$modifiers): self
    {
        return $this->withModifiers($modifiers);
    }

    /**
     * @param ModifierInterface[] $modifiers
     * @return self
     */
    public function withModifiers(array $modifiers): self
    {
        $new = clone $this;
        $new->modifiers = $modifiers;
        return $new;
    }

    public function withAddedModifier(ModifierInterface ...$modifiers): self
    {
        return $this->withAddedModifiers($modifiers);
    }

    /**
     * @param ModifierInterface[] $modifiers
     * @return self
     */
    public function withAddedModifiers(array $modifiers): self
    {
        $new = clone $this;
        $new->modifiers = array_merge($new->modifiers, $modifiers);
        return $new;
    }

    /**
     * @param array|self ...$args
     * @return self
     */
    public function mergeWith(...$args): self
    {
        array_unshift($args, $this);

        $arrays = [];
        foreach ($args as $arg) {
            $arrays[] = $arg instanceof self ? $arg->data : $arg;
        }

        $collections = [];
        foreach ($args as $index => $arg) {
            $collection = $arg instanceof self ? $arg : new self($arg);
            foreach ($collection->getModifiers() as $modifier) {
                if ($modifier instanceof BeforeMergeModifierInterface) {
                    $collection->data = $modifier->beforeMerge($arrays, $index);
                }
            }
            $collections[$index] = $collection;
        }

        $collection = $this->merge(...$collections);

        foreach ($collection->getModifiers() as $modifier) {
            if ($modifier instanceof AfterMergeModifierInterface) {
                $collection->data = $modifier->afterMerge($collection->data);
            }
        }

        return $collection;
    }

    /**
     * @param array|self ...$args
     * @return self
     */
    private function merge(...$args): self
    {
        $collection = new ArrayCollection();

        while (!empty($args)) {
            $array = array_shift($args);

            if ($array instanceof ArrayCollection) {
                $collection->modifiers = array_merge($collection->modifiers, $array->modifiers);
                $collection->data = $this->merge($collection->data, $array->data)->data;
                continue;
            }

            foreach ($array as $k => $v) {
                if (is_int($k)) {
                    if (array_key_exists($k, $collection->data)) {
                        if ($collection->data[$k] !== $v) {
                            $collection->data[] = $v;
                        }
                    } else {
                        $collection->data[$k] = $v;
                    }
                } elseif (
                    static::isMergable($v) &&

The method Yiisoft\Arrays\Collection\ArrayCollection::isMergable() is not static, but was called statically.

                    isset($collection->data[$k]) &&
                    static::isMergable($collection->data[$k])
                ) {
                    $mergedCollection = $this->merge($collection->data[$k], $v);
                    $collection->data[$k] = ($collection->data[$k] instanceof self || $v instanceof self)
                        ? $mergedCollection
                        : $mergedCollection->data;
                } else {
                    $collection->data[$k] = $v;
                }
            }
        }

        return $collection;
    }

    /**
     * @param mixed $value
     * @return bool
     */
    private function isMergable($value): bool
    {
        return is_array($value) || $value instanceof self;
    }

    public function toArray(): array
    {
        if ($this->array === null) {
            $this->array = $this->performArray($this->data);

            foreach ($this->modifiers as $modifier) {
                if ($modifier instanceof DataModifierInterface) {
                    $this->array = $modifier->apply($this->array);

$this->array of type null is incompatible with the type array expected by parameter $data of Yiisoft\Arrays\Collection\Modifier\ModifierInterface\DataModifierInterface::apply().

                }
            }
        }
        return $this->array;

The expression return $this->array could return the type null which is incompatible with the type-hinted return array. Consider adding an additional type-check to rule them out.

    }

    private function performArray(array $array): array
    {
        foreach ($array as $k => $v) {
            if ($v instanceof ArrayCollection) {
                $array[$k] = $v->toArray();
            } elseif (is_array($v)) {
                $array[$k] = $this->performArray($v);
            } else {
                $array[$k] = $v;
            }
        }
        return $array;
    }

    /**
     * Returns an iterator for traversing the data.
     * This method is required by the SPL interface {@see IteratorAggregate}.
     * It will be implicitly called when you use `foreach` to traverse the collection.
     * @return ArrayIterator an iterator for traversing the cookies in the collection.
     */
    public function getIterator(): ArrayIterator
    {
        return new ArrayIterator($this->toArray());
    }

    /**
     * Returns the number of data items.
     * This method is required by {@see Countable} interface.
     * @return int number of data elements.
     */
    public function count(): int
    {
        return count($this->toArray());
    }

    /**
     * This method is required by the interface {@see ArrayAccess}.
     * @param mixed $offset the offset to check on
     * @return bool
     */
    public function offsetExists($offset): bool
    {
        return isset($this->toArray()[$offset]);
    }

    /**
     * This method is required by the interface {@see ArrayAccess}.
     * @param mixed $offset the offset to retrieve element.
     * @return mixed the element at the offset, null if no element is found at the offset
     */
    public function offsetGet($offset)
    {
        return $this->toArray()[$offset] ?? null;
    }

    /**
     * @param mixed $offset the offset to set element
     * @param mixed $value the element value
     */
    public function offsetSet($offset, $value): void
    {
        throw new ArrayCollectionIsImmutableException();
    }

    /**
     * @param mixed $offset the offset to unset element
     */
    public function offsetUnset($offset): void
    {
        throw new ArrayCollectionIsImmutableException();
    }
}