Enjoys\Config\Config

Complexity

Total Complexity

18

Size/Duplication

Total Lines	109
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes	2
Bugs	0	Features	0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	setLogger()	0	3	1
A	getConfig()	0	11	3
A	__construct()	0	3	1
B	addConfig()	0	28	7
A	parse()	0	25	6

<?php

declare(strict_types=1);

namespace Enjoys\Config;

use Psr\Log\LoggerAwareInterface;
use Psr\Log\LoggerAwareTrait;
use Psr\Log\LoggerInterface;
use Psr\Log\NullLogger;


/**
 * Description of Config
 * @author Enjoys
 */
final class Config
{

    public const YAML = Parse\YAML::class;
    public const INI = Parse\INI::class;
    public const JSON = Parse\Json::class;


    private array $config = [];

    private LoggerInterface $logger;

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

    /**
     *
     * @param array|string $params
     * @param array $options
     * @param string $parseClass
     * @param bool $replace
     * @return void
     * @throws \Exception
     */
    public function addConfig($params, array $options = [], string $parseClass = self::INI, bool $replace = true): void
    {
        $params = (array)$params;

        if (!class_exists($parseClass)) {
            throw new \Exception(sprintf('Not found parse class: %s', $parseClass));
        }
        /** @var  ParseInterface $parser */
        $parser = new $parseClass();
        $parser->setOptions($options);

The method setOptions() does not exist on Enjoys\Config\ParseInterface. Since it exists in all sub-types, consider adding an abstract or default implementation to Enjoys\Config\ParseInterface.

        $parser->setLogger($this->logger);

        foreach ($params as $namespace => $config) {
            if (is_int($namespace)) {
                $namespace = null;
            }

            if (is_string($namespace)) {
                $namespace = \trim($namespace);
            }

            if (is_array($config)) {
                foreach ($config as $_config) {
                    $this->parse($parser, $_config, $namespace, $replace);
                }
                continue;
            }
            $this->parse($parser, $config, $namespace, $replace);
        }
    }

    private function parse(
        ParseInterface $parser,
        string $config,
        ?string $namespace = null,
        bool $replace = true
    ): void {
        $parser->addConfigSource($config);

        $result = $parser->parse();

        if (is_array($result)) {
            if ($namespace === null) {
                if ($replace === true) {
                    $this->config = array_merge($this->config, $result);
                } else {
                    $this->config = array_merge($result, $this->config);
                }
            } else {
                if (!array_key_exists($namespace, $this->config)) {
                    $this->config[$namespace] = [];
                }
                if ($replace === true) {
                    $this->config[$namespace] = array_merge((array)$this->config[$namespace], $result);
                } else {
                    $this->config[$namespace] = array_merge($result, (array)$this->config[$namespace]);
                }
            }
        }
    }

    /**
     *
     * @param string $key
     * @param mixed $default
     * @return mixed
     */
    public function getConfig(string $key = null, $default = null)
    {
        if ($key === null) {
            return $this->config;
        }

        if (array_key_exists($key, $this->config)) {
            return $this->config[$key];
        }

        return $default;
    }

    public function setLogger(LoggerInterface $logger): void
    {
        $this->logger = $logger;
    }
}