ConcatenatesRelationships::hasOneOrManyDeepFromHasOneOrMany() - Code Metrics - Inspection of "Add reverse relationships" - staudenmeir/eloquent-has-many-deep - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 81d2d7...2ca0db )

by Jonas

created 2022-06-25 11:28 UTC

hasOneOrManyDeepFromHasOneOrMany() A

↳ Parent: ConcatenatesRelationships

Complexity

Conditions	1
Paths	1

Size

Total Lines	7
Code Lines	3

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	4
CRAP Score	1

Importance

Changes

Metric	Value
cc	1
eloc	3
nc	1
nop	4
dl	0
loc	7
ccs	4
cts	4
cp	1
crap	1
rs	10
c	0
b	0
f	0

<?php

namespace Staudenmeir\EloquentHasManyDeep\Traits;

use Illuminate\Database\Eloquent\Relations\BelongsTo;
use Illuminate\Database\Eloquent\Relations\BelongsToMany;
use Illuminate\Database\Eloquent\Relations\HasManyThrough;
use Illuminate\Database\Eloquent\Relations\HasOneOrMany;
use Illuminate\Database\Eloquent\Relations\MorphOneOrMany;
use Illuminate\Database\Eloquent\Relations\MorphToMany;
use Illuminate\Database\Eloquent\Relations\Pivot;
use Illuminate\Database\Eloquent\Relations\Relation;
use RuntimeException;
use Staudenmeir\EloquentHasManyDeep\HasManyDeep;

trait ConcatenatesRelationships
{
    /**
     * Prepare a has-one-deep or has-many-deep relationship from existing relationships.
     *
     * @param \Illuminate\Database\Eloquent\Relations\Relation[] $relations
     * @return array
     */
    protected function hasOneOrManyDeepFromRelations(array $relations)
    {
        if (is_array($relations[0])) {

            $relations = $relations[0];
        }

        $related = null;
        $through = [];
        $foreignKeys = [];
        $localKeys = [];

        foreach ($relations as $i => $relation) {
            $method = $this->hasOneOrManyDeepRelationMethod($relation);

            [$through, $foreignKeys, $localKeys] = $this->$method($relation, $through, $foreignKeys, $localKeys);

            if ($i === count($relations) - 1) {
                $related = get_class($relation->getRelated());

                if ((new $related())->getTable() !== $relation->getRelated()->getTable()) {
                    $related .= ' from ' . $relation->getRelated()->getTable();
                }
            } else {
                $through[] = $this->hasOneOrManyThroughParent($relation, $relations[$i + 1]);
            }
        }

        return [$related, $through, $foreignKeys, $localKeys];
    }

    /**
     * Prepare a has-one-deep or has-many-deep relationship from an existing belongs-to relationship.
     *
     * @param \Illuminate\Database\Eloquent\Relations\BelongsTo $relation
     * @param \Illuminate\Database\Eloquent\Model[] $through
     * @param array $foreignKeys
     * @param array $localKeys
     * @return array
     */
    protected function hasOneOrManyDeepFromBelongsTo(BelongsTo $relation, array $through, array $foreignKeys, array $localKeys)
    {
        $foreignKeys[] = $relation->getOwnerKeyName();

        $localKeys[] = $relation->getForeignKeyName();

        return [$through, $foreignKeys, $localKeys];
    }

    /**
     * Prepare a has-one-deep or has-many-deep relationship from an existing belongs-to-many relationship.
     *
     * @param \Illuminate\Database\Eloquent\Relations\BelongsToMany $relation
     * @param \Illuminate\Database\Eloquent\Model[] $through
     * @param array $foreignKeys
     * @param array $localKeys
     * @return array
     */
    protected function hasOneOrManyDeepFromBelongsToMany(BelongsToMany $relation, array $through, array $foreignKeys, array $localKeys)
    {
        $through[] = $relation->getTable();

        $foreignKeys[] = $relation->getForeignPivotKeyName();
        $foreignKeys[] = $relation->getRelatedKeyName();

        $localKeys[] = $relation->getParentKeyName();
        $localKeys[] = $relation->getRelatedPivotKeyName();

        return [$through, $foreignKeys, $localKeys];
    }

    /**
     * Prepare a has-one-deep or has-many-deep relationship from an existing has-one or has-many relationship.
     *
     * @param \Illuminate\Database\Eloquent\Relations\HasOneOrMany $relation
     * @param \Illuminate\Database\Eloquent\Model[] $through
     * @param array $foreignKeys
     * @param array $localKeys
     * @return array
     */
    protected function hasOneOrManyDeepFromHasOneOrMany(HasOneOrMany $relation, array $through, array $foreignKeys, array $localKeys)
    {
        $foreignKeys[] = $relation->getQualifiedForeignKeyName();

        $localKeys[] = $relation->getLocalKeyName();

        return [$through, $foreignKeys, $localKeys];
    }

    /**
     * Prepare a has-one-deep or has-many-deep relationship from an existing has-many-through relationship.
     *
     * @param \Illuminate\Database\Eloquent\Relations\HasManyThrough $relation
     * @param \Illuminate\Database\Eloquent\Model[] $through
     * @param array $foreignKeys
     * @param array $localKeys
     * @return array
     */
    protected function hasOneOrManyDeepFromHasManyThrough(HasManyThrough $relation, array $through, array $foreignKeys, array $localKeys)
    {
        $through[] = get_class($relation->getParent());

        $foreignKeys[] = $relation->getFirstKeyName();
        $foreignKeys[] = $relation->getForeignKeyName();

        $localKeys[] = $relation->getLocalKeyName();
        $localKeys[] = $relation->getSecondLocalKeyName();

        return [$through, $foreignKeys, $localKeys];
    }

    /**
     * Prepare a has-one-deep or has-many-deep relationship from an existing has-many-deep relationship.
     *
     * @param \Staudenmeir\EloquentHasManyDeep\HasManyDeep $relation
     * @param \Illuminate\Database\Eloquent\Model[] $through
     * @param array $foreignKeys
     * @param array $localKeys
     * @return array
     */
    protected function hasOneOrManyDeepFromHasManyDeep(HasManyDeep $relation, array $through, array $foreignKeys, array $localKeys)
    {
        foreach ($relation->getThroughParents() as $throughParent) {
            $segments = explode(' as ', $throughParent->getTable());

            $class = get_class($throughParent);

            if (isset($segments[1])) {
                $class .= ' as '.$segments[1];
            } elseif ($throughParent instanceof Pivot) {
                $class = $throughParent->getTable();
            }

            $through[] = $class;
        }

        $foreignKeys = array_merge($foreignKeys, $relation->getForeignKeys());

        $localKeys = array_merge($localKeys, $relation->getLocalKeys());

        return [$through, $foreignKeys, $localKeys];
    }

    /**
     * Prepare a has-one-deep or has-many-deep relationship from an existing morph-one or morph-many relationship.
     *
     * @param \Illuminate\Database\Eloquent\Relations\MorphOneOrMany $relation
     * @param \Illuminate\Database\Eloquent\Model[] $through
     * @param array $foreignKeys
     * @param array $localKeys
     * @return array
     */
    protected function hasOneOrManyDeepFromMorphOneOrMany(MorphOneOrMany $relation, array $through, array $foreignKeys, array $localKeys)
    {
        $foreignKeys[] = [$relation->getQualifiedMorphType(), $relation->getQualifiedForeignKeyName()];

        $localKeys[] = $relation->getLocalKeyName();

        return [$through, $foreignKeys, $localKeys];
    }

    /**
     * Prepare a has-one-deep or has-many-deep relationship from an existing morph-to-many relationship.
     *
     * @param \Illuminate\Database\Eloquent\Relations\MorphToMany $relation
     * @param \Illuminate\Database\Eloquent\Model[] $through
     * @param array $foreignKeys
     * @param array $localKeys
     * @return array
     */
    protected function hasOneOrManyDeepFromMorphToMany(MorphToMany $relation, array $through, array $foreignKeys, array $localKeys)
    {
        $through[] = $relation->getTable();

        if ($relation->getInverse()) {
            $foreignKeys[] = $relation->getForeignPivotKeyName();
            $foreignKeys[] = $relation->getRelatedKeyName();

            $localKeys[] = $relation->getParentKeyName();
            $localKeys[] = [$relation->getMorphType(), $relation->getRelatedPivotKeyName()];
        } else {
            $foreignKeys[] = [$relation->getMorphType(), $relation->getForeignPivotKeyName()];
            $foreignKeys[] = $relation->getRelatedKeyName();

            $localKeys[] = $relation->getParentKeyName();
            $localKeys[] = $relation->getRelatedPivotKeyName();
        }

        return [$through, $foreignKeys, $localKeys];
    }

    /**
     * Get the relationship method name.
     *
     * @param \Illuminate\Database\Eloquent\Relations\Relation $relation
     * @return string
     */
    protected function hasOneOrManyDeepRelationMethod(Relation $relation)
    {
        $classes = [
            BelongsTo::class,
            HasManyDeep::class,
            HasManyThrough::class,
            MorphOneOrMany::class,
            HasOneOrMany::class,
            MorphToMany::class,
            BelongsToMany::class,
        ];

        foreach ($classes as $class) {
            if ($relation instanceof $class) {
                return 'hasOneOrManyDeepFrom'.class_basename($class);
            }
        }

        throw new RuntimeException('This relationship is not supported.'); // @codeCoverageIgnore
    }

    /**
     * Prepare the through parent class from an existing relationship and its successor.
     *
     * @param \Illuminate\Database\Eloquent\Relations\Relation $relation
     * @param \Illuminate\Database\Eloquent\Relations\Relation $successor
     * @return string
     */
    protected function hasOneOrManyThroughParent(Relation $relation, Relation $successor)
    {
        $through = get_class($relation->getRelated());

        if ((new $through())->getTable() !== $relation->getRelated()->getTable()) {
            $through .= ' from ' . $relation->getRelated()->getTable();
        }

        if (get_class($relation->getRelated()) === get_class($successor->getParent())) {
            $table = $successor->getParent()->getTable();

            $segments = explode(' as ', $table);

            if (isset($segments[1])) {
                $through .= ' as '.$segments[1];
            }
        }

        return $through;
    }
}


1		<?php
2
3		namespace Staudenmeir\EloquentHasManyDeep\Traits;
4
5		use Illuminate\Database\Eloquent\Relations\BelongsTo;
6		use Illuminate\Database\Eloquent\Relations\BelongsToMany;
7		use Illuminate\Database\Eloquent\Relations\HasManyThrough;
8		use Illuminate\Database\Eloquent\Relations\HasOneOrMany;
9		use Illuminate\Database\Eloquent\Relations\MorphOneOrMany;
10		use Illuminate\Database\Eloquent\Relations\MorphToMany;
11		use Illuminate\Database\Eloquent\Relations\Pivot;
12		use Illuminate\Database\Eloquent\Relations\Relation;
13		use RuntimeException;
14		use Staudenmeir\EloquentHasManyDeep\HasManyDeep;
15
16		trait ConcatenatesRelationships
17		{
18		/**
19		* Prepare a has-one-deep or has-many-deep relationship from existing relationships.
20		*
21		* @param \Illuminate\Database\Eloquent\Relations\Relation[] $relations
22		* @return array
23		*/
24	13	protected function hasOneOrManyDeepFromRelations(array $relations)
25		{
26	13	if (is_array($relations[0])) {
		0 ignored issues – show introduced 2018-11-30 03:19 UTC by Report Bug Copy Issue Report The condition `is_array($relations[0])` is always `false`. Loading history...
27	5	$relations = $relations[0];
28		}
29
30	13	$related = null;
31	13	$through = [];
32	13	$foreignKeys = [];
33	13	$localKeys = [];
34
35	13	foreach ($relations as $i => $relation) {
36	13	$method = $this->hasOneOrManyDeepRelationMethod($relation);
37
38	13	[$through, $foreignKeys, $localKeys] = $this->$method($relation, $through, $foreignKeys, $localKeys);
39
40	13	if ($i === count($relations) - 1) {
41	13	$related = get_class($relation->getRelated());
42
43	13	if ((new $related())->getTable() !== $relation->getRelated()->getTable()) {
44	13	$related .= ' from ' . $relation->getRelated()->getTable();
45		}
46		} else {
47	11	$through[] = $this->hasOneOrManyThroughParent($relation, $relations[$i + 1]);
48		}
49		}
50
51	13	return [$related, $through, $foreignKeys, $localKeys];
52		}
53
54		/**
55		* Prepare a has-one-deep or has-many-deep relationship from an existing belongs-to relationship.
56		*
57		* @param \Illuminate\Database\Eloquent\Relations\BelongsTo $relation
58		* @param \Illuminate\Database\Eloquent\Model[] $through
59		* @param array $foreignKeys
60		* @param array $localKeys
61		* @return array
62		*/
63	1	protected function hasOneOrManyDeepFromBelongsTo(BelongsTo $relation, array $through, array $foreignKeys, array $localKeys)
64		{
65	1	$foreignKeys[] = $relation->getOwnerKeyName();
66
67	1	$localKeys[] = $relation->getForeignKeyName();
68
69	1	return [$through, $foreignKeys, $localKeys];
70		}
71
72		/**
73		* Prepare a has-one-deep or has-many-deep relationship from an existing belongs-to-many relationship.
74		*
75		* @param \Illuminate\Database\Eloquent\Relations\BelongsToMany $relation
76		* @param \Illuminate\Database\Eloquent\Model[] $through
77		* @param array $foreignKeys
78		* @param array $localKeys
79		* @return array
80		*/
81	1	protected function hasOneOrManyDeepFromBelongsToMany(BelongsToMany $relation, array $through, array $foreignKeys, array $localKeys)
82		{
83	1	$through[] = $relation->getTable();
84
85	1	$foreignKeys[] = $relation->getForeignPivotKeyName();
86	1	$foreignKeys[] = $relation->getRelatedKeyName();
87
88	1	$localKeys[] = $relation->getParentKeyName();
89	1	$localKeys[] = $relation->getRelatedPivotKeyName();
90
91	1	return [$through, $foreignKeys, $localKeys];
92		}
93
94		/**
95		* Prepare a has-one-deep or has-many-deep relationship from an existing has-one or has-many relationship.
96		*
97		* @param \Illuminate\Database\Eloquent\Relations\HasOneOrMany $relation
98		* @param \Illuminate\Database\Eloquent\Model[] $through
99		* @param array $foreignKeys
100		* @param array $localKeys
101		* @return array
102		*/
103	10	protected function hasOneOrManyDeepFromHasOneOrMany(HasOneOrMany $relation, array $through, array $foreignKeys, array $localKeys)
104		{
105	10	$foreignKeys[] = $relation->getQualifiedForeignKeyName();
106
107	10	$localKeys[] = $relation->getLocalKeyName();
108
109	10	return [$through, $foreignKeys, $localKeys];
110		}
111
112		/**
113		* Prepare a has-one-deep or has-many-deep relationship from an existing has-many-through relationship.
114		*
115		* @param \Illuminate\Database\Eloquent\Relations\HasManyThrough $relation
116		* @param \Illuminate\Database\Eloquent\Model[] $through
117		* @param array $foreignKeys
118		* @param array $localKeys
119		* @return array
120		*/
121	6	protected function hasOneOrManyDeepFromHasManyThrough(HasManyThrough $relation, array $through, array $foreignKeys, array $localKeys)
122		{
123	6	$through[] = get_class($relation->getParent());
124
125	6	$foreignKeys[] = $relation->getFirstKeyName();
126	6	$foreignKeys[] = $relation->getForeignKeyName();
127
128	6	$localKeys[] = $relation->getLocalKeyName();
129	6	$localKeys[] = $relation->getSecondLocalKeyName();
130
131	6	return [$through, $foreignKeys, $localKeys];
132		}
133
134		/**
135		* Prepare a has-one-deep or has-many-deep relationship from an existing has-many-deep relationship.
136		*
137		* @param \Staudenmeir\EloquentHasManyDeep\HasManyDeep $relation
138		* @param \Illuminate\Database\Eloquent\Model[] $through
139		* @param array $foreignKeys
140		* @param array $localKeys
141		* @return array
142		*/
143	2	protected function hasOneOrManyDeepFromHasManyDeep(HasManyDeep $relation, array $through, array $foreignKeys, array $localKeys)
144		{
145	2	foreach ($relation->getThroughParents() as $throughParent) {
146	2	$segments = explode(' as ', $throughParent->getTable());
147
148	2	$class = get_class($throughParent);
149
150	2	if (isset($segments[1])) {
151	1	$class .= ' as '.$segments[1];
152	2	} elseif ($throughParent instanceof Pivot) {
153	1	$class = $throughParent->getTable();
154		}
155
156	2	$through[] = $class;
157		}
158
159	2	$foreignKeys = array_merge($foreignKeys, $relation->getForeignKeys());
160
161	2	$localKeys = array_merge($localKeys, $relation->getLocalKeys());
162
163	2	return [$through, $foreignKeys, $localKeys];
164		}
165
166		/**
167		* Prepare a has-one-deep or has-many-deep relationship from an existing morph-one or morph-many relationship.
168		*
169		* @param \Illuminate\Database\Eloquent\Relations\MorphOneOrMany $relation
170		* @param \Illuminate\Database\Eloquent\Model[] $through
171		* @param array $foreignKeys
172		* @param array $localKeys
173		* @return array
174		*/
175	1	protected function hasOneOrManyDeepFromMorphOneOrMany(MorphOneOrMany $relation, array $through, array $foreignKeys, array $localKeys)
176		{
177	1	$foreignKeys[] = [$relation->getQualifiedMorphType(), $relation->getQualifiedForeignKeyName()];
178
179	1	$localKeys[] = $relation->getLocalKeyName();
180
181	1	return [$through, $foreignKeys, $localKeys];
182		}
183
184		/**
185		* Prepare a has-one-deep or has-many-deep relationship from an existing morph-to-many relationship.
186		*
187		* @param \Illuminate\Database\Eloquent\Relations\MorphToMany $relation
188		* @param \Illuminate\Database\Eloquent\Model[] $through
189		* @param array $foreignKeys
190		* @param array $localKeys
191		* @return array
192		*/
193	2	protected function hasOneOrManyDeepFromMorphToMany(MorphToMany $relation, array $through, array $foreignKeys, array $localKeys)
194		{
195	2	$through[] = $relation->getTable();
196
197	2	if ($relation->getInverse()) {
198	1	$foreignKeys[] = $relation->getForeignPivotKeyName();
199	1	$foreignKeys[] = $relation->getRelatedKeyName();
200
201	1	$localKeys[] = $relation->getParentKeyName();
202	1	$localKeys[] = [$relation->getMorphType(), $relation->getRelatedPivotKeyName()];
203		} else {
204	1	$foreignKeys[] = [$relation->getMorphType(), $relation->getForeignPivotKeyName()];
205	1	$foreignKeys[] = $relation->getRelatedKeyName();
206
207	1	$localKeys[] = $relation->getParentKeyName();
208	1	$localKeys[] = $relation->getRelatedPivotKeyName();
209		}
210
211	2	return [$through, $foreignKeys, $localKeys];
212		}
213
214		/**
215		* Get the relationship method name.
216		*
217		* @param \Illuminate\Database\Eloquent\Relations\Relation $relation
218		* @return string
219		*/
220	13	protected function hasOneOrManyDeepRelationMethod(Relation $relation)
221		{
222	13	$classes = [
223		BelongsTo::class,
224		HasManyDeep::class,
225		HasManyThrough::class,
226		MorphOneOrMany::class,
227		HasOneOrMany::class,
228		MorphToMany::class,
229		BelongsToMany::class,
230		];
231
232	13	foreach ($classes as $class) {
233	13	if ($relation instanceof $class) {
234	13	return 'hasOneOrManyDeepFrom'.class_basename($class);
235		}
236		}
237
238		throw new RuntimeException('This relationship is not supported.'); // @codeCoverageIgnore
239		}
240
241		/**
242		* Prepare the through parent class from an existing relationship and its successor.
243		*
244		* @param \Illuminate\Database\Eloquent\Relations\Relation $relation
245		* @param \Illuminate\Database\Eloquent\Relations\Relation $successor
246		* @return string
247		*/
248	11	protected function hasOneOrManyThroughParent(Relation $relation, Relation $successor)
249		{
250	11	$through = get_class($relation->getRelated());
251
252	11	if ((new $through())->getTable() !== $relation->getRelated()->getTable()) {
253	2	$through .= ' from ' . $relation->getRelated()->getTable();
254		}
255
256	11	if (get_class($relation->getRelated()) === get_class($successor->getParent())) {
257	8	$table = $successor->getParent()->getTable();
258
259	8	$segments = explode(' as ', $table);
260
261	8	if (isset($segments[1])) {
262	1	$through .= ' as '.$segments[1];
263		}
264		}
265
266	11	return $through;
267		}
268		}
269

staudenmeir / eloquent-has-many-deep

Push — master ( 81d2d7...2ca0db )

hasOneOrManyDeepFromHasOneOrMany() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like