Botonomous\AbstractConfig

Complexity

Total Complexity

13

Size/Duplication

Total Lines	99
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Test Coverage

Coverage

100%

Importance

Changes

0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	get()	0	21	4
A	getPluginConfigObject()	0	11	2
A	getPluginConfigs()	0	8	2
A	getConfigs()	0	4	1
A	set()	0	13	4

<?php

namespace Botonomous;

use Botonomous\utility\ArrayUtility;
use Botonomous\utility\StringUtility;

/**
 * Class AbstractConfig.
 */
abstract class AbstractConfig
{
    protected static $configs;

    /**
     * @param       $key
     * @param array $replacements
     * @param null  $plugin
     *
     * @throws \Exception
     *
     * @return mixed
     */
    public function get(string $key, array $replacements = [], $plugin = null)
    {
        $configs = static::$configs;

        // overwrite $configs if $plugin is presented
        if ($plugin !== null) {
            try {
                $configs = $this->getPluginConfigs($plugin);
            } catch (\Exception $e) {
                throw $e;
            }
        }

        if (!array_key_exists($key, $configs)) {
            throw new BotonomousException("Key: '{$key}' does not exist in configs");
        }

        $found = $configs[$key];

        return (new StringUtility())->applyReplacements($found, $replacements);
    }

    /**
     * @param $plugin
     *
     * @throws \Exception
     *
     * @return self

Should the return type not be \self?

     */
    private function getPluginConfigObject($plugin): self
    {
        $pluginConfigClass = __NAMESPACE__.'\\plugin\\'.strtolower($plugin)
            .'\\'.ucfirst($plugin).'Config';

        if (!class_exists($pluginConfigClass)) {
            throw new BotonomousException("Config file: '{$pluginConfigClass}.php' does not exist");
        }

        return new $pluginConfigClass();
    }

    /**
     * @param $plugin
     *
     * @throws \Exception
     *
     * @return array
     */
    public function getPluginConfigs($plugin)
    {
        try {
            return $this->getPluginConfigObject($plugin)->getConfigs();
        } catch (\Exception $e) {
            throw $e;
        }
    }

    /**
     * @return array
     */
    public function getConfigs(): array
    {
        return static::$configs;
    }

    /**
     * @param      $key
     * @param      $value
     * @param null $plugin
     *
     * @throws \Exception
     */
    public function set($key, $value, $plugin = null)
    {
        if ($plugin !== null) {
            try {
                $this->getPluginConfigObject($plugin)->set($key, $value);
            } catch (\Exception $e) {
                throw $e;
            }
        }

        is_array($key) ? (new ArrayUtility())->setNestedArrayValue(static::$configs, $key, $value)
            : static::$configs[$key] = $value;
    }
}