Nip\Collections\Traits\OperationsTrait

Complexity

Total Complexity

16

Size/Duplication

Total Lines	106
Duplicated Lines	0 %

Test Coverage

Coverage

57.14%

Importance

Changes	2
Bugs	0	Features	1

7 Methods

Rating	Name	Duplication	Size	Complexity
A	isNotEmpty()	0	3	1
A	size()	0	8	2
B	groupBy()	0	28	7
A	isEmpty()	0	3	1
A	count()	0	3	1
A	clear()	0	4	1
A	keyBy()	0	8	3

<?php

namespace Nip\Collections\Traits;

use Nip\Collections\AbstractCollection;

/**
 * Class OperationsTrait
 * @package Nip\Collections\Traits
 */
trait OperationsTrait
{
    /**
     * Returns the number of parameters.
     *
     * @return int The number of parameters
     */
    public function count()
    {
        return count($this->items);
    }

    /**
     * Returns number of items in $collection.
     *
     * @return int
     */
    public function size()
    {
        $result = 0;
        foreach ($this as $value) {
            $result++;
        }

        return $result;
    }

    /**
     * @return bool
     */
    public function isEmpty(): bool
    {
        return $this->count() < 1;
    }

    /**
     * @return bool
     */
    public function isNotEmpty(): bool
    {
        return !$this->isEmpty();
    }

    public function clear(): void
    {
        $this->rewind();
        $this->items = [];

The property items does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

    }

    /**
     * Key an associative array by a field or using a callback.
     *
     * @param callable|string $keyBy
     * @return static
     */
    public function keyBy($keyBy)
    {
        $results = [];
        foreach ($this->items as $key => $item) {
            $resolvedKey = is_object($item) ? $item->{$keyBy} : $item[$keyBy];
            $results[$resolvedKey] = $item;
        }
        return new static($results);

The call to Nip\Collections\Traits\OperationsTrait::__construct() has too many arguments starting with $results.

    }

    /**
     * Group an associative array by a field or using a callback.
     *
     * @param array|callable|string $groupBy
     * @param bool $preserveKeys
     * @return static
     */
    public function groupBy($groupBy, $preserveKeys = false): AbstractCollection
    {
        $results = [];

        $groupBy = $this->valueRetriever($groupBy);

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

        foreach ($this->items as $key => $value) {
            $groupKeys = $groupBy($value, $key);


            if (!is_array($groupKeys)) {
                $groupKeys = [$groupKeys];
            }

            foreach ($groupKeys as $groupKey) {
                $groupKey = is_bool($groupKey) ? (int)$groupKey : $groupKey;

                if (!array_key_exists($groupKey, $results)) {
                    $results[$groupKey] = new static;
                }

                $results[$groupKey]->offsetSet($preserveKeys ? $key : null, $value);
            }
        }

        $result = new static($results);

The call to Nip\Collections\Traits\OperationsTrait::__construct() has too many arguments starting with $results.

        return $result;

The expression return $result returns the type Nip\Collections\Traits\OperationsTrait which includes types incompatible with the type-hinted return Nip\Collections\AbstractCollection.

    }

    /**
     * @return void
     */
    abstract public function rewind();
}