Gacela\Framework\AbstractFactory

Complexity

Total Complexity

7

Size/Duplication

Total Lines	59
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes

0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	getServicesToExtend()	0	5	1
A	resolveDependencyProvider()	0	3	1
A	getProvidedDependency()	0	3	1
A	getContainer()	0	9	2
A	createContainerWithProvidedDependencies()	0	7	1
A	resetCache()	0	3	1

<?php

declare(strict_types=1);

namespace Gacela\Framework;

use Closure;
use Gacela\Framework\ClassResolver\DependencyProvider\DependencyProviderResolver;
use Gacela\Framework\Config\Config;
use Gacela\Framework\Container\Container;
use Gacela\Framework\Container\Exception\ContainerKeyNotFoundException;

abstract class AbstractFactory
{
    use ConfigResolverAwareTrait;

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

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

    /**
     * @throws ContainerKeyNotFoundException
     */
    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 = new Container($this->getServicesToExtend());
        $dependencyProvider = $this->resolveDependencyProvider();
        $dependencyProvider->provideModuleDependencies($container);

        return $container;
    }

    /**
     * @return array<string,list<Closure>>
     */
    private function getServicesToExtend(): array
    {
        return Config::getInstance()
            ->getSetupGacela()
            ->getServicesToExtend();
    }

    /**
     * @throws ClassResolver\DependencyProvider\DependencyProviderNotFoundException
     */
    private function resolveDependencyProvider(): AbstractDependencyProvider
    {
        return (new DependencyProviderResolver())->resolve($this);
    }
}