Micro\Config\Environment

Complexity

Total Complexity

23

Size/Duplication

Total Lines	214
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Importance

Changes

0

12 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	6	1
A	getRaw()	0	4	1
A	getRawRecursive()	0	11	3
A	__get()	0	4	1
A	merge()	0	15	3
A	map()	0	14	3
A	parseEnvironmentVars()	0	9	1
A	variablesToTree()	0	20	4
A	getEnvironmentPrefix()	0	4	1
A	removeEnvironmentPrefix()	0	8	2
A	hasEnvironmentPrefix()	0	5	1
A	isValidEnvironmentVariable()	0	6	2

<?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;
use Micro\Config\Environment\EnvironmentNode;

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

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

    /**
     * Environment
     *
     * @var string
     */
    private $environment;

    /**
     * Load config
     *
     * @param  string $config
     * @param  string $env
     * @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 $config = null, string $env = 'production')
    {
        $this->environment = $env;
        $environmentVars = array_merge($_ENV, $_SERVER);
        $this->store = $this->parseEnvironmentVars($environmentVars);
    }


    /**
     * Get raw format
     *
     * @return mixed
     */
    public function getRaw(): array
    {
        return $this->getRawRecursive([$this->store]);
    }

    /**
     * Get from config
     *
     * @param   EnvironmentNode[] $nodes
     * @return  array
     */
    protected function getRawRecursive(array $nodes): array
    {
        $raw = [];
        foreach ($nodes as $entry) {
            if ($entry->value) {

The property $value is declared private in Micro\Config\Environment\EnvironmentNode. Since you implemented __get(), maybe consider adding a @property or @property-read annotation. This makes it easier for IDEs to provide auto-completion.

                $raw[$this->getEnvironmentPrefix() . $entry->getFullKey()] = $entry->value;

The property $value is declared private in Micro\Config\Environment\EnvironmentNode. Since you implemented __get(), maybe consider adding a @property or @property-read annotation. This makes it easier for IDEs to provide auto-completion.

            }
            $raw = array_merge($raw, $this->getRawRecursive($entry->children));

The property $children is declared private in Micro\Config\Environment\EnvironmentNode. Since you implemented __get(), maybe consider adding a @property or @property-read annotation. This makes it easier for IDEs to provide auto-completion.

        }
        return $raw;
    }

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


    /**
     * Add config tree and merge it
     *
     * @param   mixed $config
     * @return  ConfigInterface
     */
    public function merge($config): ConfigInterface
    {
        if (!$config instanceof Environment) {
            throw new Exception('not able to merge objects of other types than ' . static::class);
        }
        $raw = $this->getRaw();

        // ensure right env is set on variables
        foreach ($config->getRaw() as $key => $value) {
            $key = $this->getEnvironmentPrefix() . $config->removeEnvironmentPrefix($key);
            $raw[$key] = $value;
        }
        $this->store = $this->parseEnvironmentVars($raw);
        return $this;
    }


    /**
     * Get native config format as config instance
     *
     * @return  Config
     */
    public function map($environmentVariables = null): Config
    {
        if ($environmentVariables === null) {
            $envConfig = $this->store;
        } else {
            $envConfig = $this->parseEnvironmentVars($environmentVariables);
        }

        $config = new Config();
        foreach ($envConfig->children as $entry) {

The property $children is declared private in Micro\Config\Environment\EnvironmentNode. Since you implemented __get(), maybe consider adding a @property or @property-read annotation. This makes it easier for IDEs to provide auto-completion.

            $config[$entry->key] = $entry->toConfig();

The property $key is declared private in Micro\Config\Environment\EnvironmentNode. Since you implemented __get(), maybe consider adding a @property or @property-read annotation. This makes it easier for IDEs to provide auto-completion.

        }
        return $config;
    }

    /**
     * Filter environment variables for current environment and parse them into a tree
     *
     * @param   array $environmentVars
     * @return  EnvironmentNode
     */
    protected function parseEnvironmentVars(array $environmentVars)
    {
        // only parse environment variables with valid names
        $environmentVars = array_filter($environmentVars, function ($value, $key) {
            return $this->isValidEnvironmentVariable($key);
        }, ARRAY_FILTER_USE_BOTH);
        // transform to tree
        return $this->variablesToTree($environmentVars);
    }

    /**
     * Transform array of environment variables into a tree
     *
     * @param   array $environmentVars
     * @return  EnvironmentNode
     */
    protected function variablesToTree(array $environmentVars)
    {
        $root = new EnvironmentNode(EnvironmentNode::ROOT_KEY);
        foreach ($environmentVars as $name => $value) {
            // remove environment prefix from variable name
            $name = $this->removeEnvironmentPrefix(strtolower($name));
            // split variable name by delimiter
            $name = explode(self::DELIMITER, $name);

            $tree = $root;
            foreach ($name as $key) {
                if (!$tree->$key) {
                    $tree->addChild(new EnvironmentNode($key));
                }
                $tree = $tree->$key;
            }
            $tree->setValue($value);
        }
        return $root;
    }

    /**
     * Get prefix for current environment
     *
     * @return  string
     */
    protected function getEnvironmentPrefix(): string
    {
        return $this->environment . self::DELIMITER;
    }

    /**
     * Remove current environment prefix from given environment variable name
     *
     * @param   string $name
     * @return  string
     */
    public function removeEnvironmentPrefix(string $name): string
    {
        $prefix = $this->getEnvironmentPrefix();
        if (substr($name, 0, strlen($prefix)) == $prefix) {
            $name = substr($name, strlen($prefix));
        }
        return $name;
    }

    /**
     * Check if a given environment variable name begins with the current environment prefix
     *
     * @param   string $name
     * @return  bool
     */
    protected function hasEnvironmentPrefix(string $name): bool
    {
        $prefix = $this->getEnvironmentPrefix();
        return (0 === strpos($name, $prefix));
    }

    /**
     * Check if a given environment variable name is valid
     *
     * @param   string $name
     * @return  bool
     */
    protected function isValidEnvironmentVariable(string $name): bool
    {
        $name = strtolower($name);
        // variables are valid if their name has the right prefix and doesn't end with the delimiter
        return substr($name, -1) !== self::DELIMITER && $this->hasEnvironmentPrefix($name);
    }
}