MadWeb\Enum\Enum

Complexity

Total Complexity

20

Size/Duplication

Total Lines	120
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	2

Test Coverage

Coverage

100%

Importance

Changes

0

12 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	8	2
A	randomKey()	0	6	1
A	randomValue()	0	6	1
A	label()	0	4	1
A	labels()	0	10	2
A	getLabel()	0	11	2
A	is()	0	8	3
A	isAny()	0	10	3
A	toArray()	0	10	2
A	getConstList()	0	4	1
A	rule()	0	4	1
A	ruleByKey()	0	4	1

<?php

namespace MadWeb\Enum;

use MadWeb\Enum\Rules\EnumRule;
use MyCLabs\Enum\Enum as MyCLabsEnum;

abstract class Enum extends MyCLabsEnum
{
    /**
     * Default enum value.
     */
    const __default = null;

    /**
     * {@inheritdoc}
     */
    public function __construct($value = null)
    {
        if (is_null($value)) {
            $value = static::__default;
        }

        parent::__construct($value);
    }

    public static function randomKey(): string
    {
        $keys = self::keys();

        return $keys[array_rand($keys)];
    }

    public static function randomValue(): string
    {
        $values = self::values();

        return $values[array_rand($values)];
    }

    public function label(): string
    {
        return self::getLabel($this->getValue());
    }

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

        foreach (static::toArray() as $value) {
            $result[$value] = static::getLabel($value);

Since getLabel() is declared private, calling it with static will lead to errors in possible sub-classes. You can either use self, or increase the visibility of getLabel() to at least protected.

        }

        return $result;
    }

    private static function getLabel(string $value): string
    {
        $lang_key = sprintf(
            '%s.%s.%s',
            config('enum.lang_file_path'),
            static::class,
            $value
        );

        return trans()->has($lang_key) ? __($lang_key) : $value;
    }

    public function is($value)
    {
        if (is_iterable($value)) {
            return $this->isAny($value);
        }

        return $this->getValue() === ($value instanceof self ? $value->getValue() : $value);
    }

    public function isAny(iterable $values)
    {
        foreach ($values as $value) {
            if ($this->is($value)) {
                return true;
            }
        }

        return false;
    }

    public static function toArray(bool $include_default = false): array
    {
        $result = parent::toArray();

        if (! $include_default) {
            unset($result['__default']);
        }

        return $result;
    }

    /**
     * Returns all consts (possible values) as an array according to `SplEnum` class.
     */
    public function getConstList(bool $include_default = false): array
    {
        return static::toArray($include_default);
    }

    /**
     * Returns the validation rule (to validate by value).
     *
     * @return EnumRule
     */
    public static function rule(): EnumRule
    {
        return new EnumRule(static::class, false);
    }

    /**
     * Returns the validation rule (to validate by key).
     *
     * @return EnumRule
     */
    public static function ruleByKey(): EnumRule
    {
        return new EnumRule(static::class, true);
    }
}