Gacela\Framework\ClassResolver\AbstractClassResolver

Complexity

Total Complexity

12

Size/Duplication

Total Lines	91
Duplicated Lines	0 %

Test Coverage

Coverage

94.12%

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	doResolve()	0	18	3
A	getCacheKey()	0	3	1
A	createInstance()	0	8	2
A	getClassNameFinder()	0	8	2
A	findClassName()	0	5	1
A	resolveGlobal()	0	11	2
A	addGlobal()	0	3	1

<?php

declare(strict_types=1);

namespace Gacela\Framework\ClassResolver;

use Gacela\Framework\ClassResolver\ClassNameFinder\ClassNameFinderInterface;

abstract class AbstractClassResolver
{
    /** @var array<string,mixed|object> */
    protected static array $cachedInstances = [];
    protected static ?ClassNameFinderInterface $classNameFinder = null;

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

    abstract public function resolve(object $callerClass): ?object;

    public static function addGlobal(string $key, object $resolvedClass): void
    {
        self::$globalResolvedClasses[$key] = $resolvedClass;
    }

    /**
     * @return null|mixed
     */
    public function doResolve(object $callerClass)
    {
        $classInfo = new ClassInfo($callerClass);
        $cacheKey = $this->getCacheKey($classInfo);

        if (isset(self::$cachedInstances[$cacheKey])) {
            return self::$cachedInstances[$cacheKey];
        }

        $resolvedClassName = $this->findClassName($classInfo);

        if (null === $resolvedClassName) {
            return $this->resolveGlobal($cacheKey);
        }

        self::$cachedInstances[$cacheKey] = $this->createInstance($resolvedClassName);

        return self::$cachedInstances[$cacheKey];
    }

    abstract protected function getResolvableType(): string;

    /**
     * @return null|mixed
     */
    private function resolveGlobal(string $cacheKey)
    {
        $resolvedClass = self::$globalResolvedClasses[$cacheKey] ?? null;

        if (null === $resolvedClass) {
            return null;
        }

        self::$cachedInstances[$cacheKey] = $resolvedClass;

        return self::$cachedInstances[$cacheKey];
    }

    private function getCacheKey(ClassInfo $classInfo): string
    {
        return $classInfo->getCacheKey($this->getResolvableType());
    }

    private function findClassName(ClassInfo $classInfo): ?string
    {
        return $this->getClassNameFinder()->findClassName(
            $classInfo,
            $this->getResolvableType()
        );
    }

    private function getClassNameFinder(): ClassNameFinderInterface
    {
        if (null === self::$classNameFinder) {
            $classResolverFactory = new ClassResolverFactory();
            self::$classNameFinder = $classResolverFactory->createClassNameFinder();
        }

        return self::$classNameFinder;
    }

    /**
     * @return null|object
     */
    private function createInstance(string $resolvedClassName)
    {
        if (class_exists($resolvedClassName)) {
            /** @psalm-suppress MixedMethodCall */
            return new $resolvedClassName();
        }

        return null;
    }
}