Paillechat\Enum\Enum

Complexity

Total Complexity

17

Size/Duplication

Total Lines	135
Duplicated Lines	17.04 %

Coupling/Cohesion

Components	1
Dependencies	1

Test Coverage

Coverage

100%

Importance

Changes

0

11 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	createByName()	0	16	3
A	__callStatic()	0	4	1
A	getConstList()	0	4	1
A	getConstantReflection()	11	11	2
A	getConstKey()	0	4	1
A	findParentClassForConst()	0	4	1
A	getEnumReflection()	0	14	3
A	createNamedInstance()	12	12	2
A	getName()	0	4	1
A	__toString()	0	4	1

<?php

namespace Paillechat\Enum;

use Paillechat\Enum\Exception\EnumException;

abstract class Enum
{
    /** @var Enum[] */
    private static $instances = [];
    /** @var \ReflectionClassConstant[] */
    private static $constReflections = [];
    /** @var \ReflectionClass[] */
    private static $reflections = [];
    /** @var string */
    private $name;

    /**
     * @param string $name
     */
    final private function __construct(string $name)
    {
        $this->name = $name;
    }

    /**
     * Creates enum instance by name
     *
     * @param string $name
     *
     * @return static
     *
     * @throws EnumException
     */
    final public static function createByName(string $name)
    {
        $canonicalName = strtoupper($name);
        if ($canonicalName !== $name) {
            $name = $canonicalName;
            trigger_error('PSR-1 requires constant to be declared in upper case.', E_USER_NOTICE);
        }

        $const = static::getConstList();

        if (!\in_array($name, $const, true)) {
            throw EnumException::becauseUnknownMember(static::class, $name);
        }

        return static::createNamedInstance($name);

Since createNamedInstance() is declared private, calling it with static will lead to errors in possible sub-classes. You can either use self, or increase the visibility of createNamedInstance() to at least protected.

    }

    /**
     * Creates enum instance with short static constructor
     *
     * @param string $name
     * @param array $arguments
     *
     * @return static
     *
     * @throws EnumException
     */
    final public static function __callStatic(string $name, array $arguments)
    {
        return static::createByName($name);
    }

    public static function getConstList(): array
    {
        return array_keys(self::getEnumReflection(static::class)->getConstants());
    }

    private static function getConstantReflection(string $class, string $name): \ReflectionClassConstant

This method seems to be duplicated in your project.

    {
        $key = self::getConstKey($class, $name);
        if (!array_key_exists($key, self::$constReflections)) {
            $refl = self::getEnumReflection(static::class);

            self::$constReflections[$key] = $refl->getReflectionConstant($name);
        }

        return self::$constReflections[$key];
    }

    private static function getConstKey(string $class, string $name): string
    {
        return $class . '::' . $name;
    }

    private static function findParentClassForConst(string $name): string
    {
        return self::getConstantReflection(static::class, $name)->getDeclaringClass()->getName();
    }

    private static function getEnumReflection(string $class): \ReflectionClass
    {
        if (!array_key_exists($class, self::$reflections)) {
            try {
                self::$reflections[$class] = new \ReflectionClass($class);
                // @codeCoverageIgnoreStart
            } catch (\ReflectionException $e) {
                throw new \LogicException('Class should be valid FQCN. Fix internal calls.');
                // @codeCoverageIgnoreEnd
            }
        }

        return self::$reflections[$class];
    }

    /**
     * Create named enum instance
     *
     * @param string $name
     *
     * @return static
     */
    private static function createNamedInstance(string $name)

This method seems to be duplicated in your project.

    {
        $class = self::findParentClassForConst($name);

        $key = self::getConstKey($class, $name);

        if (!array_key_exists($key, self::$instances)) {
            self::$instances[$key] = new static($name);
        }

        return self::$instances[$key];
    }

    final public function getName(): string
    {
        return $this->name;
    }

    /**
     * {@inheritdoc}
     */
    final public function __toString(): string
    {
        return $this->getName();
    }
}