PublishingKit\Utilities\Collections\BaseCollection

Complexity

Total Complexity

41

Size/Duplication

Total Lines	259
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes	1
Bugs	0	Features	0

22 Methods

Rating	Name	Duplication	Size	Complexity
A	all()	0	6	2
A	map()	0	5	2
A	toJson()	0	3	1
A	count()	0	3	1
A	reject()	0	4	1
A	pipe()	0	3	1
A	serialize()	0	3	1
A	reduce()	0	7	2
A	each()	0	4	2
A	makeIterator()	0	9	3
A	make()	0	3	1
A	pluck()	0	4	1
A	__construct()	0	10	5
A	reduceToCollection()	0	7	2
A	getArrayableItems()	0	12	5
A	unserialize()	0	3	1
A	getIterator()	0	3	1
A	empty()	0	3	1
A	jsonSerialize()	0	3	1
A	toArray()	0	5	2
A	filter()	0	11	4
A	__debugInfo()	0	3	1

<?php

declare(strict_types=1);

namespace PublishingKit\Utilities\Collections;

use PublishingKit\Utilities\Contracts\Collectable;
use PublishingKit\Utilities\Traits\Macroable;
use JsonSerializable;
use Serializable;
use ArrayIterator;
use IteratorIterator;
use Traversable;

abstract class BaseCollection implements Collectable, JsonSerializable, Serializable
{
    use Macroable;

The trait PublishingKit\Utilities\Traits\Macroable requires the property $name which is not provided by PublishingKit\Utilities\Collections\BaseCollection.

    /**
     * @var mixed
     */
    protected $source;

    /**
     * Constructor
     *
     * @param mixed $source Items to collect.
     * @return void
     */
    public function __construct($source = [])
    {
        if (is_callable($source) || $source instanceof self) {
            $this->source = $source;
        } elseif (is_iterable($source)) {
            $this->source = $source;
        } elseif (is_null($source)) {
            $this->source = static::empty();
        } else {
            $this->source = $this->getArrayableItems($source);
        }
    }

    /**
     * Create collection
     *
     * @param mixed $items Items to collect.
     * @return Collectable
     */
    public static function make($items): Collectable
    {
        return new static($items);
    }

    /**
     * {@inheritDoc}
     */
    public static function empty()
    {
        return new static([]);
    }

    public function __debugInfo()
    {
        return $this->toArray();
    }

    /**
     * {@inheritDoc}
     */
    public function toJson()
    {
        return json_encode($this->toArray());
    }

    /**
     * Serialize collection to JSON
     *
     * @return string|false
     */
    public function jsonSerialize()
    {
        return $this->toJson();
    }

    /**
     * {@inheritDoc}
     */
    public function serialize()
    {
        return serialize($this->toArray());
    }

    /**
     * {@inheritDoc}
     */
    public function unserialize($serialized)
    {
        $this->source = unserialize($serialized);
    }

    /**
     * {@inheritDoc}
     */
    public function getIterator()
    {
        return $this->makeIterator($this->source);
    }

    /**
     * Make an iterator from the given source.
     *
     * @param  mixed  $source
     * @return \Traversable
     */
    protected function makeIterator($source)
    {
        if (is_array($source)) {
            return new ArrayIterator($source);
        }
        if (is_iterable($source)) {
            return new IteratorIterator($source);
        }
        return $source();
    }

    /**
     * {@inheritDoc}
     *
     * @return iterable
     */
    public function all(): iterable
    {
        if (is_array($this->source)) {
            return $this->source;
        }
        return iterator_to_array($this->getIterator());
    }

    /**
     * Results array of items from Collection or Arrayable.
     *
     * @param mixed  $items
     *
     * @return iterable
     */
    protected function getArrayableItems($items): iterable
    {
        if (is_array($items)) {
            return $items;
        } elseif ($items instanceof Collectable) {
            return $items->toArray();
        } elseif ($items instanceof JsonSerializable) {
            return (array) $items->jsonSerialize();
        } elseif ($items instanceof Traversable) {
            return iterator_to_array($items);
        }
        return (array) $items;
    }

    /**
     * Get the collection of items as a plain array.
     *
     * @return iterable
     */
    public function toArray(): iterable
    {
        return $this->map(function ($value) /* @return mixed */ {
            return $value instanceof Collectable ? $value->toArray() : $value;
        })->all();
    }

    /**
     * {@inheritDoc}
     */
    public function count()
    {
        return iterator_count($this->getIterator());
    }

    /**
     * {@inheritDoc}
     */
    public function pipe(callable $callback)
    {
        return $callback($this);
    }

    /**
     * {@inheritDoc}
     */
    public function map(callable $callback)
    {
        return new static(function () use ($callback) {
            foreach ($this as $key => $value) {
                yield $key => $callback($value, $key);
            }
        });
    }

    /**
     * {@inheritDoc}
     */
    public function filter(callable $callback = null)
    {
        if (is_null($callback)) {
            $callback = function ($value): bool {
                return (bool) $value;
            };
        }
        return new static(function () use ($callback) {
            foreach ($this as $key => $value) {
                if ($callback($value, $key)) {
                    yield $key => $value;
                }
            }
        });
    }

    /**
     * {@inheritDoc}
     */
    public function reject(callable $callback)
    {
        return $this->filter(function ($item) use ($callback) {
            return !$callback($item);
        });
    }

    /**
     * {@inheritDoc}
     */
    public function reduce(callable $callback, $initial = 0)
    {
        $result = $initial;
        foreach ($this as $value) {
            $result = $callback($result, $value);
        }
        return $result;
    }

    /**
     * Reduce operation that returns a collection
     *
     * @param callable $callback The callback to use.
     * @param mixed   $initial  The initial value.
     * @return Collection
     */
    public function reduceToCollection(callable $callback, $initial = 0): Collection
    {
        $accumulator = $initial;
        foreach ($this->source as $item) {
            $accumulator = $callback($accumulator, $item);
        }
        return new static($accumulator);
    }

    /**
     * {@inheritDoc}
     */
    public function pluck($name)
    {
        return $this->map(function ($item) use ($name) {
            return $item[$name];
        });
    }

    /**
     * {@inheritDoc}
     */
    public function each(callable $callback)
    {
        foreach ($this->source as $item) {
            $callback($item);
        }
    }
}