Spatie\Enum\Laravel\HasEnums

Complexity

Total Complexity

30

Size/Duplication

Total Lines	246
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	4

Test Coverage

Coverage

100%

Importance

Changes

0

15 Methods

Rating	Name	Duplication	Size	Complexity
A	setAttribute()	0	6	2
A	getAttribute()	0	8	2
A	scopeWhereEnum()	0	12	1
A	scopeOrWhereEnum()	0	12	1
A	scopeWhereNotEnum()	0	12	1
A	scopeOrWhereNotEnum()	0	12	1
B	setEnumAttribute()	0	27	6
A	getStoredValue()	0	6	2
A	getEnumAttribute()	0	8	3
A	isEnumAttribute()	0	4	1
A	getEnumCast()	0	14	2
A	isNullableEnum()	0	6	1
A	getEnumClass()	0	14	2
A	asEnum()	0	11	2
A	buildEnumScope()	0	19	3

<?php

namespace Spatie\Enum\Laravel;

use Illuminate\Database\Eloquent\Builder;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Support\Str;
use InvalidArgumentException;
use Spatie\Enum\Enumerable;
use Spatie\Enum\Laravel\Exceptions\InvalidEnumError;
use Spatie\Enum\Laravel\Exceptions\NoSuchEnumField;

/**
 * @mixin Model
 */
trait HasEnums
{
    public function setAttribute($key, $value)
    {
        return $this->isEnumAttribute($key)
            ? $this->setEnumAttribute($key, $value)
            : parent::setAttribute($key, $value);
    }

    public function getAttribute($key)
    {
        $value = parent::getAttribute($key);

        return $this->isEnumAttribute($key)
            ? $this->getEnumAttribute($key, $value)
            : $value;
    }

    /**
     * @param \Illuminate\Database\Eloquent\Builder $builder
     * @param string $key
     * @param int|string|\Spatie\Enum\Enumerable|int[]|string[]|\Spatie\Enum\Enumerable[] $enumerables
     *
     * @see \Illuminate\Database\Eloquent\Builder::whereIn()
     */
    public function scopeWhereEnum(
        Builder $builder,
        string $key,
        $enumerables
    ): void {
        $this->buildEnumScope(
            $builder,
            'whereIn',
            $key,
            $enumerables
        );
    }

    /**
     * @param \Illuminate\Database\Eloquent\Builder $builder
     * @param string $key
     * @param int|string|\Spatie\Enum\Enumerable|int[]|string[]|\Spatie\Enum\Enumerable[] $enumerables
     *
     * @see \Illuminate\Database\Eloquent\Builder::orWhereIn()
     */
    public function scopeOrWhereEnum(
        Builder $builder,
        string $key,
        $enumerables
    ): void {
        $this->buildEnumScope(
            $builder,
            'orWhereIn',
            $key,
            $enumerables
        );
    }

    /**
     * @param \Illuminate\Database\Eloquent\Builder $builder
     * @param string $key
     * @param int|string|\Spatie\Enum\Enumerable|int[]|string[]|\Spatie\Enum\Enumerable[] $enumerables
     *
     * @see \Illuminate\Database\Eloquent\Builder::whereNotIn()
     */
    public function scopeWhereNotEnum(
        Builder $builder,
        string $key,
        $enumerables
    ): void {
        $this->buildEnumScope(
            $builder,
            'whereNotIn',
            $key,
            $enumerables
        );
    }

    /**
     * @param \Illuminate\Database\Eloquent\Builder $builder
     * @param string $key
     * @param int|string|\Spatie\Enum\Enumerable|int[]|string[]|\Spatie\Enum\Enumerable[] $enumerables
     *
     * @see \Illuminate\Database\Eloquent\Builder::orWhereNotIn()
     */
    public function scopeOrWhereNotEnum(
        Builder $builder,
        string $key,
        $enumerables
    ): void {
        $this->buildEnumScope(
            $builder,
            'orWhereNotIn',
            $key,
            $enumerables
        );
    }

    /**
     * @param string $key
     * @param int|string|\Spatie\Enum\Enumerable $value
     *
     * @return $this
     */
    protected function setEnumAttribute(string $key, $value)
    {
        $enumClass = $this->getEnumClass($key);

        if (is_null($value)) {
            if (! $this->isNullableEnum($key)) {
                $enumInterface = Enumerable::class;
                throw new InvalidArgumentException("{$enumInterface} {$enumClass} is not nullable");
            }

            $this->attributes[$key] = null;

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

            return $this;
        }

        if (is_string($value) || is_int($value)) {
            $value = $this->asEnum($enumClass, $value);
        }

        if (! is_a($value, $enumClass)) {
            throw InvalidEnumError::make(static::class, $key, $enumClass, get_class($value));
        }

        $this->attributes[$key] = $this->getStoredValue($key, $value);

        return $this;
    }

    /**
     * @param string $key
     * @param \Spatie\Enum\Enumerable $enum
     *
     * @return int|string
     */
    protected function getStoredValue(string $key, Enumerable $enum)
    {
        return $this->hasCast($key, ['int', 'integer'])

It seems like hasCast() must be provided by classes using this trait. How about adding it as abstract method to this trait?

            ? $enum->getIndex()
            : $enum->getValue();
    }

    /**
     * @param string $key
     * @param int|string|null $value
     *
     * @return \Spatie\Enum\Enumerable|null
     */
    protected function getEnumAttribute(string $key, $value): ?Enumerable
    {
        if (is_null($value) && $this->isNullableEnum($key)) {
            return null;
        }

        return $this->asEnum($this->getEnumClass($key), $value);
    }

    protected function isEnumAttribute(string $key): bool
    {
        return isset($this->enums[$key]);

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

    }

    protected function getEnumCast(string $key): array
    {
        $enumCast = $this->enums[$key];

        if (! Str::contains($enumCast, ':')) {
            return [$enumCast, []];
        }

        [$enumClass, $options] = explode(':', $enumCast);

The variable $enumClass does not exist. Did you forget to declare it?

The variable $options seems only to be defined at a later point. Did you maybe move this code here without moving the variable definition?

        $options = explode(',', $options);

The variable $options seems only to be defined at a later point. Did you maybe move this code here without moving the variable definition?

        return [$enumClass, $options];
    }

    protected function isNullableEnum(string $key): bool
    {
        [, $options] = $this->getEnumCast($key);

The variable $options does not exist. Did you forget to declare it?

        return in_array('nullable', $options);
    }

    protected function getEnumClass(string $key): string
    {
        [$enumClass] = $this->getEnumCast($key);

The variable $enumClass does not exist. Did you forget to declare it?

        $enumInterface = Enumerable::class;

        $classImplementsEnumerable = class_implements($enumClass)[$enumInterface] ?? false;

        if (! $classImplementsEnumerable) {
            throw new InvalidArgumentException("Expected {$enumClass} to implement {$enumInterface}");
        }

        return $enumClass;
    }

    /**
     * @param string $class
     * @param int|string $value
     *
     * @return \Spatie\Enum\Enumerable
     */
    protected function asEnum(string $class, $value): Enumerable
    {
        if ($value instanceof Enumerable) {
            return $value;
        }

        return forward_static_call(
            $class.'::make',
            $value
        );
    }

    /**
     * @param \Illuminate\Database\Eloquent\Builder $builder
     * @param string $method
     * @param string $key
     * @param int|string|\Spatie\Enum\Enumerable|int[]|string[]|\Spatie\Enum\Enumerable[] $enumerables
     */
    protected function buildEnumScope(
        Builder $builder,
        string $method,
        string $key,
        $enumerables
    ): void {
        if (! $this->isEnumAttribute($key)) {
            throw NoSuchEnumField::make($key, get_class($this));
        }

        $enumerables = is_array($enumerables) ? $enumerables : [$enumerables];

        $builder->$method(
            $key,
            array_map(function ($value) use ($key) {
                return $this->getStoredValue($key, $this->getEnumAttribute($key, $value));

It seems like $this->getEnumAttribute($key, $value) can be null; however, getStoredValue() does not accept null, maybe add an additional type check?

            }, $enumerables)
        );
    }
}