Baleen\Migrations\Common\Collection\AbstractCollection

Complexity

Total Complexity

49

Size/Duplication

Total Lines	320
Duplicated Lines	6.25 %

Coupling/Cohesion

Components	1
Dependencies	6

Test Coverage

Coverage

100%

Importance

Changes	2
Bugs	0	Features	0

29 Methods

Rating	Name	Duplication	Size	Complexity
B	__construct()	0	20	6
A	toArray()	0	4	1
A	first()	0	4	1
A	last()	0	4	1
A	key()	0	4	1
A	next()	0	4	1
A	current()	0	4	1
A	remove()	0	12	3
A	contains()	0	5	2
A	containsVersion()	0	5	1
A	exists()	10	10	3
A	get()	0	5	2
A	getKeys()	0	4	1
A	getValues()	0	4	1
A	count()	0	4	1
A	replace()	0	8	2
A	add()	0	12	2
A	isEmpty()	0	4	1
A	getIterator()	0	4	1
A	map()	0	4	1
A	filter()	0	4	1
A	forAll()	10	10	3
A	partition()	0	14	3
A	__toString()	0	4	1
A	clear()	0	4	1
A	slice()	0	4	1
A	merge()	0	8	2
A	getPosition()	0	3	1
A	getByPosition()	0	9	3

<?php
/*
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * This software consists of voluntary contributions made by many individuals
 * and is licensed under the MIT license. For more information, see
 * <http://www.doctrine-project.org>.
 */

namespace Baleen\Migrations\Common\Collection;

use ArrayIterator;
use Baleen\Migrations\Exception\InvalidArgumentException;
use Baleen\Migrations\Exception\Version\Collection\AlreadyExistsException;
use Baleen\Migrations\Exception\Version\Collection\CollectionException;
use Baleen\Migrations\Delta\DeltaInterface;
use Closure;
use Zend\Stdlib\ArrayUtils;

/**
 * Based on the Doctrine\CollectionAbstract project.
 *
 * @see https://github.com/doctrine/collections
 *
 * @author Gabriel Somoza <gabriel@strategery.io>
 */
abstract class AbstractCollection implements CollectionInterface
{
    /**
     * An array containing the entries of this collection.
     *
     * @var DeltaInterface[]
     */
    private $elements;

    /**
     * Initializes a new AbstractCollection.
     *
     * @param DeltaInterface[] $elements
     *
     * @throws AlreadyExistsException
     * @throws CollectionException
     * @throws InvalidArgumentException
     */
    public function __construct($elements = [])
    {
        if (!is_array($elements)) {
            if ($elements instanceof \Traversable) {
                $elements = ArrayUtils::iteratorToArray($elements);
            } else {
                throw new InvalidArgumentException(
                    "Constructor parameter 'versions' must be an array or Traversable object."
                );
            }
        }

        $this->elements = [];
        foreach ($elements as $element) {
            if (!is_object($element) || !$element instanceof DeltaInterface) {
                throw CollectionException::invalidObjectException($element, DeltaInterface::class);
            }
            $this->add($element);
        }
    }

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

    /**
     * {@inheritDoc}
     */
    final public function first()
    {
        return reset($this->elements);
    }

    /**
     * {@inheritDoc}
     */
    final public function last()
    {
        return end($this->elements);
    }

    /**
     * {@inheritDoc}
     */
    final public function key()
    {
        return key($this->elements);
    }

    /**
     * {@inheritDoc}
     */
    final public function next()
    {
        return next($this->elements);
    }

    /**
     * {@inheritDoc}
     */
    final public function current()
    {
        return current($this->elements);
    }

    /**
     * {@inheritDoc}
     */
    public function remove($key)
    {
        $key = (string) $key;
        if ( ! isset($this->elements[$key]) && ! array_key_exists($key, $this->elements)) {
            return null;
        }

        $removed = $this->elements[$key];
        unset($this->elements[$key]);

        return $removed;
    }

    /**
     * {@inheritDoc}
     */
    final public function contains($key)
    {
        $key = (string) $key;
        return isset($this->elements[$key]) || array_key_exists($key, $this->elements);
    }

    /**
     * {@inheritDoc}
     */
    final public function containsVersion(DeltaInterface $version)
    {
        $key = (string) $version->getId();
        return $this->contains($key);
    }

    /**
     * {@inheritDoc}
     */
    final public function exists(Closure $p)

This method seems to be duplicated in your project.

    {
        foreach ($this->elements as $key => $element) {
            if ($p($key, $element)) {
                return true;
            }
        }

        return false;
    }

    /**
     * {@inheritDoc}
     */
    final public function get($key)
    {
        $key = (string) $key;
        return isset($this->elements[$key]) ? $this->elements[$key] : null;
    }

    /**
     * {@inheritDoc}
     */
    final public function getKeys()
    {
        return array_keys($this->elements);
    }

    /**
     * {@inheritDoc}
     */
    final public function getValues()
    {
        return array_values($this->elements);
    }

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

    /**
     * {@inheritDoc}
     */
    public function replace(DeltaInterface $version)
    {
        $key = $version->getId()->toString();
        $replacedElement = $this->contains($key) ? $this->get($key) : null;
        $this->elements[$key] = $version;

        return $replacedElement;
    }

    /**
     * {@inheritDoc}
     */
    public function add(DeltaInterface $value)
    {
        $key = $value->getId()->toString();
        if ($this->contains($key)) {
            throw new AlreadyExistsException(sprintf(
                'Element with key "%s" already exists. Remove it first or use replace() if you want to overwrite it.',
                $key
            ));
        }
        $this->elements[$key] = $value;
        return true;
    }

    /**
     * {@inheritDoc}
     */
    final public function isEmpty()
    {
        return empty($this->elements);
    }

    /**
     * Required by interface IteratorAggregate.
     *
     * {@inheritDoc}
     */
    final public function getIterator()
    {
        return new ArrayIterator($this->elements);
    }

    /**
     * {@inheritDoc}
     */
    final public function map(Closure $func)
    {
        return array_map($func, $this->elements);
    }

    /**
     * {@inheritDoc}
     */
    final public function filter(Closure $p)
    {
        return new static(array_filter($this->elements, $p));
    }

    /**
     * {@inheritDoc}
     */
    final public function forAll(Closure $p)

This method seems to be duplicated in your project.

    {
        foreach ($this->elements as $key => $element) {
            if ( ! $p($key, $element)) {
                return false;
            }
        }

        return true;
    }

    /**
     * {@inheritDoc}
     */
    final public function partition(Closure $p)
    {
        $matches = $noMatches = array();

        foreach ($this->elements as $key => $element) {
            if ($p($key, $element)) {
                $matches[$key] = $element;
            } else {
                $noMatches[$key] = $element;
            }
        }

        return array(new static($matches), new static($noMatches));
    }

    /**
     * Returns a string representation of this object.
     *
     * @return string
     */
    public function __toString()
    {
        return __CLASS__ . '@' . spl_object_hash($this);
    }

    /**
     * {@inheritDoc}
     */
    public function clear()
    {
        $this->elements = [];
    }

    /**
     * @inheritDoc
     */
    final public function slice($offset, $length = null)
    {
        return array_slice($this->elements, $offset, $length, true);
    }

    /**
     * @inheritdoc
     */
    final public function merge(CollectionInterface $collection)
    {
        foreach ($collection as $version) {
            $this->replace($version);
        }

        return $this;
    }

    /**
     * @inheritdoc
     */
    final public function getPosition($key) {
        return array_search($key, $this->getKeys()) + 1;
    }

    /**
     * @inheritdoc
     */
    final public function getByPosition($position)
    {
        $index = $position - 1;
        $keys = $this->getKeys();
        if (!isset($keys[$index]) || !array_key_exists($index, $keys)) {
            return null;
        }
        return $this->get($keys[$index]);
    }
}