HasRelatedContent::loadRelated() - Code Metrics - Inspection of "Nitpicks" - spatie/laravel-relatable - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( c51069...7bc6f0 )

by Sebastian

created 2016-03-07 11:03 UTC

HasRelatedContent::loadRelated() A

↳ Parent: HasRelatedContent

Complexity

Conditions	1
Paths	1

Size

Total Lines	12
Code Lines	7

Duplication

Lines	0
Ratio	0 %

Metric	Value
dl	0
loc	12
rs	9.4285
cc	1
eloc	7
nc	1
nop	0

<?php

namespace Spatie\Relatable;

use Illuminate\Database\Eloquent\Model;
use Illuminate\Support\Collection;
use Illuminate\Database\Eloquent\Relations\MorphMany;

/**
 * @mixin \Illuminate\Database\Eloquent\Model
 *
 * @property \Illuminate\Support\Collection $related
 * @property \Illuminate\Support\Collection $relatables
 */
trait HasRelatedContent
{
    /** @var \Illuminate\Support\Collection|null */
    protected $relatableCache;

    public function relatables() : MorphMany
    {
        return $this->morphMany(Relatable::class, 'source');
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
    }

    /**
     * Returns a Collection of all related models. The results are cached as a property on the
     * model, you reload them using the `loadRelated` method.
     *
     * @return \Illuminate\Support\Collection
     */
    public function getRelatedAttribute() : Collection
    {
        if ($this->relatableCache === null) {
            $this->loadRelated();
        }

        return $this->relatableCache;
    }

    public function loadRelated() : Collection
    {
        $this->load('relatables');
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}

        return $this->relatableCache = $this->relatables
            ->groupBy(function (Relatable $relatable) {
                return $this->getActualClassNameForMorph($relatable->related_type);
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
            })
            ->flatMap(function (Collection $typeGroup, string $type) {
                return $type::whereIn('id', $typeGroup->pluck('related_id'))->get();
            });
    }

    public function hasRelated() : bool
    {
        return ! $this->related->isEmpty();
    }

    /**
     * The `$item` parameter must be an Eloquent model or an ID. If you provide an ID, the model's
     * morph type must be specified as a second parameter.
     *
     * @param \Illuminate\Database\Eloquent\Model|int $item
     * @param string|null $type
     *
     * @return \Spatie\Relatable\Relatable
     */
    public function relate($item, string $type = '') : Relatable
    {
        return Relatable::firstOrCreate(
            $this->getRelatableValues($item, $type)
        );
    }

    /**
     * The `$item` parameter must be an Eloquent model or an ID. If you provide an ID, the model's
     * morph type must be specified as a second parameter.
     *
     * @param \Illuminate\Database\Eloquent\Model|int $item
     * @param string|null $type
     *
     * @return int
     */
    public function unrelate($item, string $type = '') : int
    {
        return Relatable::where($this->getRelatableValues($item, $type))->delete();
    }

    /**
     * The `$items` parameter can either contain an Eloquent collection of models, or an array
     * with the shape of [['id' => int, 'type' => string], ...].
     *
     * @param \Illuminate\Database\Eloquent\Collection|array $items
     * @param bool $detaching
     */
    public function syncRelated($items, $detaching = true)
    {
        $items = $this->getSyncRelatedValues($items);

        $current = $this->relatables->map(function (Relatable $relatable) {
            return $relatable->getRelatedValues();
        });

        $items->each(function (array $values) {
            $this->relate($values['id'], $values['type']);
        });

        if (!$detaching) {
            return;
        }

        $current
            ->filter(function (array $values) use ($items) {
                return ! $items->contains($values);
            })
            ->each(function (array $values) {
                $this->unrelate($values['id'], $values['type']);
            });
    }

    protected function getSyncRelatedValues($items) : Collection
    {
        if ($items instanceof Collection) {
            return $items->map(function (Model $item) : array {
                return [
                    'type' => $item->getMorphClass(),
                    'id' => $item->getKey(),
                ];
            });
        }

        return collect($items);
    }

    /**
     * @param \Illuminate\Database\Eloquent\Model|int $item
     * @param string|null $type
     *
     * @return array
     */
    protected function getRelatableValues($item, string $type = '') : array
    {
        if (! $item instanceof Model && empty($type)) {
            throw new \InvalidArgumentException(
                'If an id is specified as an item, the type isn\'t allowed to be empty.'
            );
        }

        return [
            'source_id' => $this->getKey(),
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
            'source_type' => $this->getMorphClass(),
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
            'related_id' => $item instanceof Model ? $item->getKey() : $item,
            'related_type' => $item instanceof Model ? $item->getMorphClass() : $type,
        ];
    }
}


1			<?php
2
3			namespace Spatie\Relatable;
4
5			use Illuminate\Database\Eloquent\Model;
6			use Illuminate\Support\Collection;
7			use Illuminate\Database\Eloquent\Relations\MorphMany;
8
9			/**
10			* @mixin \Illuminate\Database\Eloquent\Model
11			*
12			* @property \Illuminate\Support\Collection $related
13			* @property \Illuminate\Support\Collection $relatables
14			*/
15			trait HasRelatedContent
16			{
17			/** @var \Illuminate\Support\Collection\|null */
18			protected $relatableCache;
19
20			public function relatables() : MorphMany
21			{
22			return $this->morphMany(Relatable::class, 'source');
			0 ignored issues – show Bug introduced 2016-03-07 10:17 UTC by Report Bug Copy Issue Report It seems like `morphMany()` must be provided by classes using this trait. How about adding it as abstract method to this trait? This check looks for methods that are used by a trait but not required by it. To illustrate, let’s look at the following code example trait Idable { public function equalIds(Idable $other) { return $this->getId() === $other->getId(); } } The trait `Idable` provides a method `equalsId` that in turn relies on the method `getId()`. If this method does not exist on a class mixing in this trait, the method will fail. Adding the `getId()` as an abstract method to the trait will make sure it is available. Loading history...
23			}
24
25			/**
26			* Returns a Collection of all related models. The results are cached as a property on the
27			* model, you reload them using the `loadRelated` method.
28			*
29			* @return \Illuminate\Support\Collection
30			*/
31			public function getRelatedAttribute() : Collection
32			{
33			if ($this->relatableCache === null) {
34			$this->loadRelated();
35			}
36
37			return $this->relatableCache;
38			}
39
40			public function loadRelated() : Collection
41			{
42			$this->load('relatables');
			0 ignored issues – show Bug introduced 2016-03-07 10:48 UTC by Report Bug Copy Issue Report It seems like `load()` must be provided by classes using this trait. How about adding it as abstract method to this trait? This check looks for methods that are used by a trait but not required by it. To illustrate, let’s look at the following code example trait Idable { public function equalIds(Idable $other) { return $this->getId() === $other->getId(); } } The trait `Idable` provides a method `equalsId` that in turn relies on the method `getId()`. If this method does not exist on a class mixing in this trait, the method will fail. Adding the `getId()` as an abstract method to the trait will make sure it is available. Loading history...
43
44			return $this->relatableCache = $this->relatables
45			->groupBy(function (Relatable $relatable) {
46			return $this->getActualClassNameForMorph($relatable->related_type);
			0 ignored issues – show Bug introduced 2016-03-07 10:17 UTC by Report Bug Copy Issue Report It seems like `getActualClassNameForMorph()` must be provided by classes using this trait. How about adding it as abstract method to this trait? This check looks for methods that are used by a trait but not required by it. To illustrate, let’s look at the following code example trait Idable { public function equalIds(Idable $other) { return $this->getId() === $other->getId(); } } The trait `Idable` provides a method `equalsId` that in turn relies on the method `getId()`. If this method does not exist on a class mixing in this trait, the method will fail. Adding the `getId()` as an abstract method to the trait will make sure it is available. Loading history...
47			})
48			->flatMap(function (Collection $typeGroup, string $type) {
49			return $type::whereIn('id', $typeGroup->pluck('related_id'))->get();
50			});
51			}
52
53			public function hasRelated() : bool
54			{
55			return ! $this->related->isEmpty();
56			}
57
58			/**
59			* The `$item` parameter must be an Eloquent model or an ID. If you provide an ID, the model's
60			* morph type must be specified as a second parameter.
61			*
62			* @param \Illuminate\Database\Eloquent\Model\|int $item
63			* @param string\|null $type
64			*
65			* @return \Spatie\Relatable\Relatable
66			*/
67			public function relate($item, string $type = '') : Relatable
68			{
69			return Relatable::firstOrCreate(
70			$this->getRelatableValues($item, $type)
71			);
72			}
73
74			/**
75			* The `$item` parameter must be an Eloquent model or an ID. If you provide an ID, the model's
76			* morph type must be specified as a second parameter.
77			*
78			* @param \Illuminate\Database\Eloquent\Model\|int $item
79			* @param string\|null $type
80			*
81			* @return int
82			*/
83			public function unrelate($item, string $type = '') : int
84			{
85			return Relatable::where($this->getRelatableValues($item, $type))->delete();
86			}
87
88			/**
89			* The `$items` parameter can either contain an Eloquent collection of models, or an array
90			* with the shape of [['id' => int, 'type' => string], ...].
91			*
92			* @param \Illuminate\Database\Eloquent\Collection\|array $items
93			* @param bool $detaching
94			*/
95			public function syncRelated($items, $detaching = true)
96			{
97			$items = $this->getSyncRelatedValues($items);
98
99			$current = $this->relatables->map(function (Relatable $relatable) {
100			return $relatable->getRelatedValues();
101			});
102
103			$items->each(function (array $values) {
104			$this->relate($values['id'], $values['type']);
105			});
106
107			if (!$detaching) {
108			return;
109			}
110
111			$current
112			->filter(function (array $values) use ($items) {
113			return ! $items->contains($values);
114			})
115			->each(function (array $values) {
116			$this->unrelate($values['id'], $values['type']);
117			});
118			}
119
120			protected function getSyncRelatedValues($items) : Collection
121			{
122			if ($items instanceof Collection) {
123			return $items->map(function (Model $item) : array {
124			return [
125			'type' => $item->getMorphClass(),
126			'id' => $item->getKey(),
127			];
128			});
129			}
130
131			return collect($items);
132			}
133
134			/**
135			* @param \Illuminate\Database\Eloquent\Model\|int $item
136			* @param string\|null $type
137			*
138			* @return array
139			*/
140			protected function getRelatableValues($item, string $type = '') : array
141			{
142			if (! $item instanceof Model && empty($type)) {
143			throw new \InvalidArgumentException(
144			'If an id is specified as an item, the type isn\'t allowed to be empty.'
145			);
146			}
147
148			return [
149			'source_id' => $this->getKey(),
			0 ignored issues – show Bug introduced 2016-03-07 10:17 UTC by Report Bug Copy Issue Report It seems like `getKey()` must be provided by classes using this trait. How about adding it as abstract method to this trait? This check looks for methods that are used by a trait but not required by it. To illustrate, let’s look at the following code example trait Idable { public function equalIds(Idable $other) { return $this->getId() === $other->getId(); } } The trait `Idable` provides a method `equalsId` that in turn relies on the method `getId()`. If this method does not exist on a class mixing in this trait, the method will fail. Adding the `getId()` as an abstract method to the trait will make sure it is available. Loading history...
150			'source_type' => $this->getMorphClass(),
			0 ignored issues – show Bug introduced 2016-03-07 10:17 UTC by Report Bug Copy Issue Report It seems like `getMorphClass()` must be provided by classes using this trait. How about adding it as abstract method to this trait? This check looks for methods that are used by a trait but not required by it. To illustrate, let’s look at the following code example trait Idable { public function equalIds(Idable $other) { return $this->getId() === $other->getId(); } } The trait `Idable` provides a method `equalsId` that in turn relies on the method `getId()`. If this method does not exist on a class mixing in this trait, the method will fail. Adding the `getId()` as an abstract method to the trait will make sure it is available. Loading history...
151			'related_id' => $item instanceof Model ? $item->getKey() : $item,
152			'related_type' => $item instanceof Model ? $item->getMorphClass() : $type,
153			];
154			}
155			}
156

spatie / laravel-relatable

GitHub Access Token became invalid

Push — master ( c51069...7bc6f0 )

HasRelatedContent::loadRelated() A

Complexity

Size

Duplication

Duplication Side-by-Side

Filter issues like