Storeman\Config\ConfigurationFileReader

Complexity

Total Complexity

17

Size/Duplication

Total Lines	108
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	14

Importance

Changes

0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	2
A	getConfiguration()	0	23	2
B	readJsonFile()	0	26	6
A	mergeDefaults()	0	21	4
A	validateConfiguration()	0	10	2
A	getValidator()	0	7	1

<?php

namespace Storeman\Config;

use Psr\Log\LoggerAwareInterface;
use Psr\Log\LoggerAwareTrait;
use Psr\Log\NullLogger;
use Storeman\ArrayUtils;
use Storeman\Container;
use Storeman\Exception;
use Storeman\PathUtils;
use Storeman\Validation\ContainerConstraintValidatorFactory;
use Symfony\Component\Validator\Validation;
use Symfony\Component\Validator\Validator\ValidatorInterface;

class ConfigurationFileReader implements LoggerAwareInterface
{
    use LoggerAwareTrait;


    /**
     * @var Container
     */
    protected $container;

    public function __construct(Container $container = null)
    {
        $this->container = $container ?: new Container();
        $this->logger = new NullLogger();
    }

    public function getConfiguration(string $configurationFilePath, array $configurationDefaults = [], array $vaultConfigurationDefaults = []): Configuration
    {
        $this->logger->info("Reading config file from {$configurationFilePath}...");

        $array = $this->readJsonFile($configurationFilePath);
        $array = $this->mergeDefaults($array, $configurationDefaults, $vaultConfigurationDefaults);

        try
        {
            $configuration = new Configuration();
            $configuration->exchangeArray($array);
        }
        catch (\InvalidArgumentException $exception)
        {
            throw new ConfigurationException("In file {$configurationFilePath}", 0, $exception);
        }

        $this->validateConfiguration($configuration, $configurationFilePath);

        $this->logger->info("The following configuration has been read: " . var_export($configuration->getArrayCopy(), true));

        return $configuration;
    }

    protected function readJsonFile(string $configurationFilePath): array
    {
        $configurationFilePath = PathUtils::getAbsolutePath($configurationFilePath);

        if (!is_file($configurationFilePath) || !is_readable($configurationFilePath))
        {
            throw new Exception("Configuration file {$configurationFilePath} is not a readable file.");
        }

        if (($json = file_get_contents($configurationFilePath)) === false)
        {
            throw new Exception("Failed to read config file {$configurationFilePath}.");
        }

        if (($array = json_decode($json, true)) === null)
        {
            throw new Exception("Malformed configuration file: {$configurationFilePath}.");
        }

        if (!is_array($array))
        {
            throw new ConfigurationException("Malformed configuration file: {$configurationFilePath}");
        }

        return $array;
    }

    protected function mergeDefaults(array $config, array $configurationDefaults, array $vaultConfigurationDefaults): array
    {
        if (!array_key_exists('vaults', $config) || !is_array($config['vaults']))
        {
            throw new ConfigurationException("Missing vault configurations");
        }

        $config = ArrayUtils::merge($configurationDefaults, $config);
        $config['vaults'] = array_map(function($vaultConfig) use ($vaultConfigurationDefaults) {

            if (!is_array($vaultConfig))
            {
                throw new ConfigurationException();
            }

            return ArrayUtils::merge($vaultConfigurationDefaults, $vaultConfig);

        }, $config['vaults']);

        return $config;
    }

    protected function validateConfiguration(Configuration $configuration, string $configurationFilePath)
    {
        $constraintViolations = $this->getValidator()->validate($configuration);
        if ($constraintViolations->count())
        {
            $violation = $constraintViolations->get(0);

            throw new ConfigurationException("{$configurationFilePath}: {$violation->getPropertyPath()} - {$violation->getMessage()}");
        }
    }

    protected function getValidator(): ValidatorInterface
    {
        return Validation::createValidatorBuilder()
            ->setConstraintValidatorFactory(new ContainerConstraintValidatorFactory($this->container))
            ->addMethodMapping('loadValidatorMetadata')
            ->getValidator();
    }
}