Collections\Traits\CommonMutableContainerTrait

Complexity

Total Complexity

40

Size/Duplication

Total Lines	180
Duplicated Lines	25.56 %

Coupling/Cohesion

Components	0
Dependencies	3

Test Coverage

Coverage

94.64%

Importance

Changes	6
Bugs	2	Features	2

11 Methods

Rating	Name	Duplication	Size	Complexity
A	values()	0	4	1
A	toKeysArray()	0	9	2
A	fromArray()	0	13	3
A	groupBy()	0	16	4
A	indexBy()	0	10	2
A	toValuesArray()	13	13	3
A	toArray()	13	13	3
A	concat()	10	10	3
A	replace()	10	10	3
C	concatRecurse()	0	24	8
B	replaceRecurse()	0	17	8

<?php

namespace Collections\Traits;

use Collections\ArrayList;
use Collections\Dictionary;
use Collections\Iterable;
use Collections\VectorInterface;

trait CommonMutableContainerTrait
{
    /**
     * {@inheritdoc}
     */
    public function values()
    {
        return new ArrayList($this);
    }

    /**
     * @return array
     */
    public function toValuesArray()

This method seems to be duplicated in your project.

    {
        $arr = [];
        foreach ($this as $value) {

The expression $this of type this<Collections\Traits\CommonMutableContainerTrait> is not traversable.

            if ($value instanceof Iterable) {
                $arr[] = $value->toArray();
            } else {
                $arr[] = $value;
            }
        }

        return $arr;
    }

    public function toKeysArray()
    {
        $res = [];
        foreach ($this as $k => $_) {

The expression $this of type this<Collections\Traits\CommonMutableContainerTrait> is not traversable.

            $res[] = $k;
        }

        return $res;
    }

    /**
     * {@inheritdoc}
     */
    public function toArray()

This method seems to be duplicated in your project.

    {
        $arr = [];
        foreach ($this as $key => $value) {

The expression $this of type this<Collections\Traits\CommonMutableContainerTrait> is not traversable.

            if ($value instanceof Iterable) {
                $arr[$key] = $value->toArray();
            } else {
                $arr[$key] = $value;
            }
        }

        return $arr;
    }

    /**
     * {@inheritdoc}
     */
    public static function fromArray(array $arr)
    {
        $map = new static();
        foreach ($arr as $k => $v) {
            if (is_array($v)) {
                $map[$k] = new static($v);

The call to CommonMutableContainerTrait::__construct() has too many arguments starting with $v.

            } else {
                $map[$k] = $v;
            }
        }

        return $map;
    }

    /**
     * {@inheritDoc}
     * @return $this
     */
    public function groupBy($callback)
    {
        $group = new Dictionary();
        foreach ($this as $value) {

The expression $this of type this<Collections\Traits\CommonMutableContainerTrait> is not traversable.

            $key = $callback($value);
            if (!$group->containsKey($key)) {
                $element = $this instanceof VectorInterface ? new static([$value]) : new ArrayList([$value]);

The call to CommonMutableContainerTrait::__construct() has too many arguments starting with array($value).

                $group->add($key, $element);
            } else {
                $value = $group->get($key)->add($value);
                $group->set($key, $value);
            }
        }

        return $group;
    }

    /**
     * {@inheritDoc}
     * @return $this
     */
    public function indexBy($callback)
    {
        $group = new Dictionary();
        foreach ($this as $value) {

The expression $this of type this<Collections\Traits\CommonMutableContainerTrait> is not traversable.

            $key = $callback($value);
            $group->set($key, $value);
        }

        return $group;
    }

    /**
     * {@inheritDoc}
     * @return $this
     */
    public function concat($iterable)

This method seems to be duplicated in your project.

    {
        if (!is_array($iterable) && !$iterable instanceof \Traversable) {
            throw new \InvalidArgumentException('The items must be an array or Traversable');
        }

        $this->setAll($this->concatRecurse($this, $iterable));

It seems like setAll() must be provided by classes using this trait. How about adding it as abstract method to this trait?

        return $this;
    }

    /**
     * {@inheritDoc}
     * @return $this
     */
    public function replace($iterable)

This method seems to be duplicated in your project.

    {
        if (!is_array($iterable) && !$iterable instanceof \Traversable) {
            throw new \InvalidArgumentException('The items must be an array or Traversable');
        }

        $this->setAll($this->concatRecurse($this, $iterable));

It seems like setAll() must be provided by classes using this trait. How about adding it as abstract method to this trait?

        return $this;
    }

    private function concatRecurse($array, $array1)
    {
        $merged = $array;

        foreach ($array1 as $key => & $value) {
            $isValid = function ($value) {
                return (is_array($value) || $value instanceof \Traversable);
            };

            if (($isValid($value) && isset($merged[$key])) && $isValid($merged[$key])) {
                $merged[$key] = $this->concatRecurse($merged[$key], $value);
            } else {
                if (is_numeric($key)) {
                    if (!isset($merged[$value])) {
                        $merged[] = $value;
                    }
                } else {
                    $merged[$key] = $value;
                }
            }
        }

        return $merged;
    }

    private function replaceRecurse($array, $array1)

This method is not used, and could be removed.

    {
        foreach ($array1 as $key => $value) {
            // create new key in $array, if it is empty or not an array
            if (!isset($array[$key]) || (isset($array[$key]) && (!is_array($array[$key]) && !$array[$key] instanceof \Traversable))) {
                $array[$key] = [];
            }

            // overwrite the value in the base array
            if (is_array($value) || $value instanceof \Traversable) {
                $value = $this->replaceRecurse($array[$key], $value);
            }
            $array[$key] = $value;
        }

        return $array;
    }
}