Micro\Config\Environment

Complexity

Total Complexity

12

Size/Duplication

Total Lines	127
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	1

Importance

Changes

0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	11	2
A	__get()	0	4	1
A	map()	0	4	1
C	variablesToTree()	0	42	8

<?php
declare(strict_types = 1);

/**
 * Micro
 *
 * @author    Fabian Jucker <jucker@gyselroth.net>
 * @copyright Copyright (c) 2017 gyselroth GmbH (https://gyselroth.com)
 * @license   MIT https://opensource.org/licenses/MIT
 */

namespace Micro\Config;

use \Micro\Config;

class Environment implements ConfigInterface
{
    /**
     * DELIMITER
     *
     * @var string
     */
    const DEFAULT_DELIMITER = '_';


    /**
     * Store
     *
     * @var Config
     */
    private $store;


    /**
     * Variable delimiter
     *
     * @var string
     */
    protected $delimiter = self::DEFAULT_DELIMITER;


    /**
     * Variable prefix
     *
     * @var string
     */
    protected $prefix;


    /**
     * Load config
     *
     * @param  string $prefix
     * @param  string $delimiter
     * @param  array $variables
     * @return void

Adding a @return annotation to constructors is generally not recommended as a constructor does not have a meaningful return value.

     */
    public function __construct(?string $prefix=null, $delimiter=self::DEFAULT_DELIMITER, array $variables=[])
    {
        $this->delimiter = $delimiter;
        $this->prefix = strtolower($prefix);

        if(count($variables) === 0) {
            $this->store = $this->variablesToTree(array_merge($_ENV, $_SERVER));
        } else {
            $this->store = $this->variablesToTree($variables);
        }
   }


    /**
     * Get from config
     *
     * @param   string $name
     * @return  mixed
     */
    public function __get(string $name)
    {
        return $this->store->{$name};
    }


    /**
     * Return map
     *
     * @return  Config
     */
    public function map(): Config
    {
        return $this->store;
    }


    /**
     * Transform array of environment variables into a tree
     *
     * @param   array $variables
     * @return  Config
     */
    protected function variablesToTree(array $variables): Config
    {
        $variables = array_change_key_case($variables);

        $root = new Config();
        foreach ($variables as $name => $value) {
            $name = explode($this->delimiter, $name);

            if($this->prefix !== null) {
                if($name[0] !== $this->prefix) {
                    continue;
                } else {
                    array_shift($name);
                }
            }

            $tree = $root;


            for ($i = 0; $i < count($name); $i++) {

It seems like you are calling the size function count() as part of the test condition. You might want to compute the size beforehand, and not on each iteration.

                $key = $name[$i];

                try {
                  // create new subtree if requested subtree already has a value
                  if (!($tree->$key instanceof Config)) {
                      $tree[$key] = new Config([$tree->$key]);

array($tree->{$key}) is of type array<integer,?,{"0":"?"}>, but the function expects a string|null.

                  }

                  $tree = $tree->$key;
                } catch (Exception $e) {
                    // set value if last keypart or create subtree
                    if($i == (count($name) - 1)) {
                        $tree[$key] = $value;
                    } else {
                        $tree[$key] = new Config();
                        $tree = $tree->$key;
                    }
                }
            }
        }
        return $root;
    }
}