Fyuze\Config\Config

Complexity

Total Complexity

13

Size/Duplication

Total Lines	115
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes	4
Bugs	1	Features	0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	getType()	0	14	2
A	__construct()	0	5	1
A	load()	0	10	4
A	set()	0	9	2
A	get()	0	14	4

<?php
namespace Fyuze\Config;

use SplFileInfo;
use GlobIterator;
use InvalidArgumentException;
use Fyuze\Config\Parsers\PHP;

class Config
{
    /**
     * The configuration path
     *
     * @var string
     */
    protected $path;

    /**
     * Application env
     *
     * @var string
     */
    protected $env;

    /**
     * Loaded configurations
     *
     * @var array
     */
    protected $configs;

    /**
     * @var array
     */
    protected $types = [
        PHP::class
    ];

    /**
     * @param string $path
     * @param string $env
     */
    public function __construct($path, $env)
    {
        $this->path = $path;
        $this->env = $env;
        $this->load();

    }

    /**
     * @param $key
     * @param null $default

Are you sure the doc-type for parameter $default is correct as it would always require null to be passed?

     * @return mixed
     * @throws InvalidArgumentException
     */
    public function get($key, $default = null)
    {
        if (array_key_exists($key, $this->configs)) {
            return $this->configs[$key];
        }

        $configs = $this->configs;

        foreach (explode('.', $key) as $value) {

            $configs = array_key_exists($value, $configs) ? $configs[$value] : $default;
        }

        return $configs;
    }

    /**
     * @param $key
     * @param $value
     * @return mixed
     */
    public function set($key, $value)
    {
        $configs = &$this->configs;

        foreach (explode('.', $key) as $segment) {
            $configs = &$configs[$segment];
        }

        return $this->configs[$key] = $configs = $value;
    }

    /**
     *
     */
    protected function load()
    {
        if (!is_dir($this->path)) {
            throw new InvalidArgumentException(sprintf('The path you defined is not a valid directory: %s', $this->path));
        }

        foreach (new GlobIterator($this->path . '/*.*') as $file) {

            if($config = $this->getType($file)) {

It seems like $file can also be of type string; however, parameter $file of Fyuze\Config\Config::getType() does only seem to accept SplFileInfo, maybe add an additional type check?

                $this->configs[$config[0]] = $config[1];
            }
        }
    }

    /**
     * @param SplFileInfo $file
     * @return array
     */
    protected function getType(SplFileInfo $file)
    {
        $extension = $file->getExtension();
        $name = $file->getBasename(".$extension");

        $type = array_filter($this->types, function ($n) use ($extension) {
            return in_array($extension, $n::$extensions);
        });

        if (!$class = reset($type)) {
            return false;

The expression return false returns the type false which is incompatible with the documented return type array.

        }

        return [$name, (new $class)->parse($file)];
    }
}