Nip\Collections\Traits\TransformMethodsTrait

Complexity

Total Complexity

25

Size/Duplication

Total Lines	209
Duplicated Lines	0 %

Test Coverage

Coverage

0%

Importance

Changes	2
Bugs	0	Features	1

13 Methods

Rating	Name	Duplication	Size	Complexity
A	mapWithKeys()	0	13	3
A	__sleep()	0	3	1
A	unserialize()	0	9	3
A	implode()	0	9	3
A	jsonSerialize()	0	9	2
A	map()	0	7	1
A	mapToDictionary()	0	19	3
A	toArray()	0	5	2
A	reduce()	0	9	2
A	unserializeAllowedClasses()	0	3	1
A	pluck()	0	3	1
A	transform()	0	5	1
A	serialize()	0	8	2

<?php

namespace Nip\Collections\Traits;

use JsonSerializable;
use Nip\Collections\AbstractCollection;
use Nip\Collections\ArrayInterface;
use Nip\Utility\Arr;

/**
 * Class TransformMethodsTrait
 * @package Nip\Collections\Traits
 */
trait TransformMethodsTrait
{
    protected $serializable = ['items'];

    /**
     * Get the values of a given key.
     *
     * @param string|array|int|null $value
     * @param string|null $key
     * @return static
     */
    public function pluck($value, $key = null)
    {
        return new static(Arr::pluck($this->items, $value, $key));

The call to Nip\Collections\Traits\TransformMethodsTrait::__construct() has too many arguments starting with Nip\Utility\Arr::pluck($this->items, $value, $key).

    }

    /**
     * Run a map over each of the items.
     *
     * @param callable $callback
     * @return static
     */
    public function map(callable $callback)
    {
        $keys = array_keys($this->items);

        $items = array_map($callback, $this->items, $keys);

        return new static(array_combine($keys, $items));

The call to Nip\Collections\Traits\TransformMethodsTrait::__construct() has too many arguments starting with array_combine($keys, $items).

    }

    /**
     * Run a dictionary map over the items.
     *
     * The callback should return an associative array with a single key/value pair.
     *
     * @param callable $callback
     * @return static
     */
    public function mapToDictionary(callable $callback)
    {
        $dictionary = [];

        foreach ($this->items as $key => $item) {
            $pair = $callback($item, $key);

            $key = key($pair);

            $value = reset($pair);

            if (!isset($dictionary[$key])) {
                $dictionary[$key] = [];
            }

            $dictionary[$key][] = $value;
        }

        return new static($dictionary);

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

    }

    /**
     * Run an associative map over each of the items.
     *
     * The callback should return an associative array with a single key/value pair.
     *
     * @param  callable  $callback
     * @return static
     */
    public function mapWithKeys(callable $callback)
    {
        $result = [];

        foreach ($this->items as $key => $value) {
            $assoc = $callback($value, $key);

            foreach ($assoc as $mapKey => $mapValue) {
                $result[$mapKey] = $mapValue;
            }
        }

        return new static($result);

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

    }

    /**
     * Concatenate values of a given key as a string.
     *
     * @param string $value
     * @param string|null $glue
     * @return string
     */
    public function implode($value, $glue = null)
    {
        $first = $this->first();

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

        if (is_array($first) || is_object($first)) {
            return implode($glue, $this->pluck($value)->all());

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

It seems like $glue can also be of type null; however, parameter $glue of implode() does only seem to accept string, maybe add an additional type check?

        }

        return implode($value, $this->items);
    }

    /**
     * Transform each item in the collection using a callback.
     *
     * @param callable $callback
     * @return $this
     */
    public function transform(callable $callback)
    {
        $this->items = $this->map($callback)->all();

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

        return $this;
    }

    /**
     * Reduce the collection to a single value.
     *
     * @param  callable  $callback
     * @param  mixed $initial
     * @return mixed
     */
    public function reduce(callable $callback, $initial = null)
    {
        $result = $initial;

        foreach ($this as $key => $value) {
            $result = $callback($result, $value, $key);
        }

        return $result;
    }

    /**
     * @return array
     */
    public function toArray(): array
    {
        return array_map(function ($value) {
            return $value instanceof ArrayInterface ? $value->toArray() : $value;
        }, $this->items);
    }

    /**
     * Returns a serialized string representation of this array object.
     *
     * @link http://php.net/manual/en/serializable.serialize.php Serializable::serialize()
     *
     * @return string a PHP serialized string.
     */
    public function serialize(): string
    {
        $properties = $this->__sleep();
        $data = [];
        foreach ($properties as $property) {
            $data[$property] = $this->{$property};
        }
        return serialize($data);
    }

    /**
     * @return array
     */
    public function __sleep()
    {
        return $this->serializable;
    }

    /**
     * Converts a serialized string representation into an instance object.
     *
     * @link http://php.net/manual/en/serializable.unserialize.php Serializable::unserialize()
     *
     * @param string $serialized A PHP serialized string to unserialize.
     *
     * @phpcsSuppress SlevomatCodingStandard.TypeHints.ParameterTypeHint.MissingNativeTypeHint
     */
    public function unserialize($serialized): void
    {
        /** @var array<array-key, T> $data */
        $data = unserialize($serialized, ['allowed_classes' => $this->unserializeAllowedClasses()]);
        if (!is_array($data)) {
            return;
        }
        foreach ($data as $property => $value) {
            $this->{$property} = $value;
        }
    }

    /**
     * Specify data which should be serialized to JSON
     * @link http://php.net/manual/en/jsonserializable.jsonserialize.php
     * @return mixed data which can be serialized by <b>json_encode</b>,
     * which is a value of any type other than a resource.
     * @since 5.4.0
     */
    public function jsonSerialize()
    {
        return array_map(function ($value) {
            if ($value instanceof JsonSerializable) {
                return $value->jsonSerialize();
            } else {
                return $value;
            }
        }, $this->items);
    }

    protected function unserializeAllowedClasses()
    {
        return false;
    }
}