Teebot\Configuration\AbstractLoader

Complexity

Total Complexity

10

Size/Duplication

Total Lines	124
Duplicated Lines	0 %

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	6	1
A	getFileName()	0	5	2
A	initEnv()	0	6	2
A	loadFromArray()	0	5	1
A	processConfig()	0	7	1
A	load()	0	6	1
A	getConfigFile()	0	10	2

<?php

declare(strict_types=1);

namespace Teebot\Configuration;

use Symfony\Component\Config\{
    Definition\Processor,
    Definition\ConfigurationInterface,
    Exception\FileLoaderLoadException,
    FileLocator
};
use Symfony\Component\Yaml\Yaml;
use Dotenv\{
    Dotenv,
    Exception\InvalidPathException
};

/**
 * Abstract configuration loader
 *
 * @package Teebot\Configuration
 */
abstract class AbstractLoader
{
    protected const FILE_NAME = 'config%s.yml';

    /**
     * @var string $path
     */
    protected $path;

    /**
     * @var string $fileName
     */
    protected $fileName;

    /**
     * @param string $path
     */
    public function __construct(string $path)
    {
        $this->initEnv($path);

        $this->path     = $path;
        $this->fileName = $this->getFileName();
    }

    /**
     * Loads configuration
     *
     * @return ContainerInterface
     */
    public function load(): ContainerInterface
    {
        $configFile = $this->getConfigFile();
        $data       = Yaml::parse(file_get_contents($configFile));

        return $this->loadFromArray($data);
    }

    /**
     * Loads configuration from array
     *
     * @param array $configData
     *
     * @return ContainerInterface
     */
    public function loadFromArray(array $configData): ContainerInterface
    {
        $config = $this->processConfig($configData);

        return $this->initContainer($config);
    }

    /**
     * Returns config file name based on the current environment
     *
     * @return string
     */
    protected function getFileName(): string
    {
        $env = getenv('ENV') ? '_' . getenv('ENV') : '';

        return sprintf(static::FILE_NAME, $env);
    }

    /**
     * Initializes and loads the DotEnv, suppress the DotEnv exception to continue loading process
     *
     * @param string $path
     */
    protected function initEnv(string $path)
    {
        try {
            $dotenv = new Dotenv($path);
            $dotenv->load();
        } catch (InvalidPathException $e) {

Consider adding a comment why this CATCH block is empty.

        }
    }

    /**
     * Returns path to config file
     *
     * @return string
     *
     * @throws FileLoaderLoadException
     */
    protected function getConfigFile(): string
    {
        $locator    = new FileLocator($this->path);
        $configFile = $locator->locate($this->fileName, null, true);

        if (!is_readable($configFile)) {

It seems like $configFile can also be of type array; however, parameter $filename of is_readable() does only seem to accept string, maybe add an additional type check?

            throw new FileLoaderLoadException('Config file is not readable!');
        }

        return $configFile;

The expression return $configFile could return the type array which is incompatible with the type-hinted return string. Consider adding an additional type-check to rule them out.

    }

    /**
     * Processes the config
     *
     * @param array $data
     *
     * @return array
     */
    protected function processConfig(array $data): array
    {
        $processor       = new Processor();
        $configuration   = $this->getConfiguration();
        $processedConfig = $processor->processConfiguration($configuration, $data);

        return $processedConfig;
    }

    /**
     * @return ConfigurationInterface
     */
    abstract protected function getConfiguration(): ConfigurationInterface;

    /**
     * @param array $config
     *
     * @return ContainerInterface
     */
    abstract protected function initContainer(array $config): ContainerInterface;
}