Volosyuk\SimpleEloquent\Relations\Relation

Complexity

Total Complexity

10

Size/Duplication

Total Lines	79
Duplicated Lines	0 %

Test Coverage

Coverage

72.72%

Importance

Changes

0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	buildMorphMapFromModels()	0	9	3
A	addEagerConstraintsSimple()	0	3	1
A	getKeys()	0	5	2
A	eagerLoadAndMatchSimple()	0	5	1
A	initSimpleRelation()	0	8	2
A	getEagerSimple()	0	3	1

<?php

namespace Volosyuk\SimpleEloquent\Relations;

use Illuminate\Database\Eloquent\Model;
use Illuminate\Support\Arr;
use Illuminate\Support\Collection;
use stdClass;
use Volosyuk\SimpleEloquent\Builder;
use Volosyuk\SimpleEloquent\ModelAccessor;

/**
 * Trait SimpleRelation
 * @package Volosyuk\SimpleEloquent
 *
 * @property Builder $query
 * @property Model $parent
 */
trait Relation
{
    /**
     * @param $models
     * @param $name
     * @return array
     */
    public function eagerLoadAndMatchSimple($models, $name)
    {
        $results = $this->getEagerSimple();

        return $this->matchSimple($models, $results, $name);

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

    }

    /**
     * @param array $models
     * @param $relation
     * @return array|stdClass[]
     */
    public function initSimpleRelation(array &$models, $relation)
    {
        foreach ($models as &$model) {
            ModelAccessor::set($model, $relation, null);
        }
        unset($model);

        return $models;
    }

    /**
     * Get the relationship for eager loading.
     *
     * @return Collection
     */
    protected function getEagerSimple()
    {
        return $this->getSimple();

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

    }

    /**
     * Get all of the primary keys for an array of models.
     *
     * @param  array   $models
     * @param  string  $key
     * @return array
     */
    protected function getKeys(array $models, $key = null)
    {
        return array_unique(array_values(array_map(function ($value) use ($key) {
            return $key ? ModelAccessor::get($value, $key) : ModelAccessor::get($value, $this->parent->getKeyName());
        }, $models)));
    }

    /**
     * Set the constraints for an eager load of the relation.
     *
     * @param  array  $models
     * @return void
     */
    public function addEagerConstraintsSimple(array $models)
    {
        $this->query->whereIn($this->getQualifiedForeignKeyName(), $this->getKeys($models));

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

The method whereIn() does not exist on Volosyuk\SimpleEloquent\Builder. Since you implemented __call, consider adding a @method annotation.

    }

    /**
     * Builds a table-keyed array from model class names.
     *
     * @param  string[]|null  $models
     * @return array|null
     */
    protected static function buildMorphMapFromModels(array $models = null)
    {
        if (is_null($models) || Arr::isAssoc($models)) {
            return $models;
        }

        return array_combine(array_map(function ($model) {
            return (new $model)->getTable();
        }, $models), $models);
    }
}