BuildR\Utils\Enumeration\EnumerationBase

Complexity

Total Complexity

14

Size/Duplication

Total Lines	90
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	1

Importance

Changes	1
Bugs	0	Features	1

10 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	7	2
A	isValid()	0	3	1
A	getValue()	0	3	1
A	toArray()	0	10	2
A	getKeys()	0	3	1
A	isValidKey()	0	7	2
A	__callStatic()	0	14	2
A	__toString()	0	3	1
A	toString()	0	3	1
A	count()	0	3	1

<?php namespace BuildR\Utils\Enumeration;

use \ReflectionClass;
use \Countable;
use BuildR\Foundation\Object\StringConvertibleInterface;
use BuildR\Utils\Enumeration\Exception\EnumerationException;

class EnumerationBase implements StringConvertibleInterface, Countable {

    public $value;

    private static $cache = [];

    public function __construct($value) {
        if(!$this->isValid($value)) {
            throw EnumerationException::invalidValue($value);
        }

        $this->value = $value;
    }

    public function isValid($value) {
        return (bool) in_array($value, self::toArray());
    }

    public function getValue() {
        return $this->value;
    }

    public static function toArray() {
        $enumClass = get_called_class();

        if(!array_key_exists($enumClass, self::$cache)) {
            $reflector = new ReflectionClass($enumClass);
            self::$cache[$enumClass] = $reflector->getConstants();
        }

        return self::$cache[$enumClass];
    }

    public static function getKeys() {
        return array_keys(self::toArray());
    }

    public static function isValidKey($key) {
        if(!is_string($key)) {
            throw EnumerationException::invalidKeyType(gettype($key));
        }

        return array_key_exists($key, self::toArray());
    }

    public static function __callStatic($name, $arguments) {

The parameter $arguments is not used and could be removed.

        $calledClass = get_called_class();
        $args[] = $name;

$args was never initialized. Although not strictly required by PHP, it is generally a good practice to add $args = array(); before regardless.

        if(array_key_exists(EnumerationFieldDefinitionInterface::class, class_implements($calledClass))) {
            $fields = static::defineFields()[$name];
            array_unshift($fields, $args[0]);

            $args = $fields;
        }

        $reflector = new ReflectionClass($calledClass);
        return $reflector->newInstanceArgs($args);
    }

    // ==========================================
    // StringConvertibleInterface implementation
    // ==========================================

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

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

    // ===================================
    // Countable interface implementation
    // ===================================

    /**
     * {@inheritdoc}
     */
    public function count() {
        return count(self::toArray());
    }

}