LaravelFreelancerNL\Aranguent\Eloquent\Concerns\HasRelationships

Complexity

Total Complexity

17

Size/Duplication

Total Lines	170
Duplicated Lines	0 %

Importance

Changes	2
Bugs	0	Features	0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	hasMany()	0	9	3
A	belongsTo()	0	24	4
A	hasOne()	0	9	3
A	newMorphTo()	0	9	1
A	morphMany()	0	12	2
A	newMorphMany()	0	3	1
A	morphOne()	0	9	2
A	newMorphOne()	0	3	1

<?php

namespace LaravelFreelancerNL\Aranguent\Eloquent\Concerns;

use Illuminate\Database\Eloquent\Builder as IlluminateBuilder;
use Illuminate\Database\Eloquent\Model as IlluminateModel;
use Illuminate\Support\Str;
use LaravelFreelancerNL\Aranguent\Eloquent\Relations\BelongsTo;
use LaravelFreelancerNL\Aranguent\Eloquent\Relations\HasOne;
use LaravelFreelancerNL\Aranguent\Eloquent\Relations\MorphOne;
use LaravelFreelancerNL\Aranguent\Eloquent\Relations\MorphTo;
use LaravelFreelancerNL\Aranguent\Eloquent\Relations\MorphMany;

trait HasRelationships
{
    /**
     * Define a one-to-one relationship.
     *
     * @param  string  $related
     * @param  string  $foreignKey
     * @param  string  $localKey
     * @return HasOne
     */
    public function hasOne($related, $foreignKey = null, $localKey = null)
    {
        $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?

        $foreignKey = $foreignKey ?: $this->getForeignKey();

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

        $localKey = $localKey ?: $this->getKeyName();

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

        return $this->newHasOne($instance->newQuery(), $this, $instance->qualifyColumn($foreignKey), $localKey);

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

    }

    /**
     * Define an inverse one-to-one or many relationship.
     *
     * @param  string  $related
     * @param  string  $foreignKey
     * @param  string  $ownerKey
     * @param  string  $relation
     * @return BelongsTo
     */
    public function belongsTo($related, $foreignKey = null, $ownerKey = null, $relation = null)
    {
        // If no relation name was given, we will use this debug backtrace to extract
        // the calling method's name and use that as the relationship name as most
        // of the time this will be what we desire to use for the relationships.
        if (is_null($relation)) {
            $relation = $this->guessBelongsToRelation();

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

        }

        $instance = $this->newRelatedInstance($related);

        // If no foreign key was supplied, we can use a backtrace to guess the proper
        // foreign key name by using the name of the relationship function, which
        // when combined with an "_id" should conventionally match the columns.
        if (is_null($foreignKey)) {
            $foreignKey = Str::snake($relation) . $instance->getKeyName();
        }

        // Once we have the foreign key names, we'll just create a new Eloquent query
        // for the related models and returns the relationship instance which will
        // actually be responsible for retrieving and hydrating every relations.
        $ownerKey = $ownerKey ?: $instance->getKeyName();

        return new BelongsTo($instance->newQuery(), $this, $foreignKey, $ownerKey, $relation);

$this of type LaravelFreelancerNL\Aranguent\Eloquent\Concerns\HasRelationships is incompatible with the type Illuminate\Database\Eloquent\Model expected by parameter $child of LaravelFreelancerNL\Aranguent\Eloquent\Relations\BelongsTo::__construct().

    }

    /**
     * Define a one-to-many relationship.
     *
     * @param  string  $related
     * @param  string|null  $foreignKey
     * @param  string|null  $localKey
     * @return \Illuminate\Database\Eloquent\Relations\HasMany
     */
    public function hasMany($related, $foreignKey = null, $localKey = null)
    {
        $instance = $this->newRelatedInstance($related);

        $foreignKey = $foreignKey ?: $this->getForeignKey();

        $localKey = $localKey ?: $this->getKeyName();

        return $this->newHasMany($instance->newQuery(), $this, $foreignKey, $localKey);

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

    }

    /**
     * Define a polymorphic one-to-one relationship.
     *
     * @param  string  $related
     * @param  string  $name
     * @param  string|null  $type
     * @param  string|null  $id
     * @param  string|null  $localKey
     * @return MorphOne
     */
    public function morphOne($related, $name, $type = null, $id = null, $localKey = null)
    {
        $instance = $this->newRelatedInstance($related);

        [$type, $id] = $this->getMorphs($name, $type, $id);

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

        $localKey = $localKey ?: $this->getKeyName();

        return $this->newMorphOne($instance->newQuery(), $this, $type, $id, $localKey);

$this of type LaravelFreelancerNL\Aranguent\Eloquent\Concerns\HasRelationships is incompatible with the type Illuminate\Database\Eloquent\Model expected by parameter $parent of LaravelFreelancerNL\Aranguent\Eloquent\Concerns\HasRelationships::newMorphOne().

    }

    /**
     * Instantiate a new MorphOne relationship.
     *
     * @param  IlluminateBuilder  $query
     * @param  IlluminateModel  $parent
     * @param  string  $type
     * @param  string  $id
     * @param  string  $localKey
     * @return MorphOne
     */
    protected function newMorphOne(IlluminateBuilder $query, IlluminateModel $parent, $type, $id, $localKey)
    {
        return new MorphOne($query, $parent, $type, $id, $localKey);
    }

    /**
     * Instantiate a new MorphTo relationship.
     *
     * @param  IlluminateBuilder  $query
     * @param  IlluminateModel  $parent
     * @param  string  $foreignKey
     * @param  string  $ownerKey
     * @param  string  $type
     * @param  string  $relation
     * @return MorphTo
     */
    protected function newMorphTo(
        IlluminateBuilder $query,
        IlluminateModel $parent,
        $foreignKey,
        $ownerKey,
        $type,
        $relation
    ) {
        return new MorphTo($query, $parent, $foreignKey, $ownerKey, $type, $relation);
    }

    /**
     * Define a polymorphic one-to-many relationship.
     *
     * @param  string  $related
     * @param  string  $name
     * @param  string|null  $type
     * @param  string|null  $id
     * @param  string|null  $localKey
     * @return MorphMany
     */
    public function morphMany($related, $name, $type = null, $id = null, $localKey = null)
    {
        $instance = $this->newRelatedInstance($related);

        // Here we will gather up the morph type and ID for the relationship so that we
        // can properly query the intermediate table of a relation. Finally, we will
        // get the table and create the relationship instances for the developers.
        [$type, $id] = $this->getMorphs($name, $type, $id);

        $localKey = $localKey ?: $this->getKeyName();

        return $this->newMorphMany($instance->newQuery(), $this, $type, $id, $localKey);

$this of type LaravelFreelancerNL\Aranguent\Eloquent\Concerns\HasRelationships is incompatible with the type Illuminate\Database\Eloquent\Model expected by parameter $parent of LaravelFreelancerNL\Aranguent\Eloquent\Concerns\HasRelationships::newMorphMany().

    }

    /**
     * Instantiate a new MorphMany relationship.
     *
     * @param  IlluminateBuilder  $query
     * @param  IlluminateModel  $parent
     * @param  string  $type
     * @param  string  $id
     * @param  string  $localKey
     * @return MorphMany
     */
    protected function newMorphMany(IlluminateBuilder $query, IlluminateModel $parent, $type, $id, $localKey)
    {
        return new MorphMany($query, $parent, $type, $id, $localKey);
    }
}