HasManyDeep::get() - Code Metrics - Inspection of "Refactoring" - staudenmeir/eloquent-has-many-deep - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 8684f9...1eb973 )

by Jonas

created 2022-11-19 12:10 UTC

HasManyDeep::get() A

↳ Parent: HasManyDeep

Complexity

Conditions	2
Paths	2

Size

Total Lines	11
Code Lines	5

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	6
CRAP Score	2

Importance

Changes

Metric	Value
cc	2
eloc	5
nc	2
nop	1
dl	0
loc	11
ccs	6
cts	6
cp	1
crap	2
rs	10
c	0
b	0
f	0

<?php

namespace Staudenmeir\EloquentHasManyDeep;

use Closure;
use Exception;
use Illuminate\Database\Eloquent\Builder;
use Illuminate\Database\Eloquent\Collection;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\Relations\HasManyThrough;
use Staudenmeir\EloquentHasManyDeep\Eloquent\Relations\Traits\ExecutesQueries;
use Staudenmeir\EloquentHasManyDeep\Eloquent\Relations\Traits\HasEagerLimit;
use Staudenmeir\EloquentHasManyDeep\Eloquent\Relations\Traits\IsConcatenable;
use Staudenmeir\EloquentHasManyDeep\Eloquent\Relations\Traits\JoinsThroughParents;
use Staudenmeir\EloquentHasManyDeep\Eloquent\Relations\Traits\RetrievesIntermediateTables;
use Staudenmeir\EloquentHasManyDeep\Eloquent\Relations\Traits\SupportsCompositeKeys;
use Staudenmeir\EloquentHasManyDeep\Eloquent\Relations\Traits\IsCustomizable;
use Staudenmeir\EloquentHasManyDeepContracts\Interfaces\ConcatenableRelation;

/**
 * @template TRelatedModel of \Illuminate\Database\Eloquent\Model
 * @extends \Illuminate\Database\Eloquent\Relations\Relation<TRelatedModel>
 */
class HasManyDeep extends HasManyThrough implements ConcatenableRelation
{
    use ExecutesQueries;
    use HasEagerLimit;

    use IsConcatenable;
    use IsCustomizable;
    use JoinsThroughParents;

    use RetrievesIntermediateTables;
    use SupportsCompositeKeys;


    /**
     * The "through" parent model instances.
     *
     * @var \Illuminate\Database\Eloquent\Model[]
     */
    protected $throughParents;

    /**
     * The foreign keys on the relationship.
     *
     * @var array
     */
    protected $foreignKeys;

    /**
     * The local keys on the relationship.
     *
     * @var array
     */
    protected $localKeys;

    /**
     * Create a new has many deep relationship instance.
     *
     * @param \Illuminate\Database\Eloquent\Builder $query
     * @param \Illuminate\Database\Eloquent\Model $farParent
     * @param \Illuminate\Database\Eloquent\Model[] $throughParents
     * @param array $foreignKeys
     * @param array $localKeys
     * @return void
     */
    public function __construct(Builder $query, Model $farParent, array $throughParents, array $foreignKeys, array $localKeys)
    {
        $this->throughParents = $throughParents;
        $this->foreignKeys = $foreignKeys;
        $this->localKeys = $localKeys;

        $firstKey = is_array($foreignKeys[0])
            ? $foreignKeys[0][1]
            : ($this->hasLeadingCompositeKey() ? $foreignKeys[0]->columns[0] : $foreignKeys[0]);

        $localKey = $this->hasLeadingCompositeKey() ? $localKeys[0]->columns[0] : $localKeys[0];

        parent::__construct($query, $farParent, $throughParents[0], $firstKey, $foreignKeys[1], $localKey, $localKeys[1]);
    }

    /**
     * Set the base constraints on the relation query.
     *
     * @return void
     */
    public function addConstraints()
    {
        if ($this->firstKey instanceof Closure || $this->localKey instanceof Closure) {

            $this->performJoin();
        } else {
            parent::addConstraints();
        }

        if (static::$constraints) {
            if ($this->firstKey instanceof Closure) {

                ($this->firstKey)($this->query);
            } elseif ($this->localKey instanceof Closure) {

                ($this->localKey)($this->query);
            } elseif (is_array($this->foreignKeys[0])) {
                $this->query->where(
                    $this->throughParent->qualifyColumn($this->foreignKeys[0][0]),
                    '=',
                    $this->farParent->getMorphClass()
                );
            } elseif ($this->hasLeadingCompositeKey()) {
                $this->addConstraintsWithCompositeKey();
            }
        }
    }

    /**
     * Set the join clauses on the query.
     *
     * @param \Illuminate\Database\Eloquent\Builder|null $query
     * @return void
     */
    protected function performJoin(Builder $query = null)
    {
        $query = $query ?: $this->query;

        $throughParents = array_reverse($this->throughParents);
        $foreignKeys = array_reverse($this->foreignKeys);
        $localKeys = array_reverse($this->localKeys);

        $segments = explode(' as ', $query->getQuery()->from);

        $alias = $segments[1] ?? null;

        foreach ($throughParents as $i => $throughParent) {
            $predecessor = $throughParents[$i - 1] ?? $this->related;

            $prefix = $i === 0 && $alias ? $alias.'.' : '';

            $this->joinThroughParent($query, $throughParent, $predecessor, $foreignKeys[$i], $localKeys[$i], $prefix);
        }
    }

    /**
     * Set the constraints for an eager load of the relation.
     *
     * @param array $models
     * @return void
     */
    public function addEagerConstraints(array $models)
    {
        if ($this->customEagerConstraintsCallback) {
            ($this->customEagerConstraintsCallback)($this->query, $models);
            return;
        }

        if ($this->hasLeadingCompositeKey()) {
            $this->addEagerConstraintsWithCompositeKey($models);
        } else {
            parent::addEagerConstraints($models);

            if (is_array($this->foreignKeys[0])) {
                $this->query->where(
                    $this->throughParent->qualifyColumn($this->foreignKeys[0][0]),
                    '=',
                    $this->farParent->getMorphClass()
                );
            }
        }
    }

    /**
     * Match the eagerly loaded results to their parents.
     *
     * @param array $models
     * @param \Illuminate\Database\Eloquent\Collection $results
     * @param string $relation
     * @return array
     */
    public function match(array $models, Collection $results, $relation)
    {
        if ($this->customEagerMatchingCallbacks) {

            foreach ($this->customEagerMatchingCallbacks as $callback) {
                $models = $callback($models, $results, $relation);
            }

            return $models;
        }

        if ($this->hasLeadingCompositeKey()) {
            return $this->matchWithCompositeKey($models, $results, $relation);
        }

        return parent::match($models, $results, $relation);
    }

    /**
     * Set the select clause for the relation query.
     *
     * @param array $columns
     * @return array
     */
    protected function shouldSelect(array $columns = ['*'])
    {
        if ($columns == ['*']) {
            $columns = [$this->related->getTable().'.*'];
        }

        $alias = 'laravel_through_key';

        if ($this->customThroughKeyCallback) {
            $columns[] = ($this->customThroughKeyCallback)($alias);
        } else {
            $columns[] = $this->getQualifiedFirstKeyName() . " as $alias";
        }

        if ($this->hasLeadingCompositeKey()) {
            $columns = array_merge(
                $columns,
                $this->shouldSelectWithCompositeKey()
            );
        }

        return array_merge($columns, $this->intermediateColumns());
    }

    /**
     * Add the constraints for a relationship query.
     *
     * @param \Illuminate\Database\Eloquent\Builder $query
     * @param \Illuminate\Database\Eloquent\Builder $parentQuery
     * @param array|mixed $columns
     * @return \Illuminate\Database\Eloquent\Builder
     */
    public function getRelationExistenceQuery(Builder $query, Builder $parentQuery, $columns = ['*'])
    {
        foreach ($this->throughParents as $throughParent) {
            if ($throughParent->getTable() === $parentQuery->getQuery()->from) {
                if (!in_array(HasTableAlias::class, class_uses_recursive($throughParent))) {
                    $traitClass = HasTableAlias::class;
                    $parentClass = get_class($throughParent);

                    throw new Exception(
                        <<<EOT
This query requires an additional trait. Please add the $traitClass trait to $parentClass.
See https://github.com/staudenmeir/eloquent-has-many-deep/issues/137 for details.
EOT
                    );
                }

                $table = $throughParent->getTable() . ' as ' . $this->getRelationCountHash();

                $throughParent->setTable($table);

                break;
            }
        }

        if ($this->firstKey instanceof Closure || $this->localKey instanceof Closure) {

            $this->performJoin($query);

            $closureKey = $this->firstKey instanceof Closure ? $this->firstKey : $this->localKey;

            $closureKey($query, $parentQuery);

            return $query->select($columns);
        }

        $query = parent::getRelationExistenceQuery($query, $parentQuery, $columns);

        if (is_array($this->foreignKeys[0])) {
            $column = $this->throughParent->qualifyColumn($this->foreignKeys[0][0]);

            $query->where($column, '=', $this->farParent->getMorphClass());
        } elseif ($this->hasLeadingCompositeKey()) {
            $this->getRelationExistenceQueryWithCompositeKey($query);
        }

        return $query;
    }

    /**
     * Add the constraints for a relationship query on the same table.
     *
     * @param \Illuminate\Database\Eloquent\Builder $query
     * @param \Illuminate\Database\Eloquent\Builder $parentQuery
     * @param array|mixed $columns
     * @return \Illuminate\Database\Eloquent\Builder
     */
    public function getRelationExistenceQueryForSelfRelation(Builder $query, Builder $parentQuery, $columns = ['*'])
    {
        $hash = $this->getRelationCountHash();

        $query->from($query->getModel()->getTable().' as '.$hash);

        $this->performJoin($query);

        $query->getModel()->setTable($hash);

        return $query->select($columns)->whereColumn(

            $parentQuery->getQuery()->from.'.'.$this->localKey,
            '=',
            $this->getQualifiedFirstKeyName()
        );
    }

    /**
     * Restore soft-deleted models.
     *
     * @param array|string ...$columns
     * @return $this
     */
    public function withTrashed(...$columns)
    {
        if (empty($columns)) {
            $this->query->withTrashed();

            return $this;
        }

        if (is_array($columns[0])) {
            $columns = $columns[0];
        }

        foreach ($columns as $column) {
            $this->query->withoutGlobalScope(__CLASS__ . ":$column");
        }

        return $this;
    }

    /**
     * Get the far parent model instance.
     *
     * @return \Illuminate\Database\Eloquent\Model
     */
    public function getFarParent(): Model
    {
        return $this->farParent;
    }

    /**
     * Get the "through" parent model instances.
     *
     * @return \Illuminate\Database\Eloquent\Model[]
     */
    public function getThroughParents()
    {
        return $this->throughParents;
    }

    /**
     * Get the foreign keys on the relationship.
     *
     * @return array
     */
    public function getForeignKeys()
    {
        return $this->foreignKeys;
    }

    /**
     * Get the local keys on the relationship.
     *
     * @return array
     */
    public function getLocalKeys()
    {
        return $this->localKeys;
    }
}


1		<?php
2
3		namespace Staudenmeir\EloquentHasManyDeep;
4
5		use Closure;
6		use Exception;
7		use Illuminate\Database\Eloquent\Builder;
8		use Illuminate\Database\Eloquent\Collection;
9		use Illuminate\Database\Eloquent\Model;
10		use Illuminate\Database\Eloquent\Relations\HasManyThrough;
11		use Staudenmeir\EloquentHasManyDeep\Eloquent\Relations\Traits\ExecutesQueries;
12		use Staudenmeir\EloquentHasManyDeep\Eloquent\Relations\Traits\HasEagerLimit;
13		use Staudenmeir\EloquentHasManyDeep\Eloquent\Relations\Traits\IsConcatenable;
14		use Staudenmeir\EloquentHasManyDeep\Eloquent\Relations\Traits\JoinsThroughParents;
15		use Staudenmeir\EloquentHasManyDeep\Eloquent\Relations\Traits\RetrievesIntermediateTables;
16		use Staudenmeir\EloquentHasManyDeep\Eloquent\Relations\Traits\SupportsCompositeKeys;
17		use Staudenmeir\EloquentHasManyDeep\Eloquent\Relations\Traits\IsCustomizable;
18		use Staudenmeir\EloquentHasManyDeepContracts\Interfaces\ConcatenableRelation;
19
20		/**
21		* @template TRelatedModel of \Illuminate\Database\Eloquent\Model
22		* @extends \Illuminate\Database\Eloquent\Relations\Relation<TRelatedModel>
23		*/
24		class HasManyDeep extends HasManyThrough implements ConcatenableRelation
25		{
26		use ExecutesQueries;
27		use HasEagerLimit;
		0 ignored issues – show Bug introduced 2022-08-12 23:35 UTC by Report Bug Copy Issue Report The trait `Staudenmeir\EloquentHasM...ns\Traits\HasEagerLimit` requires the property `$exists` which is not provided by `Staudenmeir\EloquentHasManyDeep\HasManyDeep`. Loading history...
28		use IsConcatenable;
29		use IsCustomizable;
30		use JoinsThroughParents;
		0 ignored issues – show Bug introduced 2022-08-12 23:48 UTC by Report Bug Copy Issue Report The trait `Staudenmeir\EloquentHasM...its\JoinsThroughParents` requires the property `$columns` which is not provided by `Staudenmeir\EloquentHasManyDeep\HasManyDeep`. Loading history...
31		use RetrievesIntermediateTables;
32		use SupportsCompositeKeys;
		0 ignored issues – show Bug introduced 2022-08-12 23:35 UTC by Report Bug Copy Issue Report The trait `Staudenmeir\EloquentHasM...s\SupportsCompositeKeys` requires the property `$columns` which is not provided by `Staudenmeir\EloquentHasManyDeep\HasManyDeep`. Loading history...
33
34		/**
35		* The "through" parent model instances.
36		*
37		* @var \Illuminate\Database\Eloquent\Model[]
38		*/
39		protected $throughParents;
40
41		/**
42		* The foreign keys on the relationship.
43		*
44		* @var array
45		*/
46		protected $foreignKeys;
47
48		/**
49		* The local keys on the relationship.
50		*
51		* @var array
52		*/
53		protected $localKeys;
54
55		/**
56		* Create a new has many deep relationship instance.
57		*
58		* @param \Illuminate\Database\Eloquent\Builder $query
59		* @param \Illuminate\Database\Eloquent\Model $farParent
60		* @param \Illuminate\Database\Eloquent\Model[] $throughParents
61		* @param array $foreignKeys
62		* @param array $localKeys
63		* @return void
64		*/
65	190	public function __construct(Builder $query, Model $farParent, array $throughParents, array $foreignKeys, array $localKeys)
66		{
67	190	$this->throughParents = $throughParents;
68	190	$this->foreignKeys = $foreignKeys;
69	190	$this->localKeys = $localKeys;
70
71	190	$firstKey = is_array($foreignKeys[0])
72	10	? $foreignKeys[0][1]
73	180	: ($this->hasLeadingCompositeKey() ? $foreignKeys[0]->columns[0] : $foreignKeys[0]);
74
75	190	$localKey = $this->hasLeadingCompositeKey() ? $localKeys[0]->columns[0] : $localKeys[0];
76
77	190	parent::__construct($query, $farParent, $throughParents[0], $firstKey, $foreignKeys[1], $localKey, $localKeys[1]);
78		}
79
80		/**
81		* Set the base constraints on the relation query.
82		*
83		* @return void
84		*/
85	190	public function addConstraints()
86		{
87	190	if ($this->firstKey instanceof Closure \|\| $this->localKey instanceof Closure) {
		0 ignored issues – show introduced 2022-11-15 22:07 UTC by Report Bug Copy Issue Report `$this->localKey` is never a sub-type of `Closure`. Loading history...
88	35	$this->performJoin();
89		} else {
90	155	parent::addConstraints();
91		}
92
93	190	if (static::$constraints) {
94	114	if ($this->firstKey instanceof Closure) {
		0 ignored issues – show introduced 2022-11-15 22:07 UTC by Report Bug Copy Issue Report `$this->firstKey` is never a sub-type of `Closure`. Loading history...
95	11	($this->firstKey)($this->query);
96	103	} elseif ($this->localKey instanceof Closure) {
		0 ignored issues – show introduced 2022-11-15 22:07 UTC by Report Bug Copy Issue Report `$this->localKey` is never a sub-type of `Closure`. Loading history...
97		($this->localKey)($this->query);
98	103	} elseif (is_array($this->foreignKeys[0])) {
99	4	$this->query->where(
100	4	$this->throughParent->qualifyColumn($this->foreignKeys[0][0]),
101		'=',
102	4	$this->farParent->getMorphClass()
103		);
104	99	} elseif ($this->hasLeadingCompositeKey()) {
105	10	$this->addConstraintsWithCompositeKey();
106		}
107		}
108		}
109
110		/**
111		* Set the join clauses on the query.
112		*
113		* @param \Illuminate\Database\Eloquent\Builder\|null $query
114		* @return void
115		*/
116	190	protected function performJoin(Builder $query = null)
117		{
118	190	$query = $query ?: $this->query;
119
120	190	$throughParents = array_reverse($this->throughParents);
121	190	$foreignKeys = array_reverse($this->foreignKeys);
122	190	$localKeys = array_reverse($this->localKeys);
123
124	190	$segments = explode(' as ', $query->getQuery()->from);
125
126	190	$alias = $segments[1] ?? null;
127
128	190	foreach ($throughParents as $i => $throughParent) {
129	190	$predecessor = $throughParents[$i - 1] ?? $this->related;
130
131	190	$prefix = $i === 0 && $alias ? $alias.'.' : '';
132
133	190	$this->joinThroughParent($query, $throughParent, $predecessor, $foreignKeys[$i], $localKeys[$i], $prefix);
134		}
135		}
136
137		/**
138		* Set the constraints for an eager load of the relation.
139		*
140		* @param array $models
141		* @return void
142		*/
143	40	public function addEagerConstraints(array $models)
144		{
145	40	if ($this->customEagerConstraintsCallback) {
146	12	($this->customEagerConstraintsCallback)($this->query, $models);
147	12	return;
148		}
149
150	28	if ($this->hasLeadingCompositeKey()) {
151	4	$this->addEagerConstraintsWithCompositeKey($models);
152		} else {
153	24	parent::addEagerConstraints($models);
154
155	24	if (is_array($this->foreignKeys[0])) {
156	2	$this->query->where(
157	2	$this->throughParent->qualifyColumn($this->foreignKeys[0][0]),
158		'=',
159	2	$this->farParent->getMorphClass()
160		);
161		}
162		}
163		}
164
165		/**
166		* Match the eagerly loaded results to their parents.
167		*
168		* @param array $models
169		* @param \Illuminate\Database\Eloquent\Collection $results
170		* @param string $relation
171		* @return array
172		*/
173	36	public function match(array $models, Collection $results, $relation)
174		{
175	36	if ($this->customEagerMatchingCallbacks) {
		0 ignored issues – show Bug Best Practice introduced 2022-11-16 07:12 UTC by Report Bug Copy Issue Report The expression `$this->customEagerMatchingCallbacks` of type `array` is implicitly converted to a boolean; are you sure this is intended? If so, consider using `! empty($expr)` instead to make it clear that you intend to check for an array without elements. This check marks implicit conversions of arrays to boolean values in a comparison. While in PHP an empty array is considered to be equal (but not identical) to false, this is not always apparent. Consider making the comparison explicit by using `empty(..)` or `! empty(...)` instead. Loading history...
176	12	foreach ($this->customEagerMatchingCallbacks as $callback) {
177	12	$models = $callback($models, $results, $relation);
178		}
179
180	12	return $models;
181		}
182
183	24	if ($this->hasLeadingCompositeKey()) {
184	4	return $this->matchWithCompositeKey($models, $results, $relation);
185		}
186
187	20	return parent::match($models, $results, $relation);
188		}
189
190		/**
191		* Set the select clause for the relation query.
192		*
193		* @param array $columns
194		* @return array
195		*/
196	153	protected function shouldSelect(array $columns = ['*'])
197		{
198	153	if ($columns == ['*']) {
199	153	$columns = [$this->related->getTable().'.*'];
200		}
201
202	153	$alias = 'laravel_through_key';
203
204	153	if ($this->customThroughKeyCallback) {
205	23	$columns[] = ($this->customThroughKeyCallback)($alias);
206		} else {
207	130	$columns[] = $this->getQualifiedFirstKeyName() . " as $alias";
208		}
209
210	153	if ($this->hasLeadingCompositeKey()) {
211	14	$columns = array_merge(
212		$columns,
213	14	$this->shouldSelectWithCompositeKey()
214		);
215		}
216
217	153	return array_merge($columns, $this->intermediateColumns());
218		}
219
220		/**
221		* Add the constraints for a relationship query.
222		*
223		* @param \Illuminate\Database\Eloquent\Builder $query
224		* @param \Illuminate\Database\Eloquent\Builder $parentQuery
225		* @param array\|mixed $columns
226		* @return \Illuminate\Database\Eloquent\Builder
227		*/
228	36	public function getRelationExistenceQuery(Builder $query, Builder $parentQuery, $columns = ['*'])
229		{
230	36	foreach ($this->throughParents as $throughParent) {
231	36	if ($throughParent->getTable() === $parentQuery->getQuery()->from) {
232	9	if (!in_array(HasTableAlias::class, class_uses_recursive($throughParent))) {
233	2	$traitClass = HasTableAlias::class;
234	2	$parentClass = get_class($throughParent);
235
236	2	throw new Exception(
237		<<<EOT
238		This query requires an additional trait. Please add the $traitClass trait to $parentClass.
239		See https://github.com/staudenmeir/eloquent-has-many-deep/issues/137 for details.
240		EOT
241		);
242		}
243
244	7	$table = $throughParent->getTable() . ' as ' . $this->getRelationCountHash();
245
246	7	$throughParent->setTable($table);
247
248	7	break;
249		}
250		}
251
252	34	if ($this->firstKey instanceof Closure \|\| $this->localKey instanceof Closure) {
		0 ignored issues – show introduced 2022-11-15 22:07 UTC by Report Bug Copy Issue Report `$this->localKey` is never a sub-type of `Closure`. Loading history...
253	12	$this->performJoin($query);
254
255	12	$closureKey = $this->firstKey instanceof Closure ? $this->firstKey : $this->localKey;
256
257	12	$closureKey($query, $parentQuery);
258
259	12	return $query->select($columns);
260		}
261
262	22	$query = parent::getRelationExistenceQuery($query, $parentQuery, $columns);
263
264	22	if (is_array($this->foreignKeys[0])) {
265	4	$column = $this->throughParent->qualifyColumn($this->foreignKeys[0][0]);
266
267	4	$query->where($column, '=', $this->farParent->getMorphClass());
268	18	} elseif ($this->hasLeadingCompositeKey()) {
269	2	$this->getRelationExistenceQueryWithCompositeKey($query);
270		}
271
272	22	return $query;
273		}
274
275		/**
276		* Add the constraints for a relationship query on the same table.
277		*
278		* @param \Illuminate\Database\Eloquent\Builder $query
279		* @param \Illuminate\Database\Eloquent\Builder $parentQuery
280		* @param array\|mixed $columns
281		* @return \Illuminate\Database\Eloquent\Builder
282		*/
283	4	public function getRelationExistenceQueryForSelfRelation(Builder $query, Builder $parentQuery, $columns = ['*'])
284		{
285	4	$hash = $this->getRelationCountHash();
286
287	4	$query->from($query->getModel()->getTable().' as '.$hash);
288
289	4	$this->performJoin($query);
290
291	4	$query->getModel()->setTable($hash);
292
293	4	return $query->select($columns)->whereColumn(
		0 ignored issues – show Bug Best Practice introduced 2021-08-21 10:13 UTC by Report Bug Copy Issue Report The expression `return $query->select($c...ualifiedFirstKeyName())` also could return the type `Illuminate\Database\Query\Builder` which is incompatible with the documented return type `Illuminate\Database\Eloquent\Builder`. Loading history...
294	4	$parentQuery->getQuery()->from.'.'.$this->localKey,
295		'=',
296	4	$this->getQualifiedFirstKeyName()
297		);
298		}
299
300		/**
301		* Restore soft-deleted models.
302		*
303		* @param array\|string ...$columns
304		* @return $this
305		*/
306	14	public function withTrashed(...$columns)
307		{
308	14	if (empty($columns)) {
309	4	$this->query->withTrashed();
310
311	4	return $this;
312		}
313
314	10	if (is_array($columns[0])) {
315	2	$columns = $columns[0];
316		}
317
318	10	foreach ($columns as $column) {
319	10	$this->query->withoutGlobalScope(__CLASS__ . ":$column");
320		}
321
322	10	return $this;
323		}
324
325		/**
326		* Get the far parent model instance.
327		*
328		* @return \Illuminate\Database\Eloquent\Model
329		*/
330	10	public function getFarParent(): Model
331		{
332	10	return $this->farParent;
333		}
334
335		/**
336		* Get the "through" parent model instances.
337		*
338		* @return \Illuminate\Database\Eloquent\Model[]
339		*/
340	10	public function getThroughParents()
341		{
342	10	return $this->throughParents;
343		}
344
345		/**
346		* Get the foreign keys on the relationship.
347		*
348		* @return array
349		*/
350	10	public function getForeignKeys()
351		{
352	10	return $this->foreignKeys;
353		}
354
355		/**
356		* Get the local keys on the relationship.
357		*
358		* @return array
359		*/
360	10	public function getLocalKeys()
361		{
362	10	return $this->localKeys;
363		}
364		}
365

staudenmeir / eloquent-has-many-deep

Push — master ( 8684f9...1eb973 )

HasManyDeep::get() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like