HasRelationships::hasMany() - Code Metrics - Inspection of "Updated migration stub filenames." - LaravelFreelancerNL/laravel-arangodb - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Push — master ( 0ba402...934d75 )

by Bas
created 2020-05-20 06:36 UTC
HasRelationships::hasMany() A

↳ Parent: HasRelationships
Complexity

Conditions	3
Paths	1
Size

Total Lines	9
Code Lines	4
Duplication

Lines	0
Ratio	0 %
Importance

Changes	1
Bugs	0	Features	0
Metric	Value
cc	3
eloc	4
nc	1
nop	3
dl	0
loc	9
rs	10
c	1
b	0
f	0
<?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);
        $instance = $this->newRelatedInstance($related);

        $foreignKey = $foreignKey ?: $this->getForeignKey();
        $foreignKey = $foreignKey ?: $this->/** @scrutinizer ignore-call */ getForeignKey();

        $localKey = $localKey ?: $this->getKeyName();
        $localKey = $localKey ?: $this->/** @scrutinizer ignore-call */ getKeyName();

        return $this->newHasOne($instance->newQuery(), $this, $instance->qualifyColumn($foreignKey), $localKey);
        return $this->/** @scrutinizer ignore-call */ newHasOne($instance->newQuery(), $this, $instance->qualifyColumn($foreignKey), $localKey);
    }

    /**
     * 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();
            $relation = $this->guessBelongsToRelation();
        }

        $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);
        return new BelongsTo($instance->newQuery(), /** @scrutinizer ignore-type */ $this, $foreignKey, $ownerKey, $relation);
    }

    /**
     * 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);
        return $this->/** @scrutinizer ignore-call */ newHasMany($instance->newQuery(), $this, $foreignKey, $localKey);
    }

    /**
     * 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);
        [$type, $id] = $this->getMorphs($name, $type, $id);

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

        return $this->newMorphOne($instance->newQuery(), $this, $type, $id, $localKey);
        return $this->newMorphOne($instance->newQuery(), /** @scrutinizer ignore-type */ $this, $type, $id, $localKey);
    }

    /**
     * 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);
        return $this->newMorphMany($instance->newQuery(), /** @scrutinizer ignore-type */ $this, $type, $id, $localKey);
    }

    /**
     * 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);
    }
}

LaravelFreelancerNL / laravel-arangodb

Push — master ( 0ba402...934d75 )

HasRelationships::hasMany() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
