BrenoRoosevelt\PhpAttributes\Specification\Reflector

Complexity

Total Complexity

18

Size/Duplication

Total Lines	61
Duplicated Lines	0 %

Importance

Changes	3
Bugs	0	Features	1

2 Methods

Rating	Name	Duplication	Size	Complexity
C	getTypeHint()	0	43	14
A	matchType()	0	14	4

<?php
declare(strict_types=1);

namespace BrenoRoosevelt\PhpAttributes\Specification;

use ReflectionClass;
use ReflectionClassConstant;
use ReflectionFunctionAbstract;
use ReflectionMethod;
use ReflectionNamedType;
use ReflectionParameter;
use ReflectionProperty;
use ReflectionType;
use ReflectionUnionType;

class Reflector
{
    public static function getTypeHint(\Reflector $subject): array
    {
        if ($subject instanceof ReflectionFunctionAbstract) {
            $type = $subject->getReturnType();
        } elseif ($subject instanceof ReflectionParameter) {
            $type = $subject->getType();
        } elseif ($subject instanceof ReflectionProperty) {
            $type = $subject->getType();
        } elseif ($subject instanceof ReflectionClassConstant) {
            return [gettype($subject->getValue())];
        } elseif ($subject instanceof ReflectionClass) {
            return [$subject->getName()];
        } else {
            return [];
        }

        $types = [];
        $result = [];

        if ($type instanceof ReflectionNamedType) {
            $types[] = $type;
        } elseif ($type instanceof ReflectionUnionType) {
            $types = $type->getTypes();
        }

        foreach ($types as $type) {
            if ($type->allowsNull()) {
                $result[] = 'null';
            }

            $typeHint = ltrim($type->getName(), "?");
            if ($typeHint === 'self' &&
                ($subject instanceof ReflectionMethod ||
                $subject instanceof ReflectionProperty ||
                $subject instanceof ReflectionParameter)
            ) {
                $typeHint = $subject->getDeclaringClass()->getName();
            }

            $result[] = $typeHint;
        }

        return $result;
    }

    public static function matchType(\Reflector $subject, string $type): bool
    {
        $types = Reflector::getTypeHint($subject);
        if (in_array($type, $types, true)) {
            return true;
        }

        foreach ($types as $typeHint) {
            if (is_a($typeHint, $type, true)) {
                return true;
            }
        }

        return false;
    }
}