Enum::equals() - Code Metrics - atrapalo/php-tools - Measure and Improve Code Quality continuously with Scrutinizer

Enum::equals() A
last analyzed 2018-03-02 11:30 UTC

↳ Parent: Enum

Complexity

Conditions	2
Paths	2

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	2
CRAP Score	2

Importance

Changes

Metric	Value
dl	0
loc	4
ccs	2
cts	2
cp	1
rs	10
c	0
b	0
f	0
nc	2
cc	2
eloc	2
nop	1
crap	2

<?php

namespace Atrapalo\PHPTools\Enum;

/**
 * Class Enum
 * @package Atrapalo\PHPTools\Enum
 *
 * @author Guillermo González <[email protected]>
 */
abstract class Enum
{
    /**
     * @var mixed
     */
    protected $value;

    /**
     * @var array
     */
    protected static $cache = array();

    /**
     * @param mixed $value
     * @throws \Exception
     */
    public function __construct($value)
    {
        if (!$this->isValid($value)) {
            throw static::customInvalidValueException($value);
        }

        $this->value = $value;
    }

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

    /**
     * @return mixed
     */
    public function key()
    {
        return static::search($this->value);
    }

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

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

    /**
     * @return array
     */
    public static function keys(): array
    {
        return array_keys(static::toArray());
    }

    /**
     * @return static[] Constant name in key, Enum instance in value
     */
    public static function values(): array
    {
        $values = array();

        foreach (static::toArray() as $key => $value) {
            $values[$key] = new static($value);
        }

        return $values;
    }

    /**
     * @return array Constant name in key, constant value in value
     */
    public static function toArray(): array
    {
        $class = get_called_class();
        if (!array_key_exists($class, static::$cache)) {
            $reflection            = new \ReflectionClass($class);
            static::$cache[$class] = $reflection->getConstants();
        }

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

    /**
     * @param $value
     * @return bool
     */
    public static function isValid($value): bool
    {
        return in_array($value, static::toArray(), true);
    }

    /**
     * @param $key
     * @return bool
     */
    public static function isValidKey($key): bool
    {
        $array = static::toArray();

        return isset($array[$key]);
    }

    /**
     * @param $value
     * @return mixed
     */
    public static function search($value)
    {
        return array_search($value, static::toArray(), true);
    }

    /**
     * Returns a value when called statically like so: MyEnum::someValue() given SOME_VALUE is a class constant
     * @example MyEnum::someValue()
     *
     * @param string $name
     * @param array  $arguments
     * @return static
     * @throws \Exception
     */
    public static function __callStatic($name, $arguments)
    {
        $key = self::toSnakeCase($name);
        $array = static::toArray();
        if (array_key_exists($key, $array)) {
            return new static($array[$key]);
        }

        throw static::customUnknownStaticMethodException($name);
    }


    /**
     * Check if a given key is selected using the "isKey" syntax.
     * @example $myEnum->isSomeValue()
     *
     * @param string $method
     * @param        $arguments
     * @return bool
     * @throws \Exception
     */
    public function __call($method, $arguments): bool
    {
        if (substr($method, 0, 2) === 'is')  {
            $key = $this->toSnakeCase(substr($method, 2));
            $array = static::toArray();
            if (array_key_exists($key, $array)) {
                return $this->value() === $array[$key];
            }
        }

        throw static::customUnknownMethodException($method);
    }

    /**
     * @param string $string
     * @return string
     */
    private static function toSnakeCase(string $string): string
    {
        return strtoupper(preg_replace(
            '/(?<=\d)(?=[A-Za-z])|(?<=[A-Za-z])(?=\d)|(?<=[a-z])(?=[A-Z])/',
            '_',
            $string
        ));
    }

    /**
     * @param string $value
     * @return \Exception
     */
    public static function customInvalidValueException(string $value): \Exception
    {
        return new \UnexpectedValueException("Value '$value' is not part of the enum " . get_called_class());
    }

    /**
     * @param string $method
     * @return \Exception
     */
    public static function customUnknownStaticMethodException(string $method): \Exception
    {
        return new \BadMethodCallException("No static method or enum constant '$method' in class " . get_called_class());
    }

    /**
     * @param string $method
     * @return \Exception
     */
    public static function customUnknownMethodException(string $method): \Exception
    {
        return new \BadMethodCallException(sprintf('The method "%s" is not defined.', $method));
    }
}

1		<?php
2
3		namespace Atrapalo\PHPTools\Enum;
4
5		/**
6		* Class Enum
7		* @package Atrapalo\PHPTools\Enum
8		*
9		* @author Guillermo González <[email protected]>
10		*/
11		abstract class Enum
12		{
13		/**
14		* @var mixed
15		*/
16		protected $value;
17
18		/**
19		* @var array
20		*/
21		protected static $cache = array();
22
23		/**
24		* @param mixed $value
25		* @throws \Exception
26		*/
27	17	public function __construct($value)
28		{
29	17	if (!$this->isValid($value)) {
30	5	throw static::customInvalidValueException($value);
31		}
32
33	12	$this->value = $value;
34	12	}
35
36		/**
37		* @return mixed
38		*/
39	5	public function value()
40		{
41	5	return $this->value;
42		}
43
44		/**
45		* @return mixed
46		*/
47	2	public function key()
48		{
49	2	return static::search($this->value);
50		}
51
52		/**
53		* @return string
54		*/
55	3	public function __toString(): string
56		{
57	3	return (string) $this->value;
58		}
59
60		/**
61		* @param Enum $enum
62		* @return bool True if Enums are equal, false if not equal
63		*/
64	2	public function equals(Enum $enum): bool
65		{
66	2	return $this->value() === $enum->value() && static::class === get_class($enum);
67		}
68
69		/**
70		* @return array
71		*/
72	1	public static function keys(): array
73		{
74	1	return array_keys(static::toArray());
75		}
76
77		/**
78		* @return static[] Constant name in key, Enum instance in value
79		*/
80	1	public static function values(): array
81		{
82	1	$values = array();
83
84	1	foreach (static::toArray() as $key => $value) {
85	1	$values[$key] = new static($value);
86		}
87
88	1	return $values;
89		}
90
91		/**
92		* @return array Constant name in key, constant value in value
93		*/
94	37	public static function toArray(): array
95		{
96	37	$class = get_called_class();
97	37	if (!array_key_exists($class, static::$cache)) {
98	2	$reflection = new \ReflectionClass($class);
99	2	static::$cache[$class] = $reflection->getConstants();
100		}
101
102	37	return static::$cache[$class];
103		}
104
105		/**
106		* @param $value
107		* @return bool
108		*/
109	24	public static function isValid($value): bool
110		{
111	24	return in_array($value, static::toArray(), true);
112		}
113
114		/**
115		* @param $key
116		* @return bool
117		*/
118	1	public static function isValidKey($key): bool
119		{
120	1	$array = static::toArray();
121
122	1	return isset($array[$key]);
123		}
124
125		/**
126		* @param $value
127		* @return mixed
128		*/
129	9	public static function search($value)
130		{
131	9	return array_search($value, static::toArray(), true);
132		}
133
134		/**
135		* Returns a value when called statically like so: MyEnum::someValue() given SOME_VALUE is a class constant
136		* @example MyEnum::someValue()
137		*
138		* @param string $name
139		* @param array $arguments
140		* @return static
141		* @throws \Exception
142		*/
143	5	public static function __callStatic($name, $arguments)
144		{
145	5	$key = self::toSnakeCase($name);
146	5	$array = static::toArray();
147	5	if (array_key_exists($key, $array)) {
148	2	return new static($array[$key]);
149		}
150
151	3	throw static::customUnknownStaticMethodException($name);
152		}
153
154
155		/**
156		* Check if a given key is selected using the "isKey" syntax.
157		* @example $myEnum->isSomeValue()
158		*
159		* @param string $method
160		* @param $arguments
161		* @return bool
162		* @throws \Exception
163		*/
164	5	public function __call($method, $arguments): bool
165		{
166	5	if (substr($method, 0, 2) === 'is') {
167	4	$key = $this->toSnakeCase(substr($method, 2));
168	4	$array = static::toArray();
169	4	if (array_key_exists($key, $array)) {
170	2	return $this->value() === $array[$key];
171		}
172		}
173
174	3	throw static::customUnknownMethodException($method);
175		}
176
177		/**
178		* @param string $string
179		* @return string
180		*/
181	9	private static function toSnakeCase(string $string): string
182		{
183	9	return strtoupper(preg_replace(
184	9	'/(?<=\d)(?=[A-Za-z])\|(?<=[A-Za-z])(?=\d)\|(?<=[a-z])(?=[A-Z])/',
185	9	'_',
186	9	$string
187		));
188		}
189
190		/**
191		* @param string $value
192		* @return \Exception
193		*/
194	3	public static function customInvalidValueException(string $value): \Exception
195		{
196	3	return new \UnexpectedValueException("Value '$value' is not part of the enum " . get_called_class());
197		}
198
199		/**
200		* @param string $method
201		* @return \Exception
202		*/
203	2	public static function customUnknownStaticMethodException(string $method): \Exception
204		{
205	2	return new \BadMethodCallException("No static method or enum constant '$method' in class " . get_called_class());
206		}
207
208		/**
209		* @param string $method
210		* @return \Exception
211		*/
212	2	public static function customUnknownMethodException(string $method): \Exception
213		{
214	2	return new \BadMethodCallException(sprintf('The method "%s" is not defined.', $method));
215		}
216		}

atrapalo / php-tools

Enum::equals() A last analyzed 2018-03-02 11:30 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

Enum::equals() A
last analyzed 2018-03-02 11:30 UTC