Enum::resolveByIndex() - Code Metrics - Inspection of "v3" - spatie/enum - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#56)

by Brent

created 2020-05-28 11:48 UTC

Enum::resolveByIndex() A

↳ Parent: Project

Complexity

Conditions	1
Paths	1

Size

Total Lines	6
Code Lines	3

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	1
eloc	3
c	1
b	0
f	0
nc	1
nop	1
dl	0
loc	6
rs	10

<?php

namespace Spatie\Enum;

use BadMethodCallException;
use JsonSerializable;
use ReflectionClass;
use Spatie\Enum\Exceptions\DuplicateLabelsException;
use Spatie\Enum\Exceptions\DuplicateValuesException;

/**
 * @property-read string value
 * @property-read string label
 */
abstract class Enum implements JsonSerializable
{
    /** @var string|int */
    protected $value;

    protected string $label;

    private static array $definitionCache = [];

    public static function toArray(): array
    {
        $array = [];

        foreach (static::resolveDefinition() as $definition) {
            $array[$definition->value] = $definition->label;
        }

        return $array;
    }

    /**
     * @param string|int $value
     */
    public static function make($value): Enum
    {
        return new static($value);
    }

    /**
     * @param string|int $value
     */
    public function __construct($value)
    {
        $definition = $this->findDefinition($value);

        if ($definition === null) {
            $enumClass = static::class;

            throw new BadMethodCallException("There's no value {$value} defined for enum {$enumClass}, consider adding it in the docblock definition.");
        }

        $this->value = $definition->value;

        $this->label = $definition->label;

    }

    public function __get($name)
    {
        if ($name === 'label') {
            return $this->label;
        }

        if ($name === 'value') {
            return $this->value;
        }
    }

    public static function __callStatic(string $name, array $arguments)
    {
        return new static($name);
    }

    public function __call($name, $arguments)
    {
        if (strpos($name, 'is') === 0) {
            $other = new static(str_replace('is', '', $name));

            return $this->equals($other);
        }
    }

    public function equals(Enum ...$others): bool
    {
        foreach ($others as $other) {
            if (
                get_class($this) === get_class($other)
                && $this->value === $other->value
            ) {
                return true;
            }
        }

        return false;
    }

    protected static function values(): array
    {
        return [];
    }

    protected static function labels(): array
    {
        return [];
    }

    private function findDefinition($input): ?EnumDefinition
    {
        foreach (static::resolveDefinition() as $definition) {
            if ($definition->equals($input)) {
                return $definition;
            }
        }

        return null;
    }

    /**
     * @return \Spatie\Enum\EnumDefinition[]|null
     */
    private static function resolveDefinition(): array
    {
        $className = static::class;

        if (static::$definitionCache[$className] ?? null) {

            return static::$definitionCache[$className];
        }

        $reflectionClass = new ReflectionClass($className);

        $docComment = $reflectionClass->getDocComment();

        preg_match_all('/@method static self ([\w_]+)\(\)/', $docComment, $matches);

        $definition = [];

        $valueMap = static::values();

        if (self::arrayHasDuplicates($valueMap)) {
            throw new DuplicateValuesException(static::class);
        }

        $labelMap = static::labels();

        if (self::arrayHasDuplicates($labelMap)) {
            throw new DuplicateLabelsException(static::class);
        }

        foreach ($matches[1] as $methodName) {
            $value = $valueMap[$methodName] ?? $methodName;

            $label = $labelMap[$methodName] ?? $methodName;

            $definition[$methodName] = new EnumDefinition($methodName, $value, $label);
        }

        return static::$definitionCache[$className] ??= $definition;
    }

    private static function arrayHasDuplicates(array $array): bool
    {
        return count($array) > count(array_unique($array));
    }

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


1			<?php
2
3			namespace Spatie\Enum;
4
5			use BadMethodCallException;
6			use JsonSerializable;
7			use ReflectionClass;
8			use Spatie\Enum\Exceptions\DuplicateLabelsException;
9			use Spatie\Enum\Exceptions\DuplicateValuesException;
10
11			/**
12			* @property-read string value
13			* @property-read string label
14			*/
15			abstract class Enum implements JsonSerializable
16			{
17			/** @var string\|int */
18			protected $value;
19
20			protected string $label;
21
22			private static array $definitionCache = [];
23
24			public static function toArray(): array
25			{
26			$array = [];
27
28			foreach (static::resolveDefinition() as $definition) {
29			$array[$definition->value] = $definition->label;
30			}
31
32			return $array;
33			}
34
35			/**
36			* @param string\|int $value
37			*/
38			public static function make($value): Enum
39			{
40			return new static($value);
41			}
42
43			/**
44			* @param string\|int $value
45			*/
46			public function __construct($value)
47			{
48			$definition = $this->findDefinition($value);
49
50			if ($definition === null) {
51			$enumClass = static::class;
52
53			throw new BadMethodCallException("There's no value {$value} defined for enum {$enumClass}, consider adding it in the docblock definition.");
54			}
55
56			$this->value = $definition->value;
			0 ignored issues – show Bug introduced 2020-05-20 07:39 UTC by Report Bug Copy Issue Report The property `value` is declared read-only in `Spatie\Enum\Enum`. Loading history...
57			$this->label = $definition->label;
			0 ignored issues – show Bug introduced 2020-05-20 07:39 UTC by Report Bug Copy Issue Report The property `label` is declared read-only in `Spatie\Enum\Enum`. Loading history...
58			}
59
60			public function __get($name)
61			{
62			if ($name === 'label') {
63			return $this->label;
64			}
65
66			if ($name === 'value') {
67			return $this->value;
68			}
69			}
70
71			public static function __callStatic(string $name, array $arguments)
72			{
73			return new static($name);
74			}
75
76			public function __call($name, $arguments)
77			{
78			if (strpos($name, 'is') === 0) {
79			$other = new static(str_replace('is', '', $name));
80
81			return $this->equals($other);
82			}
83			}
84
85			public function equals(Enum ...$others): bool
86			{
87			foreach ($others as $other) {
88			if (
89			get_class($this) === get_class($other)
90			&& $this->value === $other->value
91			) {
92			return true;
93			}
94			}
95
96			return false;
97			}
98
99			protected static function values(): array
100			{
101			return [];
102			}
103
104			protected static function labels(): array
105			{
106			return [];
107			}
108
109			private function findDefinition($input): ?EnumDefinition
110			{
111			foreach (static::resolveDefinition() as $definition) {
112			if ($definition->equals($input)) {
113			return $definition;
114			}
115			}
116
117			return null;
118			}
119
120			/**
121			* @return \Spatie\Enum\EnumDefinition[]\|null
122			*/
123			private static function resolveDefinition(): array
124			{
125			$className = static::class;
126
127			if (static::$definitionCache[$className] ?? null) {
			0 ignored issues – show Bug introduced 2020-05-15 13:49 UTC by Report Bug Copy Issue Report Since `$definitionCache` is declared private, accessing it with `static` will lead to errors in possible sub-classes; you can either use `self`, or increase the visibility of `$definitionCache` to at least protected. Loading history...
128			return static::$definitionCache[$className];
129			}
130
131			$reflectionClass = new ReflectionClass($className);
132
133			$docComment = $reflectionClass->getDocComment();
134
135			preg_match_all('/@method static self ([\w_]+)\(\)/', $docComment, $matches);
136
137			$definition = [];
138
139			$valueMap = static::values();
140
141			if (self::arrayHasDuplicates($valueMap)) {
142			throw new DuplicateValuesException(static::class);
143			}
144
145			$labelMap = static::labels();
146
147			if (self::arrayHasDuplicates($labelMap)) {
148			throw new DuplicateLabelsException(static::class);
149			}
150
151			foreach ($matches[1] as $methodName) {
152			$value = $valueMap[$methodName] ?? $methodName;
153
154			$label = $labelMap[$methodName] ?? $methodName;
155
156			$definition[$methodName] = new EnumDefinition($methodName, $value, $label);
157			}
158
159			return static::$definitionCache[$className] ??= $definition;
160			}
161
162			private static function arrayHasDuplicates(array $array): bool
163			{
164			return count($array) > count(array_unique($array));
165			}
166
167			public function jsonSerialize(): string
168			{
169			return (string) $this->value;
170			}
171			}
172

spatie / enum

Pull Request — master (#56)

Enum::resolveByIndex() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like