arc\config\Configuration

Complexity

Total Complexity

23

Size/Duplication

Total Lines	120
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	2

Test Coverage

Coverage

84.38%

Importance

Changes

0

12 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	cd()	0	4	1
A	getVar()	0	4	1
A	putVar()	0	4	1
A	getValueIfRoot()	0	7	2
A	isHash()	0	4	2
A	mergeValue()	0	14	4
A	acquire()	0	12	1
A	configure()	0	9	2
A	ls()	0	6	1
A	getValue()	0	13	3
A	setValue()	0	17	4

<?php

/*
 * This file is part of the Ariadne Component Library.
 *
 * (c) Muze <info@muze.nl>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace arc\config;

class Configuration implements ConfigurationInterface
{
    use \arc\traits\Proxy {
        \arc\traits\Proxy::__construct as private ProxyConstruct;
    }

    private $tree = null;

    public function __construct($tree)
    {
        $this->ProxyConstruct( $tree );
        $this->tree = $tree;
    }

    public function acquire($name)
    {
        return \arc\tree::dive(
            $this->tree,
            function ($node) use ($name) {
                return $this->getValueIfRoot( $name, $node->nodeValue );
            },
            function ($node, $result) use ($name) {
                return $this->mergeValue( $result, $this->getValue( $name, $node->nodeValue ) );
            }
        );
    }

    public function configure($name, $value)
    {
        if (!isset( $this->tree->nodeValue )) {
            $this->tree->nodeValue = array();
        }
        $this->setValue( $name, $value, $this->tree->nodeValue );

        return $this;
    }

    public function cd($path)
    {
        return new Configuration( $this->tree->cd( $path ) );
    }

    public function ls()
    {
        return $this->tree->ls( function ($node) {
            return new Configuration( $node );
        } );
    }

    // \arc\KeyValueStoreInterface
    public function getVar($name)
    {
        return $this->acquire( $name );
    }

    public function putVar($name, $value)
    {
        return $this->configure( $name, $value );
    }

    private function getValue($name, $config)
    {
        $vars = explode('.', $name);
        $entry = $config;
        foreach ($vars as $var) {
            if (!isset( $entry[$var] )) {
                return null;
            }
            $entry = $entry[$var];
        }

        return $entry;
    }

    private function setValue($name, $value, &$config)
    {
        $vars = explode('.', $name);
        $lastName = array_pop( $vars );
        $entry = &$config;
        foreach ($vars as $var) {
            if (!isset( $entry[$var] )) {
                $entry[$var] = array();
            }
            $entry = &$entry[$var];
        }
        if ( !is_array( $entry ) ) {
            throw \arc\ConfigError( 'Unable to configure '.$name.', parent set to non-array value', \arc\exceptions::CONFIGURATION_ERROR );
        } else {
            $entry[ $lastName ] = $value;
        }
    }

    private function getValueIfRoot($name, $config)
    {
        $value = $this->getValue( $name, $config );
        if (!$this->isHash( $value )) {
            return $value;
        }
    }

    private function isHash($array)
    {
        return ( is_array( $array ) && !is_numeric( key( $array ) ) );
    }

    private function mergeValue($initial, $additional)
    {
        if (isset( $additional )) {
            if (!$this->isHash( $initial )) {
                return $additional;
            } elseif ( $this->isHash( $additional ) ) {
                return array_replace_recursive( $initial, $additional );
            } else {
                return $additional;
            }
        }

        return $initial;
    }
}