Nip\Records\Traits\Relations\HasRelationsRecordTrait

Complexity

Total Complexity

15

Size/Duplication

Total Lines	111
Duplicated Lines	0 %

Test Coverage

Coverage

11.43%

Importance

Changes	3
Bugs	2	Features	0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	hasRelation()	0	3	1
A	newRelation()	0	6	1
A	getCloneWithRelations()	0	7	1
A	cloneRelations()	0	3	1
A	initRelation()	0	6	2
A	getRelations()	0	3	1
A	saveRelations()	0	6	2
A	isCallRelationOperation()	0	12	4
A	getRelation()	0	7	2

<?php

namespace Nip\Records\Traits\Relations;

use Nip\Records\AbstractModels\Record;
use Nip\Records\AbstractModels\RecordManager;
use Nip\Records\Relations\HasMany;
use Nip\Records\Relations\Relation;
use Nip\Records\Traits\AbstractTrait\RecordTrait;

/**
 * Trait HasRelationsRecordTrait
 * @package Nip\Records\Traits\Relations
 *
 * @method HasRelationsRecordsTrait|RecordManager getManager
 */
trait HasRelationsRecordTrait
{
    use RecordTrait;

    /**
     * The loaded relationships for the model.
     * @var array
     */
    protected $relations = [];

    public function saveRelations()
    {
        $relations = $this->getRelations();
        foreach ($relations as $relation) {
            /** @var Relation $relation */
            $relation->save();
        }
    }

    /**
     * @return array
     */
    public function getRelations()
    {
        return $this->relations;
    }

    /**
     * @param string $name
     * @param $arguments
     * @return bool|\Nip\Records\AbstractModels\Record|\Nip\Records\Collections\Collection
     */
    protected function isCallRelationOperation($name, $arguments = [])

The parameter $arguments is not used and could be removed.

    {
        if (substr($name, 0, 3) == "get") {
            $relation = $this->getRelation(substr($name, 3));
            if ($relation) {
                $results = $relation->getResults();
                // RETURN NULL TO DISTINCT FROM FALSE THAT MEANS NO RELATION
                return ($results) ? $results : null;
            }
        }

        return false;
    }

    /**
     * @param $relationName
     * @return Relation|HasMany|null
     */
    public function getRelation($relationName)
    {
        if (!$this->hasRelation($relationName)) {
            $this->initRelation($relationName);
        }

        return $this->relations[$relationName];
    }

    /**
     * @param $key
     * @return bool
     */
    public function hasRelation($key)
    {
        return array_key_exists($key, $this->relations);
    }

    /**
     * @param $relationName
     */
    public function initRelation($relationName)
    {
        if (!$this->getManager()->hasRelation($relationName)) {

The method hasRelation() does not exist on Nip\Records\AbstractModels\RecordManager. Since you implemented __call, consider adding a @method annotation.

            return;
        }
        $this->relations[$relationName] = $this->newRelation($relationName);
    }

    /**
     * @param string $relationName
     * @return Relation|null
     */
    public function newRelation($relationName)
    {
        $relation = clone $this->getManager()->getRelation($relationName);

The method getRelation() does not exist on Nip\Records\AbstractModels\RecordManager. Since you implemented __call, consider adding a @method annotation.

        $relation->setItem($this);

The method setItem() does not exist on Nip\Records\AbstractModels\RecordManager. Since you implemented __call, consider adding a @method annotation.

The method setItem() does not exist on Nip\Records\Collections\Collection. Did you maybe mean setItems()?

It seems like setItem() must be provided by classes using this trait. How about adding it as abstract method to this trait?

        return $relation;

The expression return $relation also could return the type Nip\Records\AbstractModels\RecordManager|Nip\Records\Collections\Collection|Nip\Records\Traits\Relations\HasRelationsRecordsTrait which is incompatible with the documented return type Nip\Records\Relations\Relation|null.

    }

    /**
     * @return Record|self
     */
    public function getCloneWithRelations()
    {
        /** @var self $item */
        $item = $this->getClone();

The method getClone() does not exist on Nip\Records\Traits\Relations\HasRelationsRecordTrait. Did you maybe mean getCloneWithRelations()?

        $item->cloneRelations($this);

        return $item;
    }

    /**
     * Clone the relations records from a sibling
     * @param self $from
     * @return \Nip\Records\Traits\Relations\HasRelationsRecordTrait
     */
    public function cloneRelations($from)
    {
        return $this->getManager()->cloneRelations($from, $this);

The method cloneRelations() does not exist on Nip\Records\AbstractModels\RecordManager. Since you implemented __call, consider adding a @method annotation.

    }
}