bytic / orm

src/Collections/Collection.php

<?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 expression return $this->getManager()->getRelation($name) returns the type Nip\Records\AbstractModels\RecordManager|Nip\Records\Collections\Collection|true which is incompatible with the documented return type Nip\Records\Relations\Relation|null.

The method getRelation() does not exist on Nip\Records\AbstractModels\RecordManager. Since you implemented __call, 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();

Are you sure the usage of $this->rewind() targeting Nip\Collections\AbstractCollection::rewind() seems to always return null.

        $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 can also be of type string; however, parameter $index of 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

Are you sure the doc-type for parameter $index is correct as it would always require null to be passed?

     * @return string|null
     */
    public function getRecordKey(Record $record, $index = null)
    {
        if ($index) {

$index is of type null, thus it always evaluated to false.

            return $this->generateRecordKeyByIndex($record, $index);
        }

        $index = $this->getIndexKey();
        if ($index) {
            return $this->generateRecordKeyByIndex($record, $index);
        }

        $index = $record->getPrimaryKey();
        if (is_array($index)) {
            return implode('-', $index);
        }
        return $index;
    }

    /**
     * @param Record $record
     * @param $index
     * @return mixed
     */
    protected function generateRecordKeyByIndex(Record $record, $index)
    {
        if (is_array($index)) {
            return $record->implodeFields($index);
        }

        return $record->{$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) {

$record is always a sub-type of Nip\Records\AbstractModels\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;
    }

    /**
     * @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);

The method pluck() does not exist on Nip\Helpers\AbstractHelper. It seems like you code against a sub-type of Nip\Helpers\AbstractHelper such as Nip_Helper_Url or Nip_Helper_Arrays or Nip\Helpers\View\Stylesheets or Nip\Helpers\View\Strings or Nip\Helpers\View\Paginator or Nip\Helpers\View\Arrays or Nip\Helpers\View\Icontext or Nip\Helpers\View\Color or Nip\Helpers\View\Scripts or Nip\Helpers\View\Url.

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

            $this->clear();
        }

        return $this;
    }
}