Robo\Config\Config

Complexity

Total Complexity

22

Size/Duplication

Total Lines	221
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	2

Importance

Changes

0

16 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	has()	0	4	1
A	get()	0	7	2
A	set()	0	5	1
A	import()	0	7	2
A	extend()	0	10	2
A	export()	0	4	1
A	applyConfiguration()	0	11	3
A	getGlobalOptionDefaultValues()	0	10	1
A	getDefault()	0	4	2
A	setDefault()	0	5	1
A	isSimulated()	0	4	1
A	setSimulated()	0	4	1
A	isDecorated()	0	4	1
A	setDecorated()	0	4	1
A	setProgressBarAutoDisplayInterval()	0	4	1

<?php
namespace Robo\Config;

use Dflydev\DotAccessData\Data;

class Config
{
    const PROGRESS_BAR_AUTO_DISPLAY_INTERVAL = 'progress-delay';
    const DEFAULT_PROGRESS_DELAY = 2;
    const SIMULATE = 'simulate';
    const DECORATED = 'decorated';

    /**
     * @var Data
     */
    protected $config;

    /**
     * @var array
     */
    protected $defaults;

    /**
     * Create a new configuration object, and initialize it with
     * the provided nested array containing configuration data.
     */
    public function __construct(array $data = null)
    {
        $this->config = new Data($data);
        $this->defaults = $this->getGlobalOptionDefaultValues();
    }

    /**
     * Determine if a non-default config value exists.
     */
    public function has($key)
    {
        return ($this->config->has($key));
    }

    /**
     * Fetch a configuration value
     *
     * @param string $key Which config item to look up
     * @param string|null $defaultOverride Override usual default value with a different default. Deprecated; provide defaults to the config processor instead.
     *
     * @return mixed
     */
    public function get($key, $defaultOverride = null)
    {
        if ($this->has($key)) {
            return $this->config->get($key);
        }
        return $this->getDefault($key, $defaultOverride);
    }

    /**
     * Set a config value
     *
     * @param string $key
     * @param mixed $value
     *
     * @return $this
     */
    public function set($key, $value)
    {
        $this->config->set($key, $value);
        return $this;
    }

    /**
     * Import configuration from the provided nexted array, replacing whatever
     * was here previously. No processing is done on the provided data.
     *
     * @param array $data
     * @return Config
     */
    public function import($data)
    {
        if (!empty($data)) {
            $this->config->import($data, true);
        }
        return $this;
    }

    /**
     * Extend this configuration by merging the provided nested array.
     * This will also do some simple processing on the data.
     *
     * @param array|ConfigLoaderInterface $data
     */
    public function extend($data)
    {
        if (empty($data)) {
            return;
        }
        $processor = new ConfigProcessor();
        $processor->add($this->config->export());
        $processor->add($data);

It seems like $data defined by parameter $data on line 92 can also be of type object<Robo\Config\ConfigLoaderInterface>; however, Robo\Config\ConfigProcessor::add() does only seem to accept array, maybe add an additional type check?

        return $this->import($processor->export());
    }

    /**
     * Export all configuration as a nested array.
     */
    public function export()
    {
        return $this->config->export();
    }

    /**
     * Given an object that contains configuration methods, inject any
     * configuration found in the configuration file.
     *
     * The proper use for this method is to call setter methods of the
     * provided object. Using configuration to call methods that do work
     * is an abuse of this mechanism.
     *
     * TODO: We could use reflection to test to see if the return type
     * of the provided object is a reference to the object itself. All
     * setter methods should do this. This test is insufficient to guarentee
     * that the method is valid, but it would be a good start.
     */
    public function applyConfiguration($object, $configurationKey)
    {
        if ($this->has($configurationKey)) {
            $settings = $this->get($configurationKey);
            foreach ($settings as $setterMethod => $args) {
                // TODO: Should it be possible to make $args a nested array
                // to make this code call the setter method multiple times?
                call_user_func_array([$object, $setterMethod], (array)$args);
            }
        }
    }

    /**
     * Return an associative array containing all of the global configuration
     * options and their default values.
     *
     * @return array
     */
    public function getGlobalOptionDefaultValues()
    {
        $globalOptions =
        [
            self::PROGRESS_BAR_AUTO_DISPLAY_INTERVAL => self::DEFAULT_PROGRESS_DELAY,
            self::SIMULATE => false,
        ];

        return $globalOptions;
    }

    /**
     * Return the default value for a given configuration item.
     *
     * @param string $key
     * @param mixed $defaultOverride
     *
     * @return mixed
     */
    public function getDefault($key, $defaultOverride = null)
    {
        return isset($this->defaults[$key]) ? $this->defaults[$key] : $defaultOverride;
    }

    /**
     * Set the default value for a configuration setting. This allows us to
     * set defaults either before or after more specific configuration values
     * are loaded. Keeping defaults separate from current settings also
     * allows us to determine when a setting has been overridden.
     *
     * @param string $key
     * @param string $value
     */
    public function setDefault($key, $value)
    {
        $this->defaults[$key] = $value;
        return $this;
    }

    /**
     * @return bool
     */
    public function isSimulated()
    {
        return $this->get(self::SIMULATE);
    }

    /**
     * @param bool $simulated
     *
     * @return $this
     */
    public function setSimulated($simulated = true)
    {
        return $this->set(self::SIMULATE, $simulated);
    }

    /**
     * @return bool
     */
    public function isDecorated()
    {
        return $this->get(self::DECORATED);
    }

    /**
     * @param bool $decorated
     *
     * @return $this
     */
    public function setDecorated($decorated = true)
    {
        return $this->set(self::DECORATED, $decorated);
    }

    /**
     * @param int $interval
     *
     * @return $this
     */
    public function setProgressBarAutoDisplayInterval($interval)
    {
        return $this->set(self::PROGRESS_BAR_AUTO_DISPLAY_INTERVAL, $interval);
    }
}