Raidros\Collection\Collection

Complexity

Total Complexity

30

Size/Duplication

Total Lines	252
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	2

Test Coverage

Coverage

100%

Importance

Changes	25
Bugs	12	Features	9

16 Methods

Rating	Name	Duplication	Size	Complexity
A	remove()	0	8	2
A	__construct()	0	5	1
A	put()	0	10	3
A	isValidObjectInstance()	0	8	3
A	isInstanceOrSubclassOf()	0	4	2
A	all()	0	4	1
A	find()	0	6	2
A	has()	0	4	1
A	findOrFail()	0	10	2
A	each()	0	8	2
A	count()	0	4	1
A	except()	0	6	2
A	filterByKeys()	0	14	3
A	map()	0	7	1
A	only()	0	6	2
A	filter()	0	8	2

<?php

namespace Raidros\Collection;

use Raidros\Collection\Exceptions\CollectionItemNotFoundException;
use Raidros\Collection\Exceptions\InvalidCollectionItemInstanceException;

class Collection
{
    /**
     * Collection items.
     *
     * @var array
     */
    private $items = [];

    /**
     * Implementation namespace.
     *
     * @var string
     */
    private $classname;

    /**
     * Create a new collection instance.
     *
     * @param string|null $classname
     * @param array       $items
     */
    public function __construct($classname = null, array $items = [])
    {
        $this->items = $items;
        $this->classname = $classname;
    }

    /**
     * Add a new item to collection.
     *
     * @param string $name
     * @param mixed  $value
     *
     * @return self
     */
    public function put($name, $value)
    {
        if (is_object($value) && !$this->isValidObjectInstance($value)) {
            throw new InvalidCollectionItemInstanceException(sprintf('%s must implement %s', $name, $this->classname));
        }

        $this->items[$name] = $value;

        return $this->items[$name];
    }

    /**
     * Verify's if the given object has a valid instance.
     *
     * @param object $object
     *
     * @return bool
     */
    private function isValidObjectInstance($object)
    {
        if (!is_null($this->classname) && !$this->isInstanceOrSubclassOf($object)) {
            return false;
        }

        return true;
    }

    /**
     * Check object instance.
     *
     * @param object $object
     *
     * @return bool
     */
    private function isInstanceOrSubclassOf($object)
    {
        return $object instanceof $this->classname || is_subclass_of($object, $this->classname);
    }

    /**
     * Get all items from collection.
     *
     * @return array
     */
    public function all()
    {
        return $this->items;
    }

    /**
     * Find collection item by name.
     *
     * @param string $name
     *
     * @return mixed|null
     */
    public function find($name)
    {
        if ($this->has($name)) {
            return $this->items[$name];
        }
    }

    /**
     * Check if the given item exists on collection.
     *
     * @param string $name
     *
     * @return bool
     */
    public function has($name)
    {
        return array_key_exists($name, $this->items);
    }

    /**
     * Find a specific collection item or throw's an exception.
     *
     * @param string $name
     *
     * @return mixed
     */
    public function findOrFail($name)
    {
        $result = $this->find($name);

        if (is_null($result)) {
            throw new CollectionItemNotFoundException(sprintf('Collection item "%s" not found', $name));
        }

        return $result;
    }

    /**
     * Run a callback over each item.
     *
     * @param callable $callback
     *
     * @return self
     */
    public function each(callable $callback)
    {
        if ($this->count()) {
            array_walk($this->items, $callback);
        }

        return $this;
    }

    /**
     * Remove an item from collection.
     *
     * @param string $name
     *
     * @return self
     */
    public function remove($name)
    {
        if ($this->has($name)) {
            unset($this->items[$name]);
        }

        return $this;
    }

    /**
     * Count total of items on collection.
     *
     * @return int
     */
    public function count()
    {
        return count($this->items);
    }

    /**
     * Get all items except for those with the specified keys.
     *
     * @param mixed $key
     *
     * @return static
     */
    public function except($key)
    {
        $keys = is_array($key) ? $key : func_get_args();

        return new static($this->classname, array_diff_key($this->items, $this->filterByKeys($keys)));
    }

    /**
     * Filter items by key name.
     *
     * @param array $keys
     *
     * @return array
     */
    private function filterByKeys(array $keys)
    {
        $results = [];

        foreach ($this->items as $key => $value) {
            if (!in_array($key, $keys)) {
                continue;
            }

            $results[$key] = $value;
        }

        return $results;
    }

    /**
     * Run a map over each item in the collection.
     *
     * @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($this->classname, array_combine($keys, $items));
    }

    /**
     * Get all items with the specified keys.
     *
     * @param mixed $key
     *
     * @return static
     */
    public function only($key)
    {
        $keys = is_array($key) ? $key : func_get_args();

        return new static($this->classname, $this->filterByKeys($keys));
    }

    /**
     * Filter the elements in the collection using a callback function.
     *
     * @param callable|null $callback
     *
     * @return static
     */
    public function filter(callable $callback = null)
    {
        if (is_null($callback)) {
            return new static($this->classname, array_filter($this->items));
        }

        return new static($this->classname, array_filter($this->items, $callback));
    }
}