Nip\Records\Collections\Collection

Complexity

Total Complexity

32

Size/Duplication

Total Lines	207
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	5

Test Coverage

Coverage

25.67%

Importance

Changes

0

16 Methods

Rating	Name	Duplication	Size	Complexity
A	loadRelations()	0	10	3
A	loadRelation()	0	7	1
A	getRelation()	0	4	1
A	setManager()	0	6	1
A	toJSON()	0	9	2
A	save()	0	8	3
A	add()	0	5	1
A	getRecordKey()	0	13	4
A	getIndexKey()	0	4	1
A	setIndexKey()	0	4	1
A	has()	0	8	2
A	hasRecord()	0	6	2
A	remove()	0	8	3
A	delete()	0	21	4
A	getManager()	0	8	2
A	initManager()	0	5	1

<?php

namespace Nip\Records\Collections;

use Nip\Collections\Collection as AbstractCollection;
use Nip\HelperBroker;
use Nip\Records\AbstractModels\Record as Record;
use Nip\Records\AbstractModels\RecordManager as Records;

/**
 * Class Collection
 * @package Nip\Records\Collections
 */
class Collection extends AbstractCollection
{
    protected $_indexKey = false;

    /**
     * @var Records
     */
    protected $_manager = null;


    /**
     * @param $relations
     */
    public function loadRelations($relations)
    {
        if (is_string($relations)) {
            $relations = func_get_args();
        }

        foreach ($relations as $relation) {
            $this->loadRelation($relation);
        }
    }

    /**
     * @param $name
     * @return Collection
     */
    public function loadRelation($name)
    {
        $relation = $this->getRelation($name);
        $results = $relation->getEagerResults($this);
        $relation->match($this, $results);
        return $results;
    }

    /**
     * @param $name
     * @return \Nip\Records\Relations\Relation|null
     */
    public function getRelation($name)
    {
        return $this->getManager()->getRelation($name);

The method getRelation does not exist on object<Nip\Records\AbstractModels\RecordManager>? Since you implemented __call, maybe consider adding a @method annotation.

    }

    /**
     * @return Records
     */
    public function getManager()
    {
        if ($this->_manager == null) {
            $this->initManager();
        }

        return $this->_manager;
    }

    /**
     * @param Records $manager
     * @return $this
     */
    public function setManager(Records $manager)
    {
        $this->_manager = $manager;

        return $this;
    }

    public function initManager()
    {
        $manager = $this->rewind()->getManager();
        $this->setManager($manager);
    }

    /**
     * @return string
     */
    public function toJSON()
    {
        $return = [];
        foreach ($this as $item) {
            $return = $item->toArray();
        }

        return json_encode($return);
    }

    public function save()
    {
        if (count($this) > 0) {
            foreach ($this as $item) {
                $item->save();
            }
        }
    }

    /**
     * @param Record $record
     * @param string $index
     */
    public function add($record, $index = null)
    {
        $index = $this->getRecordKey($record, $index);

It seems like $index defined by $this->getRecordKey($record, $index) on line 116 can also be of type string; however, Nip\Records\Collections\Collection::getRecordKey() does only seem to accept null, maybe add an additional type check?

        parent::add($record, $index);
    }

    /**
     * @param Record $record
     * @param null $index
     * @return bool|mixed|null
     */
    public function getRecordKey(Record $record, $index = null)
    {
        if ($index) {
            $index = $record->{$index};
        } else {
            $index = $this->getIndexKey();
            $index = $index ? $record->{$index} : $record->getPrimaryKey();
            if (!$index) {
                $index = null;
            }
        }
        return $index;
    }

    /**
     * @return bool
     */
    public function getIndexKey()
    {
        return $this->_indexKey;
    }

    /**
     * @param $key
     * @return mixed
     */
    public function setIndexKey($key)
    {
        return $this->_indexKey = $key;
    }

    /**
     * @param Record $record
     * @return bool
     */
    public function has($record)
    {
        if ($record instanceof Record) {
            return $this->hasRecord($record);
        }

        return parent::has($record);
    }

    /**
     * @param Record $record
     * @return bool
     */
    public function hasRecord(Record $record)
    {
        $index = $this->getRecordKey($record);

        return parent::has($index) && $this->get($index) == $record;

It seems like you call parent on a different method (has() instead of hasRecord()). Are you sure this is correct? If so, you might want to change this to $this->has().

    }

    /**
     * @param $record
     */
    public function remove($record)
    {
        foreach ($this as $key => $item) {
            if ($item == $record) {
                unset($this[$key]);
            }
        }
    }

    /**
     * When $each is true, each record gets it's delete() method called.
     * Otherwise, a delete query is built for the entire collection
     *
     * @param bool $each
     * @return $this
     */
    public function delete($each = false)
    {
        if (count($this) > 0) {
            if ($each) {
                foreach ($this as $item) {
                    $item->delete();
                }
            } else {
                $primaryKey = $this->getManager()->getPrimaryKey();
                $pk_list = HelperBroker::get('Arrays')->pluck($this, $primaryKey);

It seems like you code against a specific sub-type and not the parent class Nip\Helpers\AbstractHelper as the method pluck() does only exist in the following sub-classes of Nip\Helpers\AbstractHelper: Nip_Helper_Arrays. Maybe you want to instanceof check for one of these explicitly?

                $query = $this->getManager()->newQuery("delete");
                $query->where("$primaryKey IN ?", $pk_list);
                $query->execute();
            }

            $this->clear();
        }

        return $this;
    }
}