Gacela\Framework\DocBlockResolver\DocBlockResolvable

Complexity

Total Complexity

19

Size/Duplication

Total Lines	120
Duplicated Lines	0 %

Test Coverage

Coverage

92.16%

Importance

Changes	1
Bugs	0	Features	0

11 Methods

Rating	Name	Duplication	Size	Complexity
A	getClassName()	0	12	2
A	getClassFromDoc()	0	12	3
A	searchClassOverDocBlock()	0	5	1
A	normalizeResolvableType()	0	9	2
A	createCustomServicesCache()	0	8	2
A	generateCacheKey()	0	3	1
A	hasParentClass()	0	5	2
A	isProjectCacheEnabled()	0	4	1
A	fromCaller()	0	5	2
A	__construct()	0	4	1
A	searchClassOverUseStatements()	0	9	2

<?php

declare(strict_types=1);

namespace Gacela\Framework\DocBlockResolver;

use Gacela\Framework\ClassResolver\Cache\GacelaCache;
use Gacela\Framework\ClassResolver\ClassNameCacheInterface;
use Gacela\Framework\ClassResolver\DocBlockService\CustomServicesCache;
use Gacela\Framework\ClassResolver\DocBlockService\DocBlockParser;
use Gacela\Framework\ClassResolver\DocBlockService\MissingClassDefinitionException;
use Gacela\Framework\ClassResolver\DocBlockService\UseBlockParser;
use Gacela\Framework\ClassResolver\InMemoryCache;
use Gacela\Framework\Config\Config;
use ReflectionClass;

use function get_class;
use function is_string;

final class DocBlockResolvable
{
    /** @var array<string,string> [fileName => fileContent] cached */
    private static array $fileContentCache = [];

    /** @var 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 string $callerClass;

    /** @var class-string|string */

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

    private string $callerParentClass;

    /**
     * @param class-string $callerClass

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

     * @param class-string|string $callerParentClass
     */
    private function __construct(string $callerClass, string $callerParentClass)
    {
        $this->callerClass = $callerClass;
        $this->callerParentClass = $callerParentClass;
    }

    public static function fromCaller(object $caller): self
    {
        return new self(
            get_class($caller),
            get_parent_class($caller) ?: ''
        );
    }

    public function getClassName(string $method): string
    {
        $cacheKey = $this->generateCacheKey($method);
        $cache = $this->createCustomServicesCache();

        if (!$cache->has($cacheKey)) {
            $className = $this->getClassFromDoc($method);
            $cache->put($cacheKey, $className);
        }

        /** @psalm-suppress ArgumentTypeCoercion */
        return $cache->get($cacheKey);
    }


    public function hasParentClass(): bool
    {
        /** @psalm-suppress ArgumentTypeCoercion */
        return $this->callerParentClass !== ''
            && method_exists($this->callerParentClass, '__call');
    }

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

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

    public function createCustomServicesCache(): ClassNameCacheInterface
    {
        if (!$this->isProjectCacheEnabled()) {
            return new InMemoryCache(CustomServicesCache::class);
        }

        return new CustomServicesCache(
            Config::getInstance()->getCacheDir()
        );
    }

    /**
     * @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($this->callerClass);
        $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($this->callerClass, $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 = (string)$reflectionClass->getFileName();
        if (!isset(self::$fileContentCache[$fileName])) {
            self::$fileContentCache[$fileName] = (string)file_get_contents($fileName);
        }
        $phpFile = self::$fileContentCache[$fileName];

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

    private function generateCacheKey(string $method): string
    {
        return $this->callerClass . '::' . $method;
    }

    private function isProjectCacheEnabled(): bool
    {
        return (new GacelaCache(Config::getInstance()))
            ->isProjectCacheEnabled();
    }
}