Werkspot\Enum\AbstractEnum

Complexity

Total Complexity

18

Size/Duplication

Total Lines	100
Duplicated Lines	21 %

Coupling/Cohesion

Components	2
Dependencies	2

Test Coverage

Coverage

100%

Importance

Changes

0

12 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	15	2
A	get()	0	4	1
A	__callStatic()	11	11	3
A	__call()	10	10	3
A	getValue()	0	4	1
A	equals()	0	4	2
A	__toString()	0	4	1
A	isValid()	0	4	1
A	getValidOptions()	0	4	1
A	getClassName()	0	4	1
A	getConstants()	0	4	1
A	getValidOptionsAsString()	0	9	1

<?php

declare(strict_types=1);

namespace Werkspot\Enum;

use BadMethodCallException;
use Doctrine\Common\Inflector\Inflector;
use InvalidArgumentException;
use ReflectionClass;
use Werkspot\Enum\Util\ClassNameConverter;

abstract class AbstractEnum
{
    protected $value;

    protected function __construct($value)
    {
        if (!$this->isValid($value)) {
            $message = 'Value [%s] is not matching any valid value of class "%s". Valid values are [%s].';

            throw new InvalidArgumentException(sprintf(
                $message,
                $value,
                $this->getClassName(),
                self::getValidOptionsAsString()
            ));
        }

        $this->value = $value;
    }

    /**
     * @return static
     */
    public static function get($value): self
    {
        return new static($value);
    }

    public static function __callStatic(string $methodName, array $arguments): self
    {
        foreach (self::getConstants() as $option => $value) {
            $expectedMethodName = lcfirst(Inflector::classify(strtolower($option)));
            if ($expectedMethodName === $methodName) {
                return new static($value);
            }
        }

        throw new BadMethodCallException(sprintf('%s::%s() does not exist', static::class, $methodName));
    }

    public function __call(string $methodName, array $arguments)
    {
        foreach (self::getConstants() as $option => $value) {
            $isaMethodName = 'is' . ucfirst(Inflector::classify(strtolower($option)));
            if ($isaMethodName === $methodName) {
                return $this->equals(static::get($value));
            }
        }
        throw new BadMethodCallException(sprintf('%s::%s() does not exist', static::class, $methodName));
    }


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

    public function equals(self $other): bool
    {
        return get_class($other) === get_class($this) && $other->getValue() === $this->value;
    }

    public function __toString(): string
    {
        return (string) $this->value;
    }

    protected function isValid($value): bool
    {
        return in_array($value, self::getValidOptions(), true);
    }

    public static function getValidOptions(): array
    {
        return array_values(self::getConstants());
    }

    protected function getClassName(): string
    {
        return ClassNameConverter::stripNameSpace(static::class);
    }

    private static function getConstants(): array
    {
        return (new ReflectionClass(static::class))->getConstants();
    }

    private static function getValidOptionsAsString(): string
    {
        return implode(
            ', ',
            array_map(function ($option) {
                return var_export($option, true);
            }, self::getValidOptions())
        );
    }
}