FRZB\Component\RequestMapper\Helper\ClassHelper

Complexity

Total Complexity

22

Size/Duplication

Total Lines	125
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes

0

12 Methods

Rating	Name	Duplication	Size	Complexity
A	getMethodParameters()	0	6	2
A	isEnum()	0	3	1
A	isNameContains()	0	5	1
A	getProperty()	0	5	1
A	getProperties()	0	6	2
A	getAttributes()	0	11	2
A	isNotBuiltinAndExists()	0	5	4
A	getAttribute()	0	5	1
A	isArrayHasAllPropertiesFromClass()	0	17	4
A	getShortName()	0	6	2
A	__construct()	0	2	1
A	getMethodParameter()	0	5	1

<?php

declare(strict_types=1);

namespace FRZB\Component\RequestMapper\Helper;

use Fp\Collections\ArrayList;
use FRZB\Component\RequestMapper\Exception\HelperException;
use JetBrains\PhpStorm\Immutable;

/** @internal */
#[Immutable]
final class ClassHelper
{
    private function __construct()
    {
    }

    public static function isNotBuiltinAndExists(string $className): bool
    {
        return (class_exists($className) || interface_exists($className))
            && !empty((new \ReflectionClass($className))->getNamespaceName())
            && !self::isEnum($className)
        ;
    }

    public static function isEnum(string $className): bool
    {
        return enum_exists($className);
    }

    public static function getShortName(string $className): string
    {
        try {
            return (new \ReflectionClass($className))->getShortName();
        } catch (\ReflectionException) {
            return $className;
        }
    }

    public static function isNameContains(string $className, string ...$haystack): bool
    {
        return ArrayList::collect($haystack)
            ->filter(static fn (string $value): bool => StringHelper::contains(self::getShortName($className), $value))
            ->isNonEmpty()
        ;
    }

    /** @return \ReflectionParameter[] */
    public static function getMethodParameters(string $className, string $classMethod): array
    {
        try {
            return (new \ReflectionMethod($className, $classMethod))->getParameters();
        } catch (\ReflectionException) {
            return [];
        }
    }

    public static function getMethodParameter(string $className, string $classMethod, string $parameterName): \ReflectionParameter
    {
        return ArrayList::collect(self::getMethodParameters($className, $classMethod))
            ->first(static fn (\ReflectionParameter $property) => $property->getName() === $parameterName)
            ->getOrThrow(HelperException::noMethodParameter($className, $classMethod, $parameterName))

It seems like FRZB\Component\RequestMapper\Exception\HelperException::noMethodParameter($className, $classMethod, $parameterName) can also be of type FRZB\Component\RequestMapper\Exception\HelperException; however, parameter $fallback of Fp\Functional\Option\Option::getOrThrow() does only seem to accept callable, maybe add an additional type check?

        ;
    }

    /** @return \ReflectionProperty[] */
    public static function getProperties(string $className): array
    {
        try {
            return (new \ReflectionClass($className))->getProperties();
        } catch (\ReflectionException) {
            return [];
        }
    }

    public static function getProperty(string $className, string $propertyName): \ReflectionProperty
    {
        return ArrayList::collect(self::getProperties($className))
            ->first(static fn (\ReflectionProperty $property) => $property->getName() === $propertyName)
            ->getOrThrow(HelperException::noClassProperty($className, $propertyName))

It seems like FRZB\Component\RequestMapper\Exception\HelperException::noClassProperty($className, $propertyName) can also be of type FRZB\Component\RequestMapper\Exception\HelperException; however, parameter $fallback of Fp\Functional\Option\Option::getOrThrow() does only seem to accept callable, maybe add an additional type check?

        ;
    }

    public static function isArrayHasAllPropertiesFromClass(array $array, string $class): bool
    {
        try {
            $rClass = new \ReflectionClass($class);
        } catch (\ReflectionException) {
            return false;
        }

        foreach ($rClass->getProperties() as $property) {
            $propertyValue = $array[$property->getName()] ?? $array[StringHelper::toSnakeCase($property->getName())] ?? null;

            if (!$propertyValue) {
                return false;
            }
        }

        return true;
    }

    /**
     * @template T
     *
     * @param class-string<T> $attributeClass

The doc comment class-string<T> at position 0 could not be parsed: Unknown type name 'class-string' at position 0 in class-string<T>.

     *
     * @return null|T
     */
    public static function getAttribute(string|object $target, string $attributeClass): ?object
    {
        return ArrayList::collect(self::getAttributes($target, $attributeClass))
            ->firstElement()
            ->get()
        ;
    }

    /**
     * @template T
     *
     * @param class-string<T> $attributeClass

The doc comment class-string<T> at position 0 could not be parsed: Unknown type name 'class-string' at position 0 in class-string<T>.

     *
     * @return array<T>
     */
    public static function getAttributes(string|object $target, string $attributeClass): array
    {
        try {
            $attributes = (new \ReflectionClass($target))->getAttributes($attributeClass);
        } catch (\ReflectionException) {
            $attributes = [];
        }

        return ArrayList::collect($attributes)
            ->map(static fn (\ReflectionAttribute $a) => $a->newInstance())
            ->toArray()
        ;
    }
}