UniSharp\Categorizable\Categorizable

Complexity

Total Complexity

13

Size/Duplication

Total Lines	83
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Test Coverage

Coverage

100%

Importance

Changes

0

11 Methods

Rating	Name	Duplication	Size	Complexity
A	categories()	0	4	1
A	categorize()	0	5	1
A	uncategorize()	0	5	1
A	decategorize()	0	5	1
A	recategorize()	0	5	1
A	scopeHasCategories()	0	6	1
A	scopeHasStrictCategories()	0	6	1
A	normalize()	0	16	5
A	differenceBetweenExistences()	0	4	1
	morphToMany()	0	10	?
	load()	0	1	?

<?php
namespace UniSharp\Categorizable;

use Illuminate\Database\Eloquent\Builder;
use UniSharp\Categorizable\Models\Category;
use Illuminate\Database\Eloquent\Relations\MorphToMany;

trait Categorizable
{
    public function categories(): MorphToMany
    {
        return $this->morphToMany(Category::class, 'categorizable', 'categorizable');
    }

    public function categorize(...$categories): self
    {
        $this->categories()->attach($this->differenceBetweenExistences($this->normalize($categories)));
        return $this->load('categories');
    }

    public function uncategorize(...$categories): self
    {
        $this->categories()->detach($this->normalize($categories));
        return $this->load('categories');
    }

    public function decategorize(): self
    {
        $this->categories()->sync([]);
        return $this->load('categories');
    }

    public function recategorize(...$categories): self
    {
        $this->decategorize()->categorize(...$categories);
        return $this->load('categories');
    }

    public function scopeHasCategories(Builder $builder, ...$categories): Builder
    {
        return $builder->whereHas('categories', function (Builder $query) use ($categories) {
            $query->whereIn('category_id', Category::descendantsAndSelf($this->normalize($categories))->pluck('id'));
        });
    }

    public function scopeHasStrictCategories(Builder $builder, ...$categories): Builder
    {
        return $builder->whereHas('categories', function (Builder $query) use ($categories) {
            $query->whereIn('category_id', $this->normalize($categories));
        });
    }

    /*
     * Convert everything to category ids
     */
    public function normalize(array $categories): array
    {
        $ids = collect($categories)->map(function ($categories) {
            switch (true) {
                case is_integer($categories) || is_numeric($categories):
                    return $categories;
                case is_string($categories):
                    return Category::firstOrCreate(['name' => $categories])->id;

The method firstOrCreate() does not exist on UniSharp\Categorizable\Models\Category. Did you maybe mean create()?

                case is_array($categories):
                    return $this->normalize($categories);
            }
        })->flatten()->toArray();

        // reject ids not exist in database
        return Category::whereIn('id', $ids)->pluck('id')->toArray();
    }

    protected function differenceBetweenExistences(array $ids): array
    {
        return array_diff($ids, $this->categories->pluck('id')->toArray());

The property categories does not exist. Did you maybe forget to declare it?

    }

    abstract public function morphToMany(
        $related,
        $name,
        $table = null,
        $foreignPivotKey = null,
        $relatedPivotKey = null,
        $parentKey = null,
        $relatedKey = null,
        $inverse = false
    );

    abstract public function load($relations);
}