Gacela\Framework\Config\ConfigFactory

Complexity

Total Complexity

14

Size/Duplication

Total Lines	102
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes	5
Bugs	0	Features	0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	createConfigLoader()	0	6	1
A	createPathNormalizer()	0	5	1
A	createFileIo()	0	3	1
A	createGacelaFileConfig()	0	32	4
A	__construct()	0	4	1
A	env()	0	3	2
A	getGacelaPhpDefaultPath()	0	7	1
A	resetCache()	0	3	1
A	createPathFinder()	0	3	1
A	getGacelaPhpPathFromEnv()	0	8	1

<?php

declare(strict_types=1);

namespace Gacela\Framework\Config;

use Gacela\Framework\AbstractFactory;
use Gacela\Framework\Bootstrap\SetupGacelaInterface;
use Gacela\Framework\Config\GacelaFileConfig\Factory\GacelaConfigFromBootstrapFactory;
use Gacela\Framework\Config\GacelaFileConfig\Factory\GacelaConfigUsingGacelaPhpFileFactory;
use Gacela\Framework\Config\GacelaFileConfig\GacelaConfigFileInterface;
use Gacela\Framework\Config\PathNormalizer\AbsolutePathNormalizer;
use Gacela\Framework\Config\PathNormalizer\WithoutSuffixAbsolutePathStrategy;
use Gacela\Framework\Config\PathNormalizer\WithSuffixAbsolutePathStrategy;

final class ConfigFactory extends AbstractFactory
{
    private const GACELA_PHP_CONFIG_FILENAME = 'gacela';
    private const GACELA_PHP_CONFIG_EXTENSION = '.php';

    private static ?GacelaConfigFileInterface $gacelaFileConfig = null;

    public function __construct(
        private string $appRootDir,
        private SetupGacelaInterface $setup,
    ) {
    }

    public static function resetCache(): void
    {
        self::$gacelaFileConfig = null;
    }

    public function createConfigLoader(): ConfigLoader
    {
        return new ConfigLoader(
            $this->createGacelaFileConfig(),
            $this->createPathFinder(),
            $this->createPathNormalizer(),
        );
    }

    public function createGacelaFileConfig(): GacelaConfigFileInterface
    {
        if (self::$gacelaFileConfig !== null) {
            return self::$gacelaFileConfig;
        }

        $gacelaConfigFiles = [];
        $fileIo = $this->createFileIo();

        $gacelaPhpDefaultPath = $this->getGacelaPhpDefaultPath();
        if ($fileIo->existsFile($gacelaPhpDefaultPath)) {
            $factoryFromGacelaPhp = new GacelaConfigUsingGacelaPhpFileFactory(
                $gacelaPhpDefaultPath,
                $this->setup,
                $fileIo,
            );
            $gacelaConfigFiles[] = $factoryFromGacelaPhp->createGacelaFileConfig();
        }

        $gacelaPhpPath = $this->getGacelaPhpPathFromEnv();
        if ($fileIo->existsFile($gacelaPhpPath)) {
            $factoryFromGacelaPhp = new GacelaConfigUsingGacelaPhpFileFactory($gacelaPhpPath, $this->setup, $fileIo);
            $gacelaConfigFiles[] = $factoryFromGacelaPhp->createGacelaFileConfig();
        }

        self::$gacelaFileConfig = array_reduce(
            $gacelaConfigFiles,
            static fn (GacelaConfigFileInterface $carry, GacelaConfigFileInterface $item) => $carry->combine($item),
            (new GacelaConfigFromBootstrapFactory($this->setup))->createGacelaFileConfig(),
        );

        return self::$gacelaFileConfig;

The expression return self::gacelaFileConfig returns the type null which is incompatible with the type-hinted return Gacela\Framework\Config\GacelaFileConfig\GacelaConfigFileInterface.

    }

    private function createFileIo(): FileIoInterface
    {
        return new FileIo();
    }

    private function getGacelaPhpDefaultPath(): string
    {
        return sprintf(
            '%s/%s%s',
            $this->appRootDir,
            self::GACELA_PHP_CONFIG_FILENAME,
            self::GACELA_PHP_CONFIG_EXTENSION,
        );
    }

    private function getGacelaPhpPathFromEnv(): string
    {
        return sprintf(
            '%s/%s-%s%s',
            $this->appRootDir,
            self::GACELA_PHP_CONFIG_FILENAME,
            $this->env(),
            self::GACELA_PHP_CONFIG_EXTENSION,
        );
    }

    private function env(): string
    {
        return getenv('APP_ENV') ?: '';
    }

    private function createPathFinder(): PathFinderInterface
    {
        return new PathFinder();
    }

    private function createPathNormalizer(): PathNormalizerInterface
    {
        return new AbsolutePathNormalizer([
            AbsolutePathNormalizer::WITHOUT_SUFFIX => new WithoutSuffixAbsolutePathStrategy($this->appRootDir),
            AbsolutePathNormalizer::WITH_SUFFIX => new WithSuffixAbsolutePathStrategy($this->appRootDir, $this->env()),
        ]);
    }
}