Spatie\Enum\Enum

Complexity

Total Complexity

15

Size/Duplication

Total Lines	85
Duplicated Lines	0 %

Importance

Changes	32
Bugs	5	Features	3

7 Methods

Rating	Name	Duplication	Size	Complexity
A	__get()	0	8	3
A	resolveDefinition()	0	23	3
A	labels()	0	3	1
A	__callStatic()	0	3	1
A	equals()	0	12	4
A	__construct()	0	12	2
A	toArray()	0	3	1

<?php

namespace Spatie\Enum;

use BadMethodCallException;
use ReflectionClass;

/**
 * @property-read string value
 * @property-read string label
 */
abstract class Enum
{
    protected string $value;

    protected string $label;

    private static array $definitionCache = [];

    public static function toArray(): array
    {
        return static::resolveDefinition();
    }

    public function __construct(string $value)
    {
        $definition = static::resolveDefinition();

        if (! isset($definition[$value])) {
            $enumClass = static::class;

            throw new BadMethodCallException("There's no value {$value} defined for enum {$enumClass}, consider adding it in the docblock definition.");
        }

        $this->value = $value;

The property value is declared read-only in Spatie\Enum\Enum.

        $this->label = $definition[$value];

The property label is declared read-only in Spatie\Enum\Enum.

    }

    public function __get($name)
    {
        if ($name === 'label') {
            return $this->label;
        }

        if ($name === 'value') {
            return $this->value;
        }
    }

    public static function __callStatic(string $name, array $arguments)
    {
        return new static($name);
    }

    public function equals(Enum ...$others): bool
    {
        foreach ($others as $other) {
            if (
                get_class($this) === get_class($other)
                && $this->value === $other->value
            ) {
                return true;
            }
        }

        return false;
    }

    protected static function labels(): array
    {
        return [];
    }

    private static function resolveDefinition(): array
    {
        $className = static::class;

        if (static::$definitionCache[$className] ?? null) {

Since $definitionCache is declared private, accessing it with static will lead to errors in possible sub-classes; you can either use self, or increase the visibility of $definitionCache to at least protected.

            return static::$definitionCache[$className];
        }

        $reflectionClass = new ReflectionClass($className);

        $docComment = $reflectionClass->getDocComment();

        preg_match_all('/@method static self ([\w_]+)\(\)/', $docComment, $matches);

        $definition = [];

        $labels = static::labels();

        foreach ($matches[1] as $value) {
            $definition[$value] = $labels[$value] ?? $value;
        }

        return static::$definitionCache[$className] ??= $definition;
    }
}