Imanghafoori\Relativity\BaseEloquentOverrides

Complexity

Total Complexity

14

Size/Duplication

Total Lines	88
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	1

Test Coverage

Coverage

68.18%

Importance

Changes

0

3 Methods

Rating	Name	Duplication	Size	Complexity
B	morphToMany()	0	26	7
A	morphedByMany()	0	15	3
A	getRelationValue()	0	16	4

<?php

namespace Imanghafoori\Relativity;

use Illuminate\Support\Str;

trait BaseEloquentOverrides
{
    /**
     * Define a polymorphic many-to-many relationship.
     *
     * @param  string  $related
     * @param  string  $name
     * @param  string  $table
     * @param  string  $foreignPivotKey
     * @param  string  $relatedPivotKey
     * @param  string  $parentKey
     * @param  string  $relatedKey
     * @param  bool  $inverse
     * @param  string  $caller
     * @return \Illuminate\Database\Eloquent\Relations\MorphToMany
     */
    public function morphToMany($related, $name, $table = null, $foreignPivotKey = null,
        $relatedPivotKey = null, $parentKey = null,
        $relatedKey = null, $inverse = false, $caller = null)
    {
        $caller = $caller ?: $this->guessBelongsToManyRelation();

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

        // First, we will need to determine the foreign key and "other key" for the
        // relationship. Once we have determined the keys we will make the query
        // instances, as well as the relationship instances we need for these.
        $instance = $this->newRelatedInstance($related);

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

        $foreignPivotKey = $foreignPivotKey ?: $name.'_id';

        $relatedPivotKey = $relatedPivotKey ?: $instance->getForeignKey();

        // Now we're ready to create a new query builder for this related model and
        // the relationship instances for this relation. This relations will set
        // appropriate query constraints then entirely manages the hydrations.
        $table = $table ?: Str::plural($name);

        return $this->newMorphToMany(

The method newMorphToMany() does not exist on Imanghafoori\Relativity\BaseEloquentOverrides. Did you maybe mean morphToMany()?

            $instance->newQuery(), $this, $name, $table,
            $foreignPivotKey, $relatedPivotKey, $parentKey ?: $this->getKeyName(),

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

            $relatedKey ?: $instance->getKeyName(), $caller, $inverse
        );
    }

    public function getRelationValue($key)
    {
        // If the key already exists in the relationships array, it just means the
        // relationship has already been loaded, so we'll just return it out of
        // here because there is no need to query within the relations twice.
        if ($this->relationLoaded($key)) {

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

            return $this->relations[$key];

The property relations does not exist. Did you maybe forget to declare it?

        }

        // If the "attribute" exists as a method on the model, we will just assume
        // it is a relationship and will load and return results from the query
        // and hydrate the relationship's value on the "relationships" array.
        if (method_exists($this, $key) or isset(static::$macros[$key])) {
            return $this->getRelationshipFromMethod($key);

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

        }
    }

    /**
     * Define a polymorphic, inverse many-to-many relationship.
     *
     * @param  string  $related
     * @param  string  $name
     * @param  string  $table
     * @param  string  $foreignPivotKey
     * @param  string  $relatedPivotKey
     * @param  string  $parentKey
     * @param  string  $relatedKey
     * @return \Illuminate\Database\Eloquent\Relations\MorphToMany
     */
    public function morphedByMany($related, $name, $table = null, $foreignPivotKey = null,
        $relatedPivotKey = null, $parentKey = null, $relatedKey = null, $caller = null)
    {
        $foreignPivotKey = $foreignPivotKey ?: $this->getForeignKey();

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

        // For the inverse of the polymorphic many-to-many relations, we will change
        // the way we determine the foreign and other keys, as it is the opposite
        // of the morph-to-many method since we're figuring out these inverses.
        $relatedPivotKey = $relatedPivotKey ?: $name.'_id';

        return $this->morphToMany(
            $related, $name, $table, $foreignPivotKey,
            $relatedPivotKey, $parentKey, $relatedKey, true, $caller
        );
    }
}