Gears\Enum\AbstractEnum

Complexity

Total Complexity

12

Size/Duplication

Total Lines	121
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	2

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	8	1
A	__callStatic()	0	18	3
A	isEqualTo()	0	4	2
A	getValue()	0	4	1
A	checkValue()	0	10	2
A	getValidValues()	0	10	2
A	getAllowedInterfaces()	0	4	1

<?php

/*
 * enum (https://github.com/phpgears/enum).
 * Enum object for PHP.
 *
 * @license MIT
 * @link https://github.com/phpgears/enum
 * @author Julián Gutiérrez <juliangut@gmail.com>
 */

declare(strict_types=1);

namespace Gears\Enum;

use Gears\Enum\Exception\InvalidEnumValueException;
use Gears\Immutability\ImmutabilityBehaviour;

/**
 * Base immutable enum class.
 */
abstract class AbstractEnum implements Enum
{
    use ImmutabilityBehaviour;

    /**
     * Enum class constants map.
     *
     * @var array
     */
    protected static $enumConstantsMap = [];

    /**
     * Enum value.
     *
     * @var mixed
     */
    private $value;

    /**
     * AbstractEnum constructor.
     *
     * @param mixed $value
     *
     * @throws InvalidEnumValueException
     */
    final public function __construct($value)
    {
        $this->checkImmutability();

        $this->checkValue($value);

        $this->value = $value;
    }

    /**
     * Value based static constructor.
     *
     * @param string  $value
     * @param mixed[] $params
     *
     * @return self
     */
    final public static function __callStatic(string $value, array $params)
    {
        if (\count($params) !== 0) {
            throw new InvalidEnumValueException('Enum static constructor must be called with no parameters');
        }

        $validValues = static::getValidValues();

Since getValidValues() 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 getValidValues() to at least protected.

        if (!\array_key_exists($value, $validValues)) {
            throw new InvalidEnumValueException(\sprintf(
                '%s is not a valid value for enum %s',
                $value,
                static::class
            ));
        }

        return new static($validValues[$value]);
    }

    /**
     * {@inheritdoc}
     */
    final public function isEqualTo(Enum $enum): bool
    {
        return \get_class($enum) === static::class && $enum->getValue() === $this->value;
    }

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

    /**
     * Check enum value validity.
     *
     * @param mixed $value
     *
     * @throws InvalidEnumValueException
     */
    private function checkValue($value): void
    {
        if (!\in_array($value, static::getValidValues(), true)) {

Since getValidValues() 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 getValidValues() to at least protected.

            throw new InvalidEnumValueException(\sprintf(
                '%s is not a valid value for enum %s',
                $value,
                static::class
            ));
        }
    }

    /**
     * Get list of valid enum values.
     *
     * @return array<string, mixed>

The doc-type array<string, could not be parsed: Expected ">" at position 5, but found "end of type". (view supported doc-types)

     */
    private static function getValidValues(): array
    {
        $class = static::class;

        if (!isset(static::$enumConstantsMap[$class])) {
            static::$enumConstantsMap[$class] = (new \ReflectionClass($class))->getConstants();
        }

        return static::$enumConstantsMap[$class];
    }

    /**
     * {@inheritdoc}
     *
     * @return string[]
     */
    final protected function getAllowedInterfaces(): array
    {
        return [Enum::class];
    }
}