Paillechat\Enum\Enum

Complexity

Total Complexity

17

Size/Duplication

Total Lines	130
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	1

Test Coverage

Coverage

100%

Importance

Changes

0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	10	2
A	getConstList()	0	18	3
A	__callStatic()	0	10	2
A	getDefaultValue()	0	10	2
A	getValue()	0	4	1
A	equals()	0	4	2
A	__toString()	0	4	1
A	assertValue()	0	10	4

<?php

namespace Paillechat\Enum;

use Paillechat\Enum\Exception\EnumException;

abstract class Enum
{
    /** @var string */
    private static $defaultConstantName = '__default';
    /** @var \ReflectionClass[] */
    private static $reflections;
    /** @var mixed */
    protected $value;

    /**
     * @param mixed $value
     *
     * @throws EnumException
     */
    final public function __construct($value = null)
    {
        if ($value === null) {
            $value = static::getDefaultValue();
        }

        $this->assertValue($value);

        $this->value = $value;
    }

    /**
     * @param bool $includeDefault
     *
     * @return array
     */
    final public static function getConstList(bool $includeDefault = false): array
    {
        self::$reflections[static::class] =
            self::$reflections[static::class] ??
            new \ReflectionClass(static::class);

        return array_filter(
            self::$reflections[static::class]->getConstants(),
            function ($key) use ($includeDefault) {
                if ($includeDefault === false && $key === self::$defaultConstantName) {
                    return false;
                }

                return true;
            },
            ARRAY_FILTER_USE_KEY
        );
    }

    /**
     * Creates enum instance with short static constructor
     *
     * @param string $name
     * @param array $arguments
     *
     * @return static
     *
     * @throws \BadMethodCallException
     */
    final public static function __callStatic(string $name, array $arguments)
    {
        $const = static::getConstList();

        if (!array_key_exists($name, $const)) {
            throw new \BadMethodCallException(sprintf('Unknown static constructor "%s" for %s', $name, static::class));
        }

        return new static($const[$name]);
    }

    /**
     * @return mixed
     *
     * @throws EnumException
     */
    protected static function getDefaultValue()
    {
        $const = static::getConstList(true);

        if (!array_key_exists(self::$defaultConstantName, $const)) {
            throw EnumException::becauseNoDefaultValue(static::class);
        }

        return $const[self::$defaultConstantName];
    }

    /**
     * @return mixed
     */
    final public function getValue()
    {
        return $this->value;
    }

    /**
     * Compares one Enum with another.
     *
     * @param Enum $enum
     *
     * @return bool True if Enums are equal, false if not equal
     */
    final public function equals(Enum $enum)
    {
        return $this->getValue() === $enum->getValue() && static::class === get_class($enum);
    }

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

    /**
     * @param mixed $value
     *
     * @throws EnumException
     */
    private function assertValue($value)
    {
        $const = static::getConstList(true);

        $defaultValueUsed = $value === null && isset($const[self::$defaultConstantName]);

        if (!$defaultValueUsed && !in_array($value, $const, true)) {
            throw EnumException::becauseUnrecognisedValue(static::class, $value);
        }
    }
}