Gacela\Framework\AbstractFactory

Complexity

Total Complexity

8

Size/Duplication

Total Lines	57
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes	1
Bugs	0	Features	0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	getProvidedDependency()	0	3	1
A	getContainer()	0	9	2
A	createContainerWithProvidedDependencies()	0	18	3
A	singleton()	0	3	1
A	resetCache()	0	3	1

<?php

declare(strict_types=1);

namespace Gacela\Framework;

use Gacela\Framework\ClassResolver\Provider\DependencyProviderResolver;
use Gacela\Framework\ClassResolver\Provider\ProviderNotFoundException;
use Gacela\Framework\ClassResolver\Provider\ProviderResolver;
use Gacela\Framework\Config\Config;
use Gacela\Framework\Container\Container;

abstract class AbstractFactory
{
    use ConfigResolverAwareTrait;

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

    /** @var array<string,mixed> */
    private array $instances = [];

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

    protected function singleton(string $key, callable $creator): mixed
    {
        return $this->instances[$key] ??= $creator();
    }

    protected function getProvidedDependency(string $key): mixed
    {
        return $this->getContainer()->get($key);
    }

    private function getContainer(): Container
    {
        $containerKey = static::class;

        if (!isset(self::$containers[$containerKey])) {
            self::$containers[$containerKey] = $this->createContainerWithProvidedDependencies();
        }

        return self::$containers[$containerKey];
    }

    private function createContainerWithProvidedDependencies(): Container
    {
        $container = Container::withConfig(Config::getInstance());

        $resolver = (new ProviderResolver())->resolve($this);
        $resolver?->provideModuleDependencies($container);

        {
            // Temporal solution to keep BC with the AbstractDependencyProvider
            $dpResolver = (new DependencyProviderResolver())->resolve($this);
            $dpResolver?->provideModuleDependencies($container);

            if (!$resolver instanceof AbstractProvider && !$dpResolver instanceof AbstractProvider) {

$dpResolver is always a sub-type of Gacela\Framework\AbstractProvider.

                throw new ProviderNotFoundException(static::class);
            }
        }

        return $container;
    }
}