Raidros\Collection\Collection

Complexity

Total Complexity

20

Size/Duplication

Total Lines	161
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	2

Test Coverage

Coverage

97.44%

Importance

Changes	17
Bugs	10	Features	4

10 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	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	10	3
A	remove()	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 Class or interface of namespace for implementation
     */
    public function __construct($classname = null)
    {
        $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 or is_subclass_of($object, $this->classname);

Using logical operators such as or instead of || is generally not recommended.

    }

    /**
     * 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 (!count($this->items)) {
            return $this;
        }

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

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

        return $this;
    }
}