Basis\Config

Complexity

Total Complexity

20

Size/Duplication

Total Lines	93
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Test Coverage

Coverage

54.84%

Importance

Changes	2
Bugs	0	Features	2

7 Methods

Rating	Name	Duplication	Size	Complexity
A	offsetExists()	0	4	1
A	offsetGet()	0	9	2
A	offsetUnset()	0	7	1
A	shouldHave()	0	6	2
B	__construct()	0	24	5
A	offsetSet()	0	11	3
B	getNode()	0	21	6

<?php


namespace Basis;


use ArrayAccess;

use Dotenv\Dotenv;


class Config implements ArrayAccess

{

    private $converter;


    function __construct(Filesystem $fs, Converter $converter)

It is generally recommended to explicitly declare the visibility for methods.

    {

        $this->converter = $converter;


        if($fs->exists('.env')) {

            $dotenv = new Dotenv($fs->path());

The method path() does not seem to exist on object<Basis\Filesystem>.

            $dotenv->load();

        }


        foreach ($fs->listFiles('resources/config') as $file) {

            $values = $this->converter->toObject(include $fs->getPath("resources/config/$file"));

            $current = $this;

            $name = substr($file, 0, -4);

            if (stristr($name, '/')) {

                $namespace = explode('/', $name);

                $name = array_pop($namespace);

                foreach ($namespace as $key) {

                    $current->$key = (object) [];

                    $current = $current->$key;

                }

            }

            $current->$name = $values;

        }

    }


    function offsetExists($offset)

It is generally recommended to explicitly declare the visibility for methods.

    {

        return $this->getNode($offset) != null;

    }


    function offsetGet($offset)

It is generally recommended to explicitly declare the visibility for methods.

    {

        $value = $this->getNode($offset);

        if(!is_object($value)) {

            return $value;

        }


        return $this->converter->toArray($value);

    }


    function offsetSet($offset, $value)

It is generally recommended to explicitly declare the visibility for methods.

    {

        $path = explode('.', $offset);

        $key = array_pop($path);

        $parent = $this->getNode(implode('.', $path), true);

        if (is_array($value) || is_object($value)) {

            $value = $this->converter->toObject($value);

        }


        return $parent->$key = $value;

    }


    function offsetUnset($offset)

It is generally recommended to explicitly declare the visibility for methods.

    {

        $path = explode('.', $offset);

        $key = array_pop($path);

        $parent = $this->getNode(implode('.', $path));

        unset($parent->$key);

    }


    function shouldHave($offset)

It is generally recommended to explicitly declare the visibility for methods.

    {

        if(!isset($this[$offset])) {

            throw new Exception("No offset $offset");

        }

    }


    private function getNode($offset, $createIfNone = false)

    {

        if (!$offset) {

            return $this;

        }

        $current = $this;

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

            if (is_object($current)) {

                if (!property_exists($current, $key)) {

                    if ($createIfNone) {

                        $current->$key = (object) [];

                    } else {

                        return;

                    }

                }

                $current = $current->$key;

            }

        }


        return $current;

    }

}