Nip\Records\Traits\Relations\HasRelationsRecordsTrait

Complexity

Total Complexity

30

Size/Duplication

Total Lines	278
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	6

Test Coverage

Coverage

28.21%

Importance

Changes

0

20 Methods

Rating	Name	Duplication	Size	Complexity
A	getRelation()	0	6	1
A	checkInitRelations()	0	6	2
A	initRelations()	0	7	2
A	initRelationsType()	0	7	2
A	initRelationsFromArray()	0	8	4
A	initRelation()	0	10	1
A	newRelation()	0	9	1
A	getRelationClass()	0	6	1
A	belongsTo()	0	4	1
A	hasMany()	0	4	1
A	HABTM()	0	4	1
A	morphTo()	0	4	1
A	morphMany()	0	4	1
A	morphToMany()	0	4	1
A	morphedByMany()	0	7	1
A	hasRelation()	0	6	1
A	setRelation()	0	7	1
B	cloneRelations()	0	21	5
A	getRelations()	0	6	1
A	setRelations()	0	6	1

<?php

namespace Nip\Records\Traits\Relations;

use Nip\Records\Record;
use Nip\Records\Relations\MorphToMany;
use Nip\Records\Relations\Relation;
use Nip\Records\Traits\AbstractTrait\RecordsTrait;

/**
 * Trait HasRelationsRecordsTrait
 * @package Nip\Records\Traits\Relations
 */
trait HasRelationsRecordsTrait
{
    use RecordsTrait;

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

    protected $relationTypes = ['belongsTo', 'hasMany', 'hasAndBelongsToMany'];


    /**
     * Get a specified relationship.
     * @param  string $relation
     * @return null|Relation
     * @throws \Exception
     */
    public function getRelation($relation)
    {
        $this->checkInitRelations();

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

    /**
     * Check if the model needs to initRelations
     * @return void
     * @throws \Exception
     */
    protected function checkInitRelations()
    {
        if ($this->relations === null) {
            $this->initRelations();
        }
    }

    /**
     * @throws \Exception
     */
    protected function initRelations()
    {
        $this->relations = [];
        foreach ($this->relationTypes as $type) {
            $this->initRelationsType($type);
        }
    }

    /**
     * @param string $type
     * @throws \Exception
     */
    protected function initRelationsType($type)
    {
        if (property_exists($this, '_' . $type)) {
            $array = $this->{'_' . $type};
            $this->initRelationsFromArray($type, $array);
        }
    }

    /**
     * @param string $type
     * @param $array
     * @throws \Exception
     */
    public function initRelationsFromArray($type, $array)
    {
        foreach ($array as $key => $item) {
            $name = is_array($item) ? $key : $item;
            $params = is_array($item) ? $item : [];
            $this->initRelation($type, $name, $params);
        }
    }

    /**
     * @param string $type
     * @param string $name
     * @param array $params
     * @return Relation
     * @throws \Exception
     */
    protected function initRelation($type, $name, $params)
    {
        $relation = $this->newRelation($type);
        $relation->setName($name);
        $relation->addParams($params);

        $this->relations[$name] = $relation;

        return $relation;
    }

    /**
     * @param string $type
     * @return \Nip\Records\Relations\Relation
     */
    public function newRelation($type)
    {
        $class = $this->getRelationClass($type);
        /** @var \Nip\Records\Relations\Relation $relation */
        $relation = new $class();
        $relation->setManager($this);

        return $relation;
    }

    /**
     * @param string $type
     * @return string
     */
    public function getRelationClass($type)
    {
        $class = 'Nip\Records\Relations\\' . ucfirst($type);

        return $class;
    }

    /**
     * @param $name
     * @param array $params
     * @return Relation
     * @throws \Exception
     */
    public function belongsTo($name, $params = [])
    {
        return $this->initRelation('belongsTo', $name, $params);
    }

    /**
     * @param $name
     * @param array $params
     * @return Relation
     * @throws \Exception
     */
    public function hasMany($name, $params = [])
    {
        return $this->initRelation('hasMany', $name, $params);
    }

    /** @noinspection PhpMethodNamingConventionInspection
     * @param $name
     * @param array $params
     * @return Relation
     * @throws \Exception
     */
    public function HABTM($name, $params = [])
    {
        return $this->initRelation('hasAndBelongsToMany', $name, $params);
    }

    /**
     * @param $name
     * @param array $params
     * @return Relation
     * @throws \Exception
     */
    public function morphTo($name, $params = [])
    {
        return $this->initRelation('morphTo', $name, $params);
    }

    /**
     * @param $name
     * @param array $params
     * @return Relation
     * @throws \Exception
     */
    public function morphMany($name, $params = [])
    {
        return $this->initRelation('morphMany', $name, $params);
    }

    /**
     * @param $name
     * @param array $params
     * @return Relation
     * @throws \Exception
     */
    public function morphToMany($name, $params = [])
    {
        return $this->initRelation('morphToMany', $name, $params);
    }

    /**
     * @param $name
     * @param array $params
     * @return MorphToMany
     * @throws \Exception
     */
    public function morphedByMany($name, $params = [])
    {
        /** @var MorphToMany $relation */
        $relation = $this->initRelation('morphToMany', $name, $params);
        $relation->setInverse(true);
        return $relation;
    }

    /**
     * Determine if the given relation is loaded.
     * @param  string $key
     * @return bool
     * @throws \Exception
     */
    public function hasRelation($key)
    {
        $this->checkInitRelations();

        return array_key_exists($key, $this->relations);
    }

    /**
     * Set the specific relationship in the model.
     * @param  string $relation
     * @param  mixed $value
     * @return $this
     * @throws \Exception
     */
    public function setRelation($relation, $value)
    {
        $this->checkInitRelations();
        $this->relations[$relation] = $value;

        return $this;
    }

    /**
     * @param HasRelationsRecordTrait $from

The type HasRelationsRecordTrait for parameter $from is a trait, and thus cannot be used for type-hinting in PHP. Maybe consider adding an interface and use that for type-hinting?

     * @param HasRelationsRecordTrait $to

The type HasRelationsRecordTrait for parameter $to is a trait, and thus cannot be used for type-hinting in PHP. Maybe consider adding an interface and use that for type-hinting?

     * @return HasRelationsRecordTrait

The return type HasRelationsRecordTrait is a trait, and thus cannot be used for type-hinting in PHP. Maybe consider adding an interface and use that for type-hinting?

     * @throws \Exception
     */
    public function cloneRelations($from, $to)
    {
        $relations = $from->getManager()->getRelations();

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

        foreach ($relations as $name => $relation) {
            /** @var \Nip\Records\Relations\HasMany $relation */
            if ($relation->getType() != 'belongsTo') {
                /** @var Record[] $associatedOld */
                $associatedOld = $from->{'get' . $name}();
                if (count($associatedOld)) {
                    $associatedNew = $to->getRelation($name)->newCollection();

It seems like you code against a specific sub-type and not the parent class Nip\Records\Relations\Relation as the method newCollection() does only exist in the following sub-classes of Nip\Records\Relations\Relation: Nip\Records\Relations\HasAndBelongsToMany, Nip\Records\Relations\HasMany, Nip\Records\Relations\HasOneOrMany, Nip\Records\Relations\MorphMany, Nip\Records\Relations\MorphOneOrMany, Nip\Records\Relations\MorphToMany. Maybe you want to instanceof check for one of these explicitly?

                    foreach ($associatedOld as $associated) {
                        $aItem = $associated->getCloneWithRelations();
                        $associatedNew[] = $aItem;
                    }
                    $to->getRelation($name)->setResults($associatedNew);
                }
            }
        }

        return $to;
    }

    /**
     * Get all the loaded relations for the instance.
     * @return array
     * @throws \Exception
     */
    public function getRelations()
    {
        $this->checkInitRelations();

        return $this->relations;
    }

    /**
     * Set the entire relations array on the model.
     * @param  array $relations
     * @return $this
     */
    public function setRelations(array $relations)
    {
        $this->relations = $relations;

        return $this;
    }
}