Enum::detectConstants() - Code Metrics - Inspection of "travis fix" - marc-mabe/php-enum - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — 2.x ( e67bba...dc329d )

by Marc

created 2017-07-02 11:44 UTC

Enum::detectConstants() D

↳ Parent: Enum

Complexity

Conditions	10
Paths	5

Size

Total Lines	46
Code Lines	27

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	23
CRAP Score	10.0071

Importance

Changes

Metric	Value
dl	0
loc	46
ccs	23
cts	24
cp	0.9583
rs	4.983
c	0
b	0
f	0
cc	10
eloc	27
nc	5
nop	1
crap	10.0071

How to fix Complexity

<?php

namespace MabeEnum;

use ReflectionClass;
use InvalidArgumentException;
use LogicException;

/**
 * Class to implement enumerations for PHP 5 (without SplEnum)
 *
 * @link http://github.com/marc-mabe/php-enum for the canonical source repository
 * @copyright Copyright (c) 2015 Marc Bennewitz
 * @license http://github.com/marc-mabe/php-enum/blob/master/LICENSE.txt New BSD License
 */
abstract class Enum
{
    /**
     * The selected enumerator value
     *
     * @var null|bool|int|float|string
     */
    private $value;

    /**
     * The ordinal number of the enumerator
     *
     * @var null|int
     */
    private $ordinal;

    /**
     * An array of available constants by class
     *
     * @var array ["$class" => ["$name" => $value, ...], ...]
     */
    private static $constants = array();

    /**
     * Already instantiated enumerators
     *
     * @var array ["$class" => ["$name" => $instance, ...], ...]
     */
    private static $instances = array();

    /**
     * Constructor
     *
     * @param null|bool|int|float|string $value   The value of the enumerator
     * @param int|null                   $ordinal The ordinal number of the enumerator
     */
    final private function __construct($value, $ordinal = null)
    {
        $this->value   = $value;
        $this->ordinal = $ordinal;
    }

    /**
     * Get the name of the enumerator
     *
     * @return string
     * @see getName()
     */
    public function __toString()
    {
        return $this->getName();
    }

    /**
     * @throws LogicException Enums are not cloneable
     *                        because instances are implemented as singletons
     */
    final private function __clone()
    {
        throw new LogicException('Enums are not cloneable');
    }

    /**
     * @throws LogicException Enums are not serializable
     *                        because instances are implemented as singletons
     */
    final public function __sleep()
    {
        throw new LogicException('Enums are not serializable');
    }

    /**
     * @throws LogicException Enums are not serializable
     *                        because instances are implemented as singletons
     */
    final public function __wakeup()
    {
        throw new LogicException('Enums are not serializable');
    }

    /**
     * Get the value of the enumerator
     *
     * @return null|bool|int|float|string
     */
    final public function getValue()
    {
        return $this->value;
    }

    /**
     * Get the name of the enumerator
     *
     * @return string
     */
    final public function getName()
    {
        return array_search($this->value, self::detectConstants(get_called_class()), true);
    }

    /**
     * Get the ordinal number of the enumerator
     *
     * @return int
     */
    final public function getOrdinal()
    {
        if ($this->ordinal !== null) {
            return $this->ordinal;
        }

        // detect ordinal
        $ordinal = 0;
        $value   = $this->value;
        foreach (self::detectConstants(get_called_class()) as $constValue) {
            if ($value === $constValue) {
                break;
            }
            ++$ordinal;
        }

        $this->ordinal = $ordinal;
        return $ordinal;
    }

    /**
     * Compare this enumerator against another and check if it's the same.
     *
     * @param mixed $enumerator
     * @return bool
     */
    final public function is($enumerator)
    {
        return $this === $enumerator || $this->value === $enumerator

            // The following additional conditions are required only because of the issue of serializable singletons
            || ($enumerator instanceof static
                && get_class($enumerator) === get_called_class()
                && $enumerator->value === $this->value
            );
    }

    /**
     * Get an enumerator instance of the given value or instance
     *
     * @param static|null|bool|int|float|string $value
     * @return static
     * @throws InvalidArgumentException On an unknwon or invalid value
     * @throws LogicException           On ambiguous constant values
     */
    final public static function get($value)
    {
        if ($value instanceof static && get_class($value) === get_called_class()) {
            return $value;
        }

        return static::byValue($value);
    }

    /**
     * Get an enumerator instance by the given value
     *
     * @param mixed $value
     * @return static
     * @throws InvalidArgumentException On an unknwon or invalid value
     * @throws LogicException           On ambiguous constant values
     */
    final public static function byValue($value)
    {
        $class     = get_called_class();
        $constants = self::detectConstants($class);
        $name      = array_search($value, $constants, true);
        if ($name === false) {
            $message = is_scalar($value)
                ? 'Unknown value ' . var_export($value, true)
                : 'Invalid value of type ' . (is_object($value) ? get_class($value) : gettype($value));
            throw new InvalidArgumentException($message);
        }

        if (!isset(self::$instances[$class][$name])) {
            self::$instances[$class][$name] = new $class($constants[$name]);
        }

        return self::$instances[$class][$name];
    }

    /**
     * Get an enumerator instance by the given name
     *
     * @param string $name The name of the enumerator
     * @return static
     * @throws InvalidArgumentException On an invalid or unknown name
     * @throws LogicException           On ambiguous values
     */
    final public static function byName($name)
    {
        $name  = (string) $name;
        $class = get_called_class();
        if (isset(self::$instances[$class][$name])) {
            return self::$instances[$class][$name];
        }

        $const = $class . '::' . $name;
        if (!defined($const)) {
            throw new InvalidArgumentException($const . ' not defined');
        }

        return self::$instances[$class][$name] = new $class(constant($const));
    }

    /**
     * Get an enumeration instance by the given ordinal number
     *
     * @param int $ordinal The ordinal number or the enumerator
     * @return static
     * @throws InvalidArgumentException On an invalid ordinal number
     * @throws LogicException           On ambiguous values
     */
    final public static function byOrdinal($ordinal)
    {
        $ordinal   = (int) $ordinal;
        $class     = get_called_class();
        $constants = self::detectConstants($class);
        $item      = array_slice($constants, $ordinal, 1, true);
        if (empty($item)) {
            throw new InvalidArgumentException(sprintf(
                'Invalid ordinal number, must between 0 and %s',
                count($constants) - 1
            ));
        }

        $name = key($item);
        if (isset(self::$instances[$class][$name])) {
            return self::$instances[$class][$name];
        }

        return self::$instances[$class][$name] = new $class(current($item), $ordinal);
    }

    /**
     * Get an enumerator instance by the given name
     *
     * @param string $name The name of the enumerator
     * @return static
     * @throws InvalidArgumentException On an invalid or unknown name
     * @throws LogicException           On ambiguous values
     * @deprecated
     */
    final public static function getByName($name)
    {
        return static::byName($name);
    }

    /**
     * Get an enumeration instance by the given ordinal number
     *
     * @param int $ordinal The ordinal number or the enumerator
     * @return static
     * @throws InvalidArgumentException On an invalid ordinal number
     * @throws LogicException           On ambiguous values
     * @deprecated
     */
    final public static function getByOrdinal($ordinal)
    {
        return static::byOrdinal($ordinal);
    }

    /**
     * Clear all instantiated enumerators of the called class
     *
     * NOTE: This can break singleton behavior ... use it with caution!
     *
     * @return void
     * @deprecated
     */
    final public static function clear()
    {
        $class = get_called_class();
        unset(self::$instances[$class], self::$constants[$class]);
    }

    /**
     * Get a list of enumerator instances ordered by ordinal number
     *
     * @return static[]
     */
    final public static function getEnumerators()
    {
        return array_map('self::byName', array_keys(self::detectConstants(get_called_class())));
    }

    /**
     * Get a list of enumerator values ordered by ordinal number
     *
     * @return mixed[]
     */
    final public static function getValues()
    {
        return array_values(self::detectConstants(get_called_class()));
    }

    /**
     * Get a list of enumerator names ordered by ordinal number
     *
     * @return string[]
     */
    final public static function getNames()
    {
        return array_keys(self::detectConstants(get_called_class()));
    }
    /*
     * Get a list of enumerator ordinal numbers
     *
     * @return int[]
     */
    final public static function getOrdinals()
    {
        $count = count(self::detectConstants(get_called_class()));
        return $count === 0 ? array() : range(0, $count - 1);
    }

    /**
     * Get all available constants of the called class
     *
     * @return array
     * @throws LogicException On ambiguous constant values
     */
    final public static function getConstants()
    {
        return self::detectConstants(get_called_class());
    }

    /**
     * Is the given enumerator part of this enumeration
     * 
     * @param static|null|bool|int|float|string $value
     * @return bool
     */
    final public static function has($value)
    {
        if ($value instanceof static && get_class($value) === get_called_class()) {
            return true;
        }

        $class     = get_called_class();
        $constants = self::detectConstants($class);

        return in_array($value, $constants, true);
    }

    /**
     * Detect all available constants by the given class
     *
     * @param string $class
     * @return array
     * @throws LogicException On ambiguous constant values
     */
    private static function detectConstants($class)
    {
        if (!isset(self::$constants[$class])) {
            $reflection = new ReflectionClass($class);
            $constants  = array();

            do {
                $scopeConstants = array();
                if (PHP_VERSION_ID >= 70100) {
                    // Since PHP-7.1 visibility modifiers are allowed for class constants
                    // for enumerations we are only interested in public once.
                    foreach ($reflection->getReflectionConstants() as $reflConstant) {
                        if ($reflConstant->isPublic()) {
                            $scopeConstants[ $reflConstant->getName() ] = $reflConstant->getValue();
                        }
                    }
                } else {
                    // In PHP < 7.1 all class constants were public by definition
                    $scopeConstants = $reflection->getConstants();
                }

                $constants = $scopeConstants + $constants;
            } while (($reflection = $reflection->getParentClass()) && $reflection->name !== __CLASS__);

            // Detect ambiguous values and report names
            $ambiguous = array();
            foreach ($constants as $value) {
                $names = array_keys($constants, $value, true);
                if (count($names) > 1) {
                    $ambiguous[var_export($value, true)] = $names;
                }
            }
            if (!empty($ambiguous)) {
                throw new LogicException(
                    'All possible values needs to be unique. The following are ambiguous: '
                    . implode(', ', array_map(function ($names) use ($constants) {
                        return implode('/', $names) . '=' . var_export($constants[$names[0]], true);
                    }, $ambiguous))
                );
            }

            self::$constants[$class] = $constants;
        }

        return self::$constants[$class];
    }

    /**
     * Get an enumerator instance by the given name.
     *
     * This will be called automatically on calling a method
     * with the same name of a defined enumerator.
     *
     * @param string $method The name of the enumeraotr (called as method)
     * @param array  $args   There should be no arguments
     * @return static
     * @throws InvalidArgumentException On an invalid or unknown name
     * @throws LogicException           On ambiguous constant values
     */
    final public static function __callStatic($method, array $args)
    {
        return self::byName($method);
    }
}


1			<?php
2
3			namespace MabeEnum;
4
5			use ReflectionClass;
6			use InvalidArgumentException;
7			use LogicException;
8
9			/**
10			* Class to implement enumerations for PHP 5 (without SplEnum)
11			*
12			* @link http://github.com/marc-mabe/php-enum for the canonical source repository
13			* @copyright Copyright (c) 2015 Marc Bennewitz
14			* @license http://github.com/marc-mabe/php-enum/blob/master/LICENSE.txt New BSD License
15			*/
16			abstract class Enum
17			{
18			/**
19			* The selected enumerator value
20			*
21			* @var null\|bool\|int\|float\|string
22			*/
23			private $value;
24
25			/**
26			* The ordinal number of the enumerator
27			*
28			* @var null\|int
29			*/
30			private $ordinal;
31
32			/**
33			* An array of available constants by class
34			*
35			* @var array ["$class" => ["$name" => $value, ...], ...]
36			*/
37			private static $constants = array();
38
39			/**
40			* Already instantiated enumerators
41			*
42			* @var array ["$class" => ["$name" => $instance, ...], ...]
43			*/
44			private static $instances = array();
45
46			/**
47			* Constructor
48			*
49			* @param null\|bool\|int\|float\|string $value The value of the enumerator
50			* @param int\|null $ordinal The ordinal number of the enumerator
51			*/
52	16		final private function __construct($value, $ordinal = null)
53			{
54	16		$this->value = $value;
55	16		$this->ordinal = $ordinal;
56	16		}
57
58			/**
59			* Get the name of the enumerator
60			*
61			* @return string
62			* @see getName()
63			*/
64	1		public function __toString()
65			{
66	1		return $this->getName();
67			}
68
69			/**
70			* @throws LogicException Enums are not cloneable
71			* because instances are implemented as singletons
72			*/
73	1		final private function __clone()
74			{
75	1		throw new LogicException('Enums are not cloneable');
76			}
77
78			/**
79			* @throws LogicException Enums are not serializable
80			* because instances are implemented as singletons
81			*/
82	1		final public function __sleep()
83			{
84	1		throw new LogicException('Enums are not serializable');
85			}
86
87			/**
88			* @throws LogicException Enums are not serializable
89			* because instances are implemented as singletons
90			*/
91	1		final public function __wakeup()
92			{
93	1		throw new LogicException('Enums are not serializable');
94			}
95
96			/**
97			* Get the value of the enumerator
98			*
99			* @return null\|bool\|int\|float\|string
100			*/
101	22		final public function getValue()
102			{
103	22		return $this->value;
104			}
105
106			/**
107			* Get the name of the enumerator
108			*
109			* @return string
110			*/
111	8		final public function getName()
112			{
113	8		return array_search($this->value, self::detectConstants(get_called_class()), true);
114			}
115
116			/**
117			* Get the ordinal number of the enumerator
118			*
119			* @return int
120			*/
121	44		final public function getOrdinal()
122			{
123	44		if ($this->ordinal !== null) {
124	43		return $this->ordinal;
125			}
126
127			// detect ordinal
128	9		$ordinal = 0;
129	9		$value = $this->value;
130	9		foreach (self::detectConstants(get_called_class()) as $constValue) {
131	9		if ($value === $constValue) {
132	9		break;
133			}
134	9		++$ordinal;
135			}
136
137	9		$this->ordinal = $ordinal;
138	9		return $ordinal;
139			}
140
141			/**
142			* Compare this enumerator against another and check if it's the same.
143			*
144			* @param mixed $enumerator
145			* @return bool
146			*/
147	2		final public function is($enumerator)
148			{
149	2		return $this === $enumerator \|\| $this->value === $enumerator
150
151			// The following additional conditions are required only because of the issue of serializable singletons
152	2		\|\| ($enumerator instanceof static
153	2		&& get_class($enumerator) === get_called_class()
154	2		&& $enumerator->value === $this->value
155			);
156			}
157
158			/**
159			* Get an enumerator instance of the given value or instance
160			*
161			* @param static\|null\|bool\|int\|float\|string $value
162			* @return static
163			* @throws InvalidArgumentException On an unknwon or invalid value
164			* @throws LogicException On ambiguous constant values
165			*/
166	67		final public static function get($value)
167			{
168	67		if ($value instanceof static && get_class($value) === get_called_class()) {
169	26		return $value;
170			}
171
172	48		return static::byValue($value);
173			}
174
175			/**
176			* Get an enumerator instance by the given value
177			*
178			* @param mixed $value
179			* @return static
180			* @throws InvalidArgumentException On an unknwon or invalid value
181			* @throws LogicException On ambiguous constant values
182			*/
183	48		final public static function byValue($value)
184			{
185	48		$class = get_called_class();
186	48		$constants = self::detectConstants($class);
187	46		$name = array_search($value, $constants, true);
188	46	View Code Duplication	if ($name === false) {
189	7		$message = is_scalar($value)
190	3		? 'Unknown value ' . var_export($value, true)
191	7		: 'Invalid value of type ' . (is_object($value) ? get_class($value) : gettype($value));
192	7		throw new InvalidArgumentException($message);
193			}
194
195	40		if (!isset(self::$instances[$class][$name])) {
196	7		self::$instances[$class][$name] = new $class($constants[$name]);
197			}
198
199	40		return self::$instances[$class][$name];
200			}
201
202			/**
203			* Get an enumerator instance by the given name
204			*
205			* @param string $name The name of the enumerator
206			* @return static
207			* @throws InvalidArgumentException On an invalid or unknown name
208			* @throws LogicException On ambiguous values
209			*/
210	37		final public static function byName($name)
211			{
212	37		$name = (string) $name;
213	37		$class = get_called_class();
214	37		if (isset(self::$instances[$class][$name])) {
215	31		return self::$instances[$class][$name];
216			}
217
218	8		$const = $class . '::' . $name;
219	8		if (!defined($const)) {
220	1		throw new InvalidArgumentException($const . ' not defined');
221			}
222
223	7		return self::$instances[$class][$name] = new $class(constant($const));
224			}
225
226			/**
227			* Get an enumeration instance by the given ordinal number
228			*
229			* @param int $ordinal The ordinal number or the enumerator
230			* @return static
231			* @throws InvalidArgumentException On an invalid ordinal number
232			* @throws LogicException On ambiguous values
233			*/
234	19		final public static function byOrdinal($ordinal)
235			{
236	19		$ordinal = (int) $ordinal;
237	19		$class = get_called_class();
238	19		$constants = self::detectConstants($class);
239	19		$item = array_slice($constants, $ordinal, 1, true);
240	19		if (empty($item)) {
241	1		throw new InvalidArgumentException(sprintf(
242	1		'Invalid ordinal number, must between 0 and %s',
243	1		count($constants) - 1
244			));
245			}
246
247	18		$name = key($item);
248	18		if (isset(self::$instances[$class][$name])) {
249	17		return self::$instances[$class][$name];
250			}
251
252	2		return self::$instances[$class][$name] = new $class(current($item), $ordinal);
253			}
254
255			/**
256			* Get an enumerator instance by the given name
257			*
258			* @param string $name The name of the enumerator
259			* @return static
260			* @throws InvalidArgumentException On an invalid or unknown name
261			* @throws LogicException On ambiguous values
262			* @deprecated
263			*/
264			final public static function getByName($name)
265			{
266			return static::byName($name);
267			}
268
269			/**
270			* Get an enumeration instance by the given ordinal number
271			*
272			* @param int $ordinal The ordinal number or the enumerator
273			* @return static
274			* @throws InvalidArgumentException On an invalid ordinal number
275			* @throws LogicException On ambiguous values
276			* @deprecated
277			*/
278			final public static function getByOrdinal($ordinal)
279			{
280			return static::byOrdinal($ordinal);
281			}
282
283			/**
284			* Clear all instantiated enumerators of the called class
285			*
286			* NOTE: This can break singleton behavior ... use it with caution!
287			*
288			* @return void
289			* @deprecated
290			*/
291			final public static function clear()
292			{
293			$class = get_called_class();
294			unset(self::$instances[$class], self::$constants[$class]);
295			}
296
297			/**
298			* Get a list of enumerator instances ordered by ordinal number
299			*
300			* @return static[]
301			*/
302	13		final public static function getEnumerators()
303			{
304	13		return array_map('self::byName', array_keys(self::detectConstants(get_called_class())));
305			}
306
307			/**
308			* Get a list of enumerator values ordered by ordinal number
309			*
310			* @return mixed[]
311			*/
312	1		final public static function getValues()
313			{
314	1		return array_values(self::detectConstants(get_called_class()));
315			}
316
317			/**
318			* Get a list of enumerator names ordered by ordinal number
319			*
320			* @return string[]
321			*/
322	1		final public static function getNames()
323			{
324	1		return array_keys(self::detectConstants(get_called_class()));
325			}
326			/*
327			* Get a list of enumerator ordinal numbers
328			*
329			* @return int[]
330			*/
331	1		final public static function getOrdinals()
332			{
333	1		$count = count(self::detectConstants(get_called_class()));
334	1		return $count === 0 ? array() : range(0, $count - 1);
335			}
336
337			/**
338			* Get all available constants of the called class
339			*
340			* @return array
341			* @throws LogicException On ambiguous constant values
342			*/
343	64		final public static function getConstants()
344			{
345	64		return self::detectConstants(get_called_class());
346			}
347
348			/**
349			* Is the given enumerator part of this enumeration
350			*
351			* @param static\|null\|bool\|int\|float\|string $value
352			* @return bool
353			*/
354	1		final public static function has($value)
355			{
356	1		if ($value instanceof static && get_class($value) === get_called_class()) {
357	1		return true;
358			}
359
360	1		$class = get_called_class();
361	1		$constants = self::detectConstants($class);
362
363	1		return in_array($value, $constants, true);
364			}
365
366			/**
367			* Detect all available constants by the given class
368			*
369			* @param string $class
370			* @return array
371			* @throws LogicException On ambiguous constant values
372			*/
373	84		private static function detectConstants($class)
374			{
375	84		if (!isset(self::$constants[$class])) {
376	15		$reflection = new ReflectionClass($class);
377	15		$constants = array();
378
379			do {
380	15		$scopeConstants = array();
381	15		if (PHP_VERSION_ID >= 70100) {
382			// Since PHP-7.1 visibility modifiers are allowed for class constants
383			// for enumerations we are only interested in public once.
384	15		foreach ($reflection->getReflectionConstants() as $reflConstant) {
385	14		if ($reflConstant->isPublic()) {
386	15		$scopeConstants[ $reflConstant->getName() ] = $reflConstant->getValue();
387			}
388			}
389			} else {
390			// In PHP < 7.1 all class constants were public by definition
391			$scopeConstants = $reflection->getConstants();
392			}
393
394	15		$constants = $scopeConstants + $constants;
395	15		} while (($reflection = $reflection->getParentClass()) && $reflection->name !== __CLASS__);
396
397			// Detect ambiguous values and report names
398	15		$ambiguous = array();
399	15		foreach ($constants as $value) {
400	14		$names = array_keys($constants, $value, true);
401	14		if (count($names) > 1) {
402	2		$ambiguous[var_export($value, true)] = $names;
403			}
404			}
405	15		if (!empty($ambiguous)) {
406	2		throw new LogicException(
407			'All possible values needs to be unique. The following are ambiguous: '
408	2		. implode(', ', array_map(function ($names) use ($constants) {
409	2		return implode('/', $names) . '=' . var_export($constants[$names[0]], true);
410	2		}, $ambiguous))
411			);
412			}
413
414	13		self::$constants[$class] = $constants;
415			}
416
417	82		return self::$constants[$class];
418			}
419
420			/**
421			* Get an enumerator instance by the given name.
422			*
423			* This will be called automatically on calling a method
424			* with the same name of a defined enumerator.
425			*
426			* @param string $method The name of the enumeraotr (called as method)
427			* @param array $args There should be no arguments
428			* @return static
429			* @throws InvalidArgumentException On an invalid or unknown name
430			* @throws LogicException On ambiguous constant values
431			*/
432	22		final public static function __callStatic($method, array $args)
433			{
434	22		return self::byName($method);
435			}
436			}
437

marc-mabe / php-enum

Push — 2.x ( e67bba...dc329d )

Enum::detectConstants() D

Complexity

Size

Duplication

Code Coverage

Importance

How to fix Complexity

Long Method

Duplication Side-by-Side

Filter issues like