Gacela\Framework\ClassResolver\GlobalInstance\AnonymousGlobal

Complexity

Total Complexity

15

Size/Duplication

Total Lines	114
Duplicated Lines	0 %

Importance

Changes

0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	resetCache()	0	3	1
A	addGlobal()	0	11	2
A	createCacheKey()	0	3	1
A	addCachedGlobalInstance()	0	3	1
A	validateTypeForAnonymousGlobalRegistration()	0	7	2
A	extractContextNameFromContext()	0	13	3
A	getByClassName()	0	8	1
A	getGlobalKeyFromClassName()	0	3	1
A	getByKey()	0	9	2
A	overrideExistingResolvedClass()	0	5	1

<?php

declare(strict_types=1);

namespace Gacela\Framework\ClassResolver\GlobalInstance;

use Gacela\Framework\ClassResolver\ClassInfo;
use Gacela\Framework\ClassResolver\GlobalKey;
use Gacela\Framework\ClassResolver\ResolvableType;
use RuntimeException;

use function in_array;
use function is_string;
use function sprintf;

/**
 * @internal
 */
final class AnonymousGlobal
{
    private const ALLOWED_TYPES_FOR_ANONYMOUS_GLOBAL = [
        'Config',
        'Factory',
        'Provider',
    ];

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

    /**
     * @internal
     */
    public static function resetCache(): void
    {
        self::$cachedGlobalInstances = [];
    }

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

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 ?T
     *
     * @internal so the Locator can access to the global instances before creating a new instance
     */
    public static function getByClassName(string $className)
    {
        $key = self::getGlobalKeyFromClassName($className);

        /** @var ?T $instance */
        $instance = self::getByKey($key); // @phpstan-ignore-line

        return $instance;
    }

    public static function getByKey(string $key): ?object
    {
        if (isset(self::$cachedGlobalInstances[$key])) {
            return self::$cachedGlobalInstances[$key];
        }

        $normalizedKey = '\\' . ltrim($key, '\\');

        return self::$cachedGlobalInstances[$normalizedKey] ?? null;
    }

    /**
     * Add an anonymous class as 'Config', 'Factory' or 'Provider' as a global resource
     * bound to the context that it's pass as first argument. It can be the string-key
     * (from a non-class/file context) or the class/object itself.
     */
    public static function addGlobal(object|string $context, object $resolvedClass): void
    {
        $contextName = self::extractContextNameFromContext($context);
        $parentClass = get_parent_class($resolvedClass);
        $type = is_string($parentClass)

The condition is_string($parentClass) is always true.

            ? ResolvableType::fromClassName($parentClass)->resolvableType()
            : $contextName;

        self::validateTypeForAnonymousGlobalRegistration($type);
        $key = self::createCacheKey($contextName, $type);
        self::addCachedGlobalInstance($key, $resolvedClass);
    }

    public static function createCacheKey(string $contextName, string $type): string
    {
        return sprintf('\%s\%s\%s', ClassInfo::MODULE_NAME_ANONYMOUS, $contextName, $type);
    }

    public static function overrideExistingResolvedClass(string $className, object $resolvedClass): void
    {
        $key = self::getGlobalKeyFromClassName($className);

        self::addCachedGlobalInstance($key, $resolvedClass);
    }

    private static function extractContextNameFromContext(object|string $context): string
    {
        if (is_string($context)) {
            return $context;
        }

        $callerClass = $context::class;
        /** @var list<string> $callerClassParts */
        $callerClassParts = explode('\\', ltrim($callerClass, '\\'));

        $lastCallerClassParts = end($callerClassParts);

        return is_string($lastCallerClassParts) ? $lastCallerClassParts : '';
    }

    private static function validateTypeForAnonymousGlobalRegistration(string $type): void
    {
        if (!in_array($type, self::ALLOWED_TYPES_FOR_ANONYMOUS_GLOBAL, true)) {
            throw new RuntimeException(
                sprintf("Type '%s' not allowed. Valid types: ", $type) . implode(
                    ', ',
                    self::ALLOWED_TYPES_FOR_ANONYMOUS_GLOBAL,
                ),
            );
        }
    }

    private static function addCachedGlobalInstance(string $key, object $resolvedClass): void
    {
        self::$cachedGlobalInstances[$key] = $resolvedClass;
    }

    private static function getGlobalKeyFromClassName(string $className): string
    {
        return GlobalKey::fromClassName($className);
    }
}