JefersonC\Enum\PrettyEnum

Complexity

Total Complexity

14

Size/Duplication

Total Lines	76
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	2

Test Coverage

Coverage

97.22%

Importance

Changes

0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	childInstance()	0	9	2
A	constants()	0	4	1
A	get()	0	5	1
A	pretty()	0	5	1
A	all()	0	11	2
A	getItem()	0	9	2
A	item()	0	3	1
A	mountItem()	0	9	2
A	__callStatic()	0	8	2

<?php

namespace JefersonC\Enum;

abstract class PrettyEnum
{
    protected static $instances = [];

    protected static function childInstance() {
        $class = get_called_class();

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

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

    protected static function constants() {
        $class = static::childInstance();
        return $class->register();
    }

    public static function get($index) {
      $item = static::getItem($index);

      return $item['value'];
    }

    public static function pretty($index) {
        $item = static::getItem($index);

        return $item['name'];
    }

    public static function all() {
        $constants = static::constants();

        $out = [];

        foreach($constants as $index => $const) {
            $out[] = static::mountItem($const);
        }

        return $out;
    }

    protected static function getItem($key) {
        $constants = static::constants();

        if (!isset($constants[$key])) {
            throw new InvalidEnumKeyException(sprintf('Key %s does not exists on %s', $key, get_class(static::childInstance())));
        }

        return $constants[$key];
    }

    public static function item($key) {
        return static::mountItem(static::getItem($key));
    }

    protected static function mountItem($item) {
        $obj = new \stdClass();

        foreach($item as $key => $value) {
            $obj->{$key} = $value;
        }

        return $obj;
    }

    public static function __callStatic($name, $arguments)
    {
        if(!method_exists(__CLASS__, $name)) {
            throw new InvalidEnumMethodException(sprintf('Method %s does not exists', $name));
        }

        return static::{$name}($arguments);
    }
}