Paillechat\Enum\Enum

Complexity

Total Complexity

14

Size/Duplication

Total Lines	109
Duplicated Lines	21.1 %

Coupling/Cohesion

Components	1
Dependencies	1

Test Coverage

Coverage

100%

Importance

Changes

0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	getConstantReflection()	11	11	2
A	getConstKey()	0	4	1
A	findParentClassForConst()	0	4	1
A	__construct()	0	4	1
A	__callStatic()	0	10	2
A	getConstList()	0	4	1
A	getEnumReflection()	0	8	2
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 with short static constructor
     *
     * @param string $name
     * @param array $arguments
     *
     * @return static
     *
     * @throws EnumException
     */
    final public static function __callStatic(string $name, array $arguments)
    {
        $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.

    }

    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)) {
            self::$reflections[$class] = new \ReflectionClass($class);
        }

        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();
    }
}