Ducks\Component\SplTypes\Reflection\SplReflectionEnumProxy

Complexity

Total Complexity

56

Size/Duplication

Total Lines	350
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	1

16 Methods

Rating	Name	Duplication	Size	Complexity
A	getCases()	0	10	2
A	getCase()	0	7	2
A	getFirstCaseConstant()	0	3	2
A	initCases()	0	4	1
A	isBacked()	0	14	4
B	addConstantCase()	0	20	9
A	hasCase()	0	12	3
A	hasConstantCase()	0	12	3
A	getConstantCase()	0	7	2
A	__construct()	0	4	1
A	getReflectionConstant()	0	3	2
A	getConstants()	0	3	1
A	getConstantCases()	0	10	2
B	addCase()	0	32	11
A	initConstantCases()	0	7	3
B	getBackingType()	0	30	8

<?php

/**
 * Part of SplTypes package.
 *
 * (c) Adrien Loyant <donald_duck@team-df.org>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

declare(strict_types=1);

namespace Ducks\Component\SplTypes\Reflection;

use Ducks\Component\SplTypes\SplBackedEnum;
use Ducks\Component\SplTypes\SplUnitEnum;

final class SplReflectionEnumProxy
{
    private \ReflectionClass $class;

    private ?bool $backed = null;

    /**
     * Will be used to set backingType.
     *
     * @var \ReflectionNamedType|null|false
     */
    private $backingType = null;

    /**
     * Array of constants class, indexed by name, as enum cases.
     *
     * @var array<string, \ReflectionClassConstant>
     */
    private array $constantCases = [];

    /**
     * Array of Reflection enum cases, indexed by name.
     *
     * @var array<string, SplReflectionEnumUnitCase|SplReflectionEnumBackedCase>
     */
    private array $cases = [];

    public string $name;

    public function __construct(\ReflectionClass $class)
    {
        $this->class = $class;
        $this->name = $class->name;
    }

    /**
     * Gets constants.
     *
     * @return array<string, mixed> An array of constants,
     * where the keys hold the name and the values the value of the constants.
     */
    public function getConstants(): array
    {
        return $this->class->getConstants();
    }

    /**
     * Gets a ReflectionClassConstant for a class's property
     *
     * @param string $name ? The class constant name.
     *
     * @return \ReflectionClassConstant|null
     */
    public function getReflectionConstant(string $name): ?\ReflectionClassConstant
    {
        return $this->class->getReflectionConstant($name) ?: null;
    }

    /**
     * Init internal constant cases array.
     *
     * @return void
     *
     * @codeCoverageIgnore
     */
    private function initConstantCases(): void
    {
        $constants = \array_diff_key($this->getConstants(), $this->constantCases);
        foreach (\array_keys($constants) as $name) {
            $constant = $this->getReflectionConstant($name);
            if ($constant instanceof \ReflectionClassConstant) {
                $this->addConstantCase($constant);
            }
        }
    }

    /**
     * Add a constant case to internal array
     *
     * @param \ReflectionClassConstant ...$constants
     *
     * @return void
     */
    public function addConstantCase(\ReflectionClassConstant ...$constants): void
    {
        foreach ($constants as $constant) {
            $name = $constant->getName();
            if (
                !isset($this->constantCases[$name])
                && $constant->isPublic()
                // Check consistency because of polyfilling or other bad overrides
                && $constant->getDeclaringClass()->name === $this->name
                // Do not use isBacked method because of infinite loop possibility
                // Add if not BackedEnum or Backed but valid type
                && (
                    !\is_a($this->name, SplBackedEnum::class, true)
                    || (
                        \is_a($this->name, SplBackedEnum::class, true)
                        && (\is_int($constant->getValue()) || \is_string($constant->getValue()))
                    )
                )
            ) {
                $this->constantCases[$name] = $constant;
            }
        }
    }

    /**
     * Return an array of class constants, indexed by name, that could be use as an enum case.
     *
     * @return array<string, \ReflectionClassConstant>
     */
    public function getConstantCases(): array
    {
        static $init = false;

        if (!$init) {
            $this->initConstantCases();
            $init = true;
        }

        return $this->constantCases;
    }

    /**
     * Return a class constant for a case name if exists
     *
     * @param string $name
     *
     * @return \ReflectionClassConstant
     *
     * @throws \ReflectionException If the requested constant case is not defined
     */
    public function getConstantCase(string $name): \ReflectionClassConstant
    {
        if (!$this->hasConstantCase($name)) {
            throw new \ReflectionException($this->name . '::' . $name . ' is not a constant case');
        }

        return $this->constantCases[$name];
    }

    /**
     * Checks for a constant case on an Enum
     *
     * @param string $name The case to check for.
     *
     * @return boolean
     */
    public function hasConstantCase(string $name): bool
    {
        if (isset($this->constantCases[$name])) {
            return true;
        }

        $constant = $this->getReflectionConstant($name);
        if ($constant instanceof \ReflectionClassConstant) {
            $this->addConstantCase($constant);
        }

        return isset($this->constantCases[$name]);
    }

    /**
     * Return the first defined constant as possible enum case.
     *
     * @return \ReflectionClassConstant|null
     */
    public function getFirstCaseConstant(): ?\ReflectionClassConstant
    {
        return \current($this->getConstantCases()) ?: null;
    }

    /**
     * Init internal cases array.
     *
     * @return void
     *
     * @codeCoverageIgnore
     */
    private function initCases(): void
    {
        $cases = \array_diff_key($this->getConstantCases(), $this->cases);
        $this->addCase(...\array_values($cases));
    }

    /**
     * Add a case to internal array
     *
     * @param \ReflectionClassConstant ...$constants
     *
     * @return void
     */
    public function addCase(\ReflectionClassConstant ...$constants): void
    {
        foreach ($constants as $constant) {
            $name = $constant->getName();
            if (
                !isset($this->cases[$name])
            ) {
                // Check type
                $value = $constant->getValue();

                if (
                    (
                        // Accept nullable value for UnitEnum
                        null === $value && !($this->getBackingType() instanceof \ReflectionNamedType)
                    ) || (
                        // Filter acceptable value for BackedEnum
                        $this->getBackingType() instanceof \ReflectionNamedType
                        && isset($value)
                        && (
                            \is_scalar($value) && \call_user_func('is_' . $this->getBackingType(), $value)
                            || \is_a($value, (string) $this->getBackingType())
                        )
                    )
                ) {
                    // Mandatory in order to prevent infinite loop
                    $this->cases[$name] = true;
                    $case = $this->isBacked()
                        ? new SplReflectionEnumBackedCase($this->name, $name)
                        : new SplReflectionEnumUnitCase($this->name, $name);

                    // Now link correct class on pointer
                    $this->cases[$name] = $case;
                }
            }
        }
    }

    /**
     * Returns a list of all cases on an Enum
     *
     * @return array<int, ReflectionEnumUnitCase|ReflectionEnumBackedCase>
     *
     * @link https://www.php.net/manual/en/reflectionenum.getcases.php
     */
    public function getCases(): array
    {
        static $init = false;

        if (!$init) {
            $this->initCases();
            $init = true;
        }

        return $this->cases;
    }

    /**
     * Returns a specific case of an Enum
     *
     * @param string $name
     *
     * @return SplReflectionEnumUnitCase|SplReflectionEnumBackedCase
     *
     * @throws \ReflectionException If the requested case is not defined
     *
     * @link https://www.php.net/manual/en/reflectionenum.getcase.php
     */
    public function getCase(string $name): SplReflectionEnumUnitCase
    {
        if (!$this->hasCase($name)) {
            throw new \ReflectionException($this->name . '::' . $name . ' is not a case');
        }

        return $this->cases[$name];
    }

    /**
     * Checks for a case on an Enum
     *
     * @param string $name The case to check for.
     *
     * @return boolean
     *
     * @link https://www.php.net/manual/en/reflectionenum.hascase.php
     */
    public function hasCase(string $name): bool
    {
        if (isset($this->cases[$name])) {
            return true;
        }

        if ($this->hasConstantCase($name)) {
            $constant = $this->getConstantCase($name);
            $this->addCase($constant);
        }

        return isset($this->cases[$name]);
    }

    /**
     * Determines if an Enum is a Backed Enum
     *
     * @return boolean
     */
    public function isBacked(): bool
    {
        if (null === $this->backed) {
            if (\is_a($this->name, SplBackedEnum::class, true)) {
                $this->backed = true;
            } elseif (\is_a($this->name, SplUnitEnum::class, true)) {
                $this->backed = false;
            } else {
                $constant = $this->getFirstCaseConstant();
                $this->backed = null !== $constant->getValue();
            }
        }

        return $this->backed;
    }

    /**
     * Gets the backing type of an Enum, if any
     *
     * @return \ReflectionNamedType|null An instance of ReflectionNamedType, or null if the Enum has no backing type.
     *
     * @link https://www.php.net/manual/en/reflectionenum.getbackingtype.php
     */
    public function getBackingType(): ?\ReflectionNamedType
    {
        if (null === $this->backingType) {
            if ($this->isBacked()) {
                if ($this->class->hasProperty('value')) {
                    $this->backingType = $this->class->getProperty('value')->getType() ?? false;
                } else {
                    $constant = $this->getFirstCaseConstant();
                    if ($constant instanceof \ReflectionClassConstant) {
                        switch (\gettype($constant->getValue())) {
                            case 'string':
                                $this->backingType = SplReflectionEnumHelper::getStringReflectionNamedType();
                                break;

                            case 'integer':
                                $this->backingType = SplReflectionEnumHelper::getIntReflectionNamedType();
                                break;

                            default:
                                $this->backingType = false;
                                break;
                        }
                    }
                }
            } else {
                $this->backingType = false;
            }
        }

        return $this->backingType ?: null;

The expression return $this->backingType ?: null could return the type true which is incompatible with the type-hinted return ReflectionNamedType|null. Consider adding an additional type-check to rule them out.

    }
}