Cerbero\Enum\Concerns\SelfAware

Complexity

Total Complexity

21

Size/Duplication

Total Lines	114
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes	3
Bugs	0	Features	0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	resolveMeta()	0	12	5
A	isPure()	0	3	1
A	resolveItem()	0	6	1
A	value()	0	3	1
B	metaNames()	0	22	7
A	resolveMetaAttribute()	0	17	5
A	isBacked()	0	3	1

<?php

namespace Cerbero\Enum\Concerns;

use BackedEnum;

The type BackedEnum was not found. Maybe you did not declare it correctly or list all dependencies?

use Cerbero\Enum\Attributes\Meta;
use ReflectionAttribute;
use ReflectionEnum;

The type ReflectionEnum was not found. Maybe you did not declare it correctly or list all dependencies?

use ReflectionEnumUnitCase;

The type ReflectionEnumUnitCase was not found. Maybe you did not declare it correctly or list all dependencies?

use ReflectionMethod;
use ValueError;

/**
 * The trait to make an enum self-aware.
 */
trait SelfAware
{
    /**
     * Determine whether the enum is pure.
     */
    public static function isPure(): bool
    {
        return !self::isBacked();
    }

    /**
     * Determine whether the enum is backed.
     */
    public static function isBacked(): bool
    {
        return is_subclass_of(self::class, BackedEnum::class);
    }

    /**
     * Retrieve all the meta names of the enum.
     *
     * @return string[]
     */
    public static function metaNames(): array
    {
        $meta = [];
        $enum = new ReflectionEnum(self::class);

        foreach ($enum->getAttributes(Meta::class) as $attribute) {
            array_push($meta, ...$attribute->newInstance()->names());
        }

        foreach ($enum->getCases() as $case) {
            foreach ($case->getAttributes(Meta::class) as $attribute) {
                array_push($meta, ...$attribute->newInstance()->names());
            }
        }

        foreach ($enum->getMethods(ReflectionMethod::IS_PUBLIC) as $method) {
            if (! $method->isStatic() && $method->getFileName() == $enum->getFileName()) {
                $meta[] = $method->getShortName();
            }
        }

        return array_values(array_unique($meta));
    }

    /**
     * Retrieve the given item of this case.
     *
     * @template TItemValue
     *
     * @param (callable(self): TItemValue)|string $item

The doc comment (callable(self): TItemValue)|string at position 1 could not be parsed: Expected ')' at position 1, but found 'callable'.

     * @return TItemValue
     * @throws ValueError
     */
    public function resolveItem(callable|string $item): mixed
    {
        return match (true) {
            is_callable($item) => $item($this),
            property_exists($this, $item) => $this->$item,

It seems like $item can also be of type callable; however, parameter $property of property_exists() does only seem to accept string, maybe add an additional type check?

            default => $this->resolveMeta($item),

It seems like $item can also be of type callable; however, parameter $meta of Cerbero\Enum\Concerns\SelfAware::resolveMeta() does only seem to accept string, maybe add an additional type check?

        };
    }

    /**
     * Retrieve the given meta of this case.
     *
     * @throws ValueError
     */
    public function resolveMeta(string $meta): mixed
    {
        $enum = new ReflectionEnum($this);
        $enumFileName = $enum->getFileName();

        foreach ($enum->getMethods(ReflectionMethod::IS_PUBLIC) as $method) {
            if (! $method->isStatic() && $method->getFileName() == $enumFileName && $method->getShortName() == $meta) {
                return $this->$meta();
            }
        }

        return $this->resolveMetaAttribute($meta);
    }

    /**
     * Retrieve the given meta from the attributes.
     *
     * @throws ValueError
     */
    public function resolveMetaAttribute(string $meta): mixed
    {
        $case = new ReflectionEnumUnitCase($this, $this->name);

        foreach ($case->getAttributes(Meta::class, ReflectionAttribute::IS_INSTANCEOF) as $attribute) {
            if (($metadata = $attribute->newInstance())->has($meta)) {
                return $metadata->get($meta);
            }
        }

        foreach ($case->getEnum()->getAttributes(Meta::class, ReflectionAttribute::IS_INSTANCEOF) as $attribute) {
            if (($metadata = $attribute->newInstance())->has($meta)) {
                return $metadata->get($meta);
            }
        }

        throw new ValueError(sprintf('"%s" is not a valid meta for enum "%s"', $meta, self::class));
    }

    /**
     * Retrieve the value of a backed case or the name of a pure case.
     */
    public function value(): string|int
    {
        return $this->value ?? $this->name;
    }
}