Cerbero\LaravelEnum\CasesCollectionCast

Complexity

Total Complexity

10

Size/Duplication

Total Lines	85
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes	1
Bugs	0	Features	0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	setByArray()	0	13	5
A	__construct()	0	4	2
A	set()	0	9	1
A	getByJson()	0	8	1
A	get()	0	6	1

<?php

declare(strict_types=1);

namespace Cerbero\LaravelEnum;

use BackedEnum;

This use statement conflicts with another class in this namespace, Cerbero\LaravelEnum\BackedEnum. Consider defining an alias.

use Cerbero\LaravelEnum\Contracts\Bitwise;
use Illuminate\Contracts\Database\Eloquent\CastsAttributes;
use Illuminate\Database\Eloquent\Model;
use InvalidArgumentException;
use UnitEnum;

/**
 * The cases collection cast.
 *
 * @template TKey of array-key
 * @template TValue
 *
 * @implements CastsAttributes<CasesCollection, mixed>
 */
class CasesCollectionCast implements CastsAttributes
{
    /**
     * Disable object caching.
     */
    public bool $withoutObjectCaching = true;

    /**
     * Instantiate the class.
     */
    public function __construct(private readonly string $enum)
    {
        if (! is_subclass_of($enum, UnitEnum::class)) {
            throw new InvalidArgumentException('The cast argument must be a valid enum');
        }
    }

    /**
     * Transform the attribute from the underlying model values.
     *
     * @param string|int|null $value
     * @param array<string, mixed> $attributes
     * @return CasesCollection<TKey, TValue>
     * @throws \ValueError
     */
    public function get(Model $model, string $key, mixed $value, array $attributes): ?CasesCollection
    {
        return match (true) {
            is_string($value) => $this->getByJson($value),
            is_int($value) => $this->enum::filter(fn(BackedEnum $case) => ($value & $case->value) == $case->value),

Accessing value on the interface BackedEnum suggest that you code against a concrete implementation. How about adding an instanceof check?

            default => null,
        };
    }

    /**
     * Transform the given JSON into a cases collection.
     *
     * @return CasesCollection<TKey, TValue>
     * @throws \ValueError
     */
    protected function getByJson(string $json): CasesCollection
    {
        /** @var list<string|int> $cases */
        $cases = json_decode($json, true);
        $cases = array_unique($cases);

$cases of type Cerbero\LaravelEnum\list is incompatible with the type array expected by parameter $array of array_unique().

        /** @var CasesCollection<TKey, TValue> */
        return new CasesCollection(array_map(fn(string|int $value) => $this->enum::from($value), $cases));
    }

    /**
     * Transform the attribute to its underlying model values.
     *
     * @param array<string, mixed> $attributes
     */
    public function set(Model $model, string $key, mixed $value, array $attributes): string|int|null
    {
        $this->withoutObjectCaching = ! $value instanceof CasesCollection;

        return match (true) {
            $value instanceof CasesCollection => $value->toJson(),
            is_array($value) => $this->setByArray($value),
            is_int($value) => $value,
            default => null,
        };
    }

    /**
     * Transform the given array into a serializable string.
     *
     * @param array<array-key, mixed> $array

The doc comment array<array-key, mixed> at position 2 could not be parsed: Unknown type name 'array-key' at position 2 in array<array-key, mixed>.

     */
    protected function setByArray(array $array): string|int|null
    {
        if (is_subclass_of($this->enum, Bitwise::class)) {
            return array_reduce($array, function(?int $carry, BackedEnum|int $item) {
                return $carry |= $item instanceof BackedEnum ? $item->value : $item;

Accessing value on the interface BackedEnum suggest that you code against a concrete implementation. How about adding an instanceof check?

            });
        }

        $values = reset($array) instanceof UnitEnum
            ? $this->enum::only(...array_column($array, 'name'))
            : array_values(array_unique($array));

        return json_encode($values) ?: null;
    }
}