Gacela\Container\DependencyCacheManager

Complexity

Total Complexity

22

Size/Duplication

Total Lines	178
Duplicated Lines	0 %

Test Coverage

Coverage

85%

Importance

Changes	1
Bugs	0	Features	0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	createInstance()	0	10	2
A	resolveDependencies()	0	9	2
A	getCachedClasses()	0	3	1
A	getDependencyResolver()	0	10	2
A	instantiate()	0	30	5
A	warmUp()	0	12	4
A	resolveCallableDependencies()	0	9	2
A	getCacheSize()	0	3	1
A	__construct()	0	4	1
A	hasAttribute()	0	10	2

<?php

declare(strict_types=1);

namespace Gacela\Container;

use Closure;
use Gacela\Container\Attribute\Factory;
use Gacela\Container\Attribute\Singleton;
use ReflectionClass;

use function class_exists;
use function count;

/**
 * Manages dependency resolution caching for performance optimization.
 */
final class DependencyCacheManager
{
    /** @var array<class-string|string, list<mixed>> */
    private array $cachedDependencies = [];

    /** @var array<class-string, object> */

The doc comment array<class-string, object> at position 2 could not be parsed: Unknown type name 'class-string' at position 2 in array<class-string, object>.

    private array $singletonInstances = [];

    /** @var array<string, bool> Cache for attribute existence checks */
    private array $attributeCache = [];

    private ?DependencyResolver $dependencyResolver = null;

    /**
     * @param array<class-string, class-string|callable|object> $bindings
     * @param array<string, array<class-string, class-string|callable|object>> $contextualBindings
     */
    public function __construct(
        private array $bindings = [],
        private array &$contextualBindings = [],
    ) {
    }

    /**
     * Resolve dependencies for a class, using cache if available.
     *
     * @param class-string $className
     *
     * @return list<mixed>
     */
    public function resolveDependencies(string $className): array
    {
        if (!isset($this->cachedDependencies[$className])) {
            $this->cachedDependencies[$className] = $this
                ->getDependencyResolver()
                ->resolveDependencies($className);
        }

        return $this->cachedDependencies[$className];
    }

    /**
     * Resolve dependencies for a callable with a specific cache key.
     *
     * @return list<mixed>
     */
    public function resolveCallableDependencies(string $callableKey, Closure $callable): array
    {
        if (!isset($this->cachedDependencies[$callableKey])) {
            $this->cachedDependencies[$callableKey] = $this
                ->getDependencyResolver()
                ->resolveDependencies($callable);
        }

        return $this->cachedDependencies[$callableKey];
    }

    /**
     * Pre-warm the dependency cache for multiple classes.
     *
     * @param list<class-string> $classNames
     */
    public function warmUp(array $classNames): void
    {
        foreach ($classNames as $className) {
            if (!class_exists($className)) {
                continue;
            }

            // Pre-resolve dependencies to populate cache
            if (!isset($this->cachedDependencies[$className])) {
                $this->cachedDependencies[$className] = $this
                    ->getDependencyResolver()
                    ->resolveDependencies($className);
            }
        }
    }

    /**
     * Instantiate a class using cached dependencies.
     *
     * @param class-string $class
     */
    public function instantiate(string $class): ?object
    {
        if (!class_exists($class)) {
            return null;
        }

        // Check for #[Singleton] attribute (cached)
        if ($this->hasAttribute($class, Singleton::class)) {
            if (isset($this->singletonInstances[$class])) {
                return $this->singletonInstances[$class];
            }

            $instance = $this->createInstance($class);
            $this->singletonInstances[$class] = $instance;
            return $instance;
        }

        // Check for #[Factory] attribute (cached) - always create new instance
        if ($this->hasAttribute($class, Factory::class)) {
            // Don't cache dependencies for factory classes to ensure fresh instances
            $dependencies = $this
                ->getDependencyResolver()
                ->resolveDependencies($class);

            /** @psalm-suppress MixedMethodCall */
            return new $class(...$dependencies);
        }

        // Default behavior - create new instance
        return $this->createInstance($class);
    }

    /**
     * Get the number of cached dependency resolutions.
     */
    public function getCacheSize(): int
    {
        return count($this->cachedDependencies);
    }

    /**
     * Get all cached class names.
     *
     * @return list<string>
     */
    public function getCachedClasses(): array
    {
        return array_keys($this->cachedDependencies);
    }

    /**
     * Create a new instance of a class using cached dependencies.
     *
     * @param class-string $class
     */
    private function createInstance(string $class): object
    {
        if (!isset($this->cachedDependencies[$class])) {
            $this->cachedDependencies[$class] = $this
                ->getDependencyResolver()
                ->resolveDependencies($class);
        }

        /** @psalm-suppress MixedMethodCall */
        return new $class(...$this->cachedDependencies[$class]);
    }

    private function getDependencyResolver(): DependencyResolver
    {
        if ($this->dependencyResolver === null) {
            $this->dependencyResolver = new DependencyResolver(
                $this->bindings,
                $this->contextualBindings,
            );
        }

        return $this->dependencyResolver;
    }

    /**
     * Check if a class has a specific attribute, with caching.
     *
     * @param class-string $class
     * @param class-string $attributeClass
     */
    private function hasAttribute(string $class, string $attributeClass): bool
    {
        $cacheKey = $class . '::' . $attributeClass;

        if (!isset($this->attributeCache[$cacheKey])) {
            $reflection = new ReflectionClass($class);
            $this->attributeCache[$cacheKey] = count($reflection->getAttributes($attributeClass)) > 0;
        }

        return $this->attributeCache[$cacheKey];
    }
}