Vaened\Enum\Enum

Complexity

Total Complexity

21

Size/Duplication

Total Lines	118
Duplicated Lines	0 %

Test Coverage

Coverage

95.65%

Importance

Changes	2
Bugs	0	Features	1

18 Methods

Rating	Name	Duplication	Size	Complexity
A	create()	0	3	1
A	attributes()	0	3	1
A	equals()	0	3	1
A	match()	0	3	1
A	value()	0	3	1
A	__toString()	0	3	1
A	values()	0	3	1
A	isValid()	0	3	1
A	getEnumAttributes()	0	3	1
A	bindEnumAttributes()	0	6	1
A	key()	0	3	1
A	__callStatic()	0	9	2
A	instantiate()	0	9	2
A	getConstantsFrom()	0	3	1
A	associates()	0	4	1
A	__construct()	0	7	2
A	throwErrorForInvalidValue()	0	3	1
A	attribute()	0	5	1

<?php
/**
 * Created by enea dhack - 08/07/2020 16:59.
 */

namespace Vaened\Enum;

use BadMethodCallException;
use ReflectionClass;
use Stringable;
use UnexpectedValueException;

use function array_reduce;

abstract class Enum implements Enumerable, Stringable
{
    private string|int|float|bool $value;

    private static array $attributes = [];

    private static array $cache = [];

    protected function __construct(string|int|float|bool $value)
    {
        if (!self::isValid($value)) {
            $this->throwErrorForInvalidValue($value);
        }

        $this->value = $value;
    }

    public static function create(string|int|float|bool $value): static
    {
        return new static($value);
    }

    public static function instantiate(string $key): static
    {
        $values = static::associates();

        if (!isset($values[$key])) {
            throw new UnexpectedValueException("Key '$key' is not part of the enum " . static::class);
        }

        return static::create($values[$key]);
    }

    public static function isValid(string|int|float|bool $value): bool
    {
        return in_array($value, static::associates(), true);
    }

    public static function values(): array
    {
        return array_map(static fn(string|int|float|bool $value) => static::create($value), static::associates());
    }

    private static function associates(): array
    {
        $classname = static::class;
        return self::$cache[$classname] ??= static::getConstantsFrom($classname);
    }

    private static function getConstantsFrom(string $classname): array
    {
        return (new ReflectionClass($classname))->getConstants();
    }

    private static function getEnumAttributes(): array
    {
        return self::$attributes[static::class] ??= static::bindEnumAttributes();
    }

    private static function bindEnumAttributes(): array
    {
        return array_reduce(static::attributes(), static function (array $acc, Attributor $attribute): array {
            $acc[$attribute->getCase()] = $attribute->getAttributes();
            return $acc;
        }, []);
    }

    protected function throwErrorForInvalidValue(string|int|float|bool $value): void
    {
        throw new UnexpectedValueException("Value '$value' is not part of the enum " . static::class);
    }

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

    public function value(): string|int|float|bool
    {
        return $this->value;
    }

    public function key(): string
    {
        return array_search($this->value, static::associates(), true);
    }

    public function equals(string|int|float|bool $value): bool
    {
        return $this->value() === $value;
    }

    public function match(Enumerable $value): bool
    {
        return $this->value() === $value->value();
    }

    protected function attribute(string $name): mixed
    {
        $constants  = static::getEnumAttributes();
        $attributes = $constants[$this->key()] ?? [];
        return $attributes[$name] ?? null;
    }

    public static function __callStatic(string $name, array $arguments): self
    {
        $values = static::associates();

        if (isset($values[$name])) {
            return static::create($values[$name]);
        }

        throw new BadMethodCallException("No static method or enum constant '$name' in enum " . static::class);
    }

    public function __toString(): string
    {
        return $this->value();

The expression return $this->value() could return the type boolean which is incompatible with the type-hinted return string. Consider adding an additional type-check to rule them out.

    }
}