Enjoys\Config\Config

Complexity

Total Complexity

25

Size/Duplication

Total Lines	167
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes	4
Bugs	1	Features	0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	parse()	0	30	6
A	setLogger()	0	3	1
A	setSeparator()	0	3	1
A	get()	0	3	1
A	getConfig()	0	12	3
A	__construct()	0	3	1
B	addConfig()	0	28	7
A	getValue()	0	17	5

<?php

declare(strict_types=1);

namespace Enjoys\Config;

use Enjoys\Config\ValueHandler\DefinedConstantsValueHandler;
use Enjoys\Config\ValueHandler\EnvValueHandler;
use Psr\Log\LoggerInterface;
use Psr\Log\NullLogger;


final class Config
{

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


    private array $config = [];


    /**
     * @var non-empty-string

The doc comment non-empty-string at position 0 could not be parsed: Unknown type name 'non-empty-string' at position 0 in non-empty-string.

     */
    private string $separator = '->';

    private ?LoggerInterface $logger;

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

    /**
     *
     * @param array|string $params
     * @param array $options
     * @param class-string<ParseInterface> $parseClass

The doc comment class-string<ParseInterface> at position 0 could not be parsed: Unknown type name 'class-string' at position 0 in class-string<ParseInterface>.

     * @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));
        }
        $parser = new $parseClass();
        $parser->setOptions($options);
        $parser->setLogger($this->logger);

        /** @var string|string[] $config */
        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_recursive_distinct($this->config, $result);
                } else {
                    $this->config = \array_merge_recursive_distinct($result, $this->config);
                }
            } else {
                if (!array_key_exists($namespace, $this->config)) {
                    $this->config[$namespace] = [];
                }
                if ($replace === true) {
                    $this->config[$namespace] = \array_merge_recursive_distinct(
                        (array)$this->config[$namespace],
                        $result
                    );
                } else {
                    $this->config[$namespace] = \array_merge_recursive_distinct(
                        $result,
                        (array)$this->config[$namespace]
                    );
                }
            }
        }
    }


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

        $parts = explode($this->separator, $key);

        try {
            return $this->getValue($parts, $this->config);
        } catch (Exception $e) {
            return $default;
        }
    }

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

    /**
     * @param string[] $parts
     * @param mixed $array
     * @return mixed
     * @throws Exception
     */
    private function getValue(array $parts, $array)
    {
        if (!is_array($array)) {
            throw new Exception();
        }

        $key = array_shift($parts);

        if ($key === null || !array_key_exists($key, $array)) {
            throw new Exception();
        }

        if (count($parts) > 0) {
            return $this->getValue($parts, $array[$key]);
        }

        return $array[$key];
    }

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

    /**
     * @param non-empty-string $separator

The doc comment non-empty-string at position 0 could not be parsed: Unknown type name 'non-empty-string' at position 0 in non-empty-string.

     */
    public function setSeparator(string $separator): void
    {
        $this->separator = $separator;
    }


}