EnumTrait::jsonSerialize() - Code Metrics - Inspection of "WIP Psalm templates" - thunderer/Platenum - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Pull Request — master (#24)

by Tomasz
created 2020-11-07 01:57 UTC
EnumTrait::jsonSerialize() A

↳ Parent: EnumTrait
Complexity

Conditions	1
Paths	1
Size

Total Lines	3
Code Lines	1
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	2
CRAP Score	1
Importance

Changes	1
Bugs	0	Features	0
Metric	Value
cc	1
eloc	1
c	1
b	0
f	0
nc	1
nop	0
dl	0
loc	3
ccs	2
cts	2
cp	1
crap	1
rs	10
<?php
declare(strict_types=1);
namespace Thunder\Platenum\Enum;

use Thunder\Platenum\Exception\PlatenumException;

/**
 * @author Tomasz Kowalczyk <[email protected]>
 * @psalm-template T
 * @psalm-immutable
 */
trait EnumTrait
{
    /** @var string */
    private $member;
    /** @psalm-var T */
    private $value;

    /** @psalm-var non-empty-array<string,non-empty-array<string,int|string>> */
    protected static $members = [];
    /** @var array<string,array<string,static>> */
    protected static $instances = [];

    /** @psalm-param T $value */
    final private function __construct(string $member, $value)
    {
        $this->member = $member;
        $this->value = $value;
    }

    /* --- CREATE --- */

    final public static function __callStatic(string $member, array $arguments)
    {
        $class = static::class;
        if($arguments) {

            throw PlatenumException::fromConstantArguments($class);
        }

        return static::fromMember($member);
    }

    final public static function fromMember(string $member): self
    {
        $class = static::class;
        if(isset(static::$instances[$class][$member])) {
            return static::$instances[$class][$member];
        }

        static::resolveMembers();
        if(false === array_key_exists($member, static::$members[$class])) {
            static::throwInvalidMemberException($member);
            static::throwDefaultInvalidMemberException($member);
        }

        return static::$instances[$class][$member] = static::fromMemberAndValue($member, static::$members[$class][$member]);
    }

    /**
     * @psalm-param int|string $value
     * @psalm-return static
     */
    final private static function fromMemberAndValue(string $member, $value): self
    {
        /** @psalm-suppress UnsafeInstantiation */
        return new static($member, $value);
    }

    /**
     * @param mixed $value
     * @return static
     */
    final public static function fromValue($value): self
    {
        $class = static::class;
        if(false === is_scalar($value)) {
            throw PlatenumException::fromIllegalValue($class, $value);
        }

        static::resolveMembers();
        $member = array_search($value, static::$members[$class], true);
        if(false === $member) {
            static::throwInvalidValueException($value);
            static::throwDefaultInvalidValueException($value);
        }

        /** @var string $member */
        return static::fromMember($member);
    }

    /**
     * @param static $enum
     * @return static
     */
    final public static function fromEnum($enum): self
    {
        if(false === $enum instanceof static) {
            throw PlatenumException::fromMismatchedClass(static::class, \get_class($enum));
        }

        return static::fromValue($enum->value);
    }

    /**
     * @param static &$enum
     * @param-out static $enum
     */
    final public function fromInstance(&$enum): void
    {
        $enum = static::fromEnum($enum);
    }

    /* --- EXCEPTIONS --- */

    private static function throwInvalidMemberException(string $member): void
    private static function throwInvalidMemberException(/** @scrutinizer ignore-unused */ string $member): void
    {
    }

    private static function throwDefaultInvalidMemberException(string $member): void
    {
        throw PlatenumException::fromInvalidMember(static::class, $member, static::$members[static::class]);
    }

    /** @param mixed $value */
    private static function throwInvalidValueException($value): void
    private static function throwInvalidValueException(/** @scrutinizer ignore-unused */ $value): void
    {
    }

    /** @param mixed $value */
    private static function throwDefaultInvalidValueException($value): void
    {
        throw PlatenumException::fromInvalidValue(static::class, $value);
    }

    /* --- COMPARE --- */

    /** @param static $other */
    final public function equals($other): bool
    {
        return $other instanceof $this && $this->value === $other->value;
    }

    /* --- TRANSFORM --- */

    final public function getMember(): string
    {
        return $this->member;
    }

    /** @psalm-return T */
    final public function getValue()
    {
        return $this->value;
    }

    /** @psalm-return T */
    final public function jsonSerialize()
    {
        return $this->getValue();
    }

    final public function __toString(): string
    {
        return (string)$this->getValue();
    }

    /* --- CHECK --- */

    final public static function memberExists(string $member): bool
    {
        static::resolveMembers();

        return array_key_exists($member, static::$members[static::class]);
    }

    /** @param int|string $value */
    final public static function valueExists($value): bool
    {
        static::resolveMembers();

        return \in_array($value, static::$members[static::class], true);
    }

    final public function hasMember(string $members): bool
    {
        return $members === $this->member;
    }

    /** @psalm-param T $value */
    final public function hasValue($value): bool
    {
        return $value === $this->value;
    }

    /* --- INFO --- */

    /** @return int|string */
    final public static function memberToValue(string $member)
    {
        if(false === static::memberExists($member)) {
            static::throwInvalidMemberException($member);
            static::throwDefaultInvalidMemberException($member);
        }

        return static::$members[static::class][$member];
    }

    /** @param int|string $value */
    final public static function valueToMember($value): string
    {
        if(false === static::valueExists($value)) {
            static::throwInvalidValueException($value);
            static::throwDefaultInvalidValueException($value);
        }

        return (string)array_search($value, static::$members[static::class], true);
    }

    final public static function getMembers(): array
    {
        static::resolveMembers();

        return array_keys(static::$members[static::class]);
    }

    final public static function getValues(): array
    {
        static::resolveMembers();

        return array_values(static::$members[static::class]);
    }

    final public static function getMembersAndValues(): array
    {
        static::resolveMembers();

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

    /* --- SOURCE --- */

    final private static function resolveMembers(): void
    {
        $class = static::class;
        if(isset(static::$members[$class])) {
            return;
        }

        $throwMissingResolve = function(string $class): void {
            throw PlatenumException::fromMissingResolve($class);
        };
        // reflection instead of method_exists because of PHP 7.4 bug #78632
        // @see https://bugs.php.net/bug.php?id=78632
        $hasResolve = (new \ReflectionClass($class))->hasMethod('resolve');
        /** @psalm-var array<string,T> $members */
        $members = $hasResolve ? static::resolve() : $throwMissingResolve($class);
        $members = $hasResolve ? static::/** @scrutinizer ignore-call */ resolve() : $throwMissingResolve($class);
        if(empty($members)) {
            throw PlatenumException::fromEmptyMembers($class);
        }
        if(\count($members) !== \count(\array_unique($members))) {
        if(\count(/** @scrutinizer ignore-type */ $members) !== \count(\array_unique($members))) {
            throw PlatenumException::fromNonUniqueMembers($class);
        }
        /** @psalm-suppress RedundantCondition */
        if(['string'] !== \array_unique(\array_map('gettype', array_keys($members)))) {
        if(['string'] !== \array_unique(\array_map('gettype', array_keys(/** @scrutinizer ignore-type */ $members)))) {
            throw PlatenumException::fromNonStringMembers($class);
        }
        if(1 !== \count(\array_unique(\array_map('gettype', $members)))) {
        if(1 !== \count(\array_unique(\array_map('gettype', /** @scrutinizer ignore-type */ $members)))) {
            throw PlatenumException::fromNonUniformMemberValues($class, $members);
            throw PlatenumException::fromNonUniformMemberValues($class, /** @scrutinizer ignore-type */ $members);
        }

        static::$members[$class] = $members;
    }

    /* --- MAGIC --- */

    final public function __clone()
    {
        throw PlatenumException::fromMagicMethod(static::class, __FUNCTION__);
    }

    final public function __call(string $name, array $arguments)
    {
        throw PlatenumException::fromMagicMethod(static::class, __FUNCTION__);
    }

    final public function __invoke()
    {
        throw PlatenumException::fromMagicMethod(static::class, __FUNCTION__);
    }

    /** @param mixed $name */
    final public function __isset($name)
    {
        throw PlatenumException::fromMagicMethod(static::class, __FUNCTION__);
    }

    /** @param mixed $name */
    final public function __unset($name)
    {
        throw PlatenumException::fromMagicMethod(static::class, __FUNCTION__);
    }

    /** @param mixed $value */
    final public function __set(string $name, $value)
    {
        throw PlatenumException::fromMagicMethod(static::class, __FUNCTION__);
    }

    final public function __get(string $name)
    {
        throw PlatenumException::fromMagicMethod(static::class, __FUNCTION__);
    }
}

thunderer / Platenum

GitHub Access Token became invalid

Pull Request — master (#24)

EnumTrait::jsonSerialize() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like
