Gacela\Framework\DocBlockResolverAwareTrait

Complexity

Total Complexity

12

Size/Duplication

Total Lines	84
Duplicated Lines	0 %

Test Coverage

Coverage

86.11%

Importance

Changes	1
Bugs	0	Features	0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	searchClassOverUseStatements()	0	9	2
A	__call()	0	21	4
A	getClassFromDoc()	0	12	3
A	searchClassOverDocBlock()	0	5	1
A	normalizeResolvableType()	0	9	2

<?php

declare(strict_types=1);

namespace Gacela\Framework;

use Gacela\Framework\ClassResolver\DocBlockService\DocBlockParser;
use Gacela\Framework\ClassResolver\DocBlockService\DocBlockServiceResolver;
use Gacela\Framework\ClassResolver\DocBlockService\MissingClassDefinitionException;
use Gacela\Framework\ClassResolver\DocBlockService\UseBlockParser;
use ReflectionClass;

use function is_string;

trait DocBlockResolverAwareTrait
{
    /** @var array<string,string> */
    protected static array $fileContentCache = [];

    /** @var array<string,?object> */
    private array $customServices = [];

    /**
     * @param string $method
     * @param array $parameters
     *
     * @return mixed
     */
    public function __call($method, $parameters = [])
    {
        if (!isset($this->customServices[$method])) {
            $className = $this->getClassFromDoc($method);
            $resolvableType = $this->normalizeResolvableType($className);

            $this->customServices[$method] = (new DocBlockServiceResolver($resolvableType))
                ->resolve($className);
        }

        $object = $this->customServices[$method];

        if (isset($object)) {
            return $object;
        }

        if (method_exists(parent::class, '__call')) {
            return parent::__call($method, $parameters);
        }

        return null;
    }

    /**
     * @return class-string

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

     */
    private function getClassFromDoc(string $method): string
    {
        $reflectionClass = new ReflectionClass(static::class);
        $className = $this->searchClassOverDocBlock($reflectionClass, $method);
        if (class_exists($className)) {
            return $className;
        }
        $className = $this->searchClassOverUseStatements($reflectionClass, $className);
        if (class_exists($className)) {
            return $className;
        }
        throw MissingClassDefinitionException::missingDefinition(static::class, $method, $className);
    }

    private function searchClassOverDocBlock(ReflectionClass $reflectionClass, string $method): string
    {
        $docBlock = (string)$reflectionClass->getDocComment();

        return (new DocBlockParser())->getClassFromMethod($docBlock, $method);
    }

    /**
     * Look the uses, to find the fully-qualified class name for the className.
     */
    private function searchClassOverUseStatements(ReflectionClass $reflectionClass, string $className): string
    {
        $fileName = $reflectionClass->getFileName();
        if (!isset(static::$fileContentCache[$fileName])) {
            static::$fileContentCache[$fileName] = file_get_contents($fileName);
        }
        $phpFile = static::$fileContentCache[$fileName];

        return (new UseBlockParser())->getUseStatement($className, $phpFile);
    }

    private function normalizeResolvableType(string $resolvableType): string
    {
        /** @var list<string> $resolvableTypeParts */
        $resolvableTypeParts = explode('\\', ltrim($resolvableType, '\\'));
        $normalizedResolvableType = end($resolvableTypeParts);

        return is_string($normalizedResolvableType)
            ? $normalizedResolvableType
            : $resolvableType;
    }
}