DevOp\Core\Config

Complexity

Total Complexity

15

Size/Duplication

Total Lines	122
Duplicated Lines	0 %

Test Coverage

Coverage

82.5%

Importance

Changes

0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	get()	0	7	2
A	init()	0	3	1
A	load()	0	12	3
A	has()	0	3	1
A	__construct()	0	3	1
A	all()	0	3	1
A	set()	0	5	1
A	loadFromArray()	0	25	5

<?php
namespace DevOp\Core;

class Config
{

    /**
     * @var mixed
     */
    private $container = [];

    /**
     * @param mixed $resources
     * @param string|null $environment
     * @param array|null $params
     */
    public function __construct($resources, $environment = null, array $params = [])
    {
        $this->load($resources, $environment, $params);
    }

    /**
     * @param string $name
     * @return boolean
     */
    public function has($name)
    {
        return isset($this->container[$name]);
    }

    /**
     * @param string $name
     * @param mixed $default
     * @return mixed
     */
    public function get($name, $default = null)
    {
        if ($this->has($name)) {
            return $this->container[$name];
        }

        return $default;
    }

    /**
     * @param string $name
     * @param mixed $args
     */
    public function set($name, $args)
    {
        $this->container[$name] = $args;

        return $this;
    }

    /**
     * @return mixed
     */
    public function all()
    {
        return $this->container;
    }

    /**
     * @param mixed $resources
     * @param string|null $environment
     * @param array $params
     * @return \static
     */
    public static function init($resources, $environment = null, array $params = [])
    {
        return new static($resources, $environment, $params);

The expression return new static($resources, $environment, $params) returns the type DevOp\Core\Config which is incompatible with the documented return type static.

    }
    
    /**
     * @param mixed $resources
     * @param string|null $environment
     * @param array $params
     * @throws \RuntimeException
     */
    public function load($resources, $environment = null, array $params = [])
    {

        if (is_array($resources)) {
            $data = $this->loadFromArray($resources, $environment);
        } else if (file_exists($resources)) {
            $data = $this->loadFromFile([$resources], $environment);

The method loadFromFile() does not exist on DevOp\Core\Config. Did you maybe mean loadFromArray()?

        } else {
            throw new \RuntimeException('Invalid configuration source defined.');
        }

        $this->container = array_replace_recursive($data, $params);
    }

    /**
     * @param array $resources
     * @param string|null $environment
     * @return mixed
     * @throws \InvalidArgumentException
     */
    private function loadFromArray(array $resources = [], $environment = null)
    {
        $data = [];

        foreach ($resources AS $resource) {
            
            if (!file_exists($resource)) {
                throw new \InvalidArgumentException("Invalid resource {$resource}");
            }

            $data = array_replace_recursive($data, include $resource);

            if (null === $environment) {
                continue;
            }

            $pathinfo = pathinfo($resource);
            $filename = "{$pathinfo['filename']}_{$environment}.{$pathinfo['extension']}";

            if (file_exists($filename)) {
                $data = array_replace_recursive($data, include $filename);
            }
        }

        return $data;
    }
}