Gears\Enum\AbstractEnum

Complexity

Total Complexity

15

Size/Duplication

Total Lines	135
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	3

Importance

Changes

0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	8	1
A	__callStatic()	0	18	3
A	isEqualTo()	0	4	2
A	isAnyOf()	0	10	3
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 $enumCacheMap = [];

    /**
     * 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 isAnyOf(array $enums): bool
    {
        foreach ($enums as $enum) {
            if ($this->isEqualTo($enum)) {
                return true;
            }
        }

        return false;
    }

    /**
     * {@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
    {
        $enumClass = static::class;

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

        return static::$enumCacheMap[$enumClass];
    }

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