Borobudur\Config\Definition\ArrayNode

Complexity

Total Complexity

27

Size/Duplication

Total Lines	184
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	5

Importance

Changes	2
Bugs	1	Features	1

11 Methods

Rating	Name	Duplication	Size	Complexity
A	setName()	0	4	1
A	append()	0	14	3
A	setDefaultValue()	0	4	1
A	getDefaultValue()	0	9	2
A	hasDefaultValue()	0	8	2
A	validateType()	0	6	2
A	normalizeValue()	0	14	3
A	mergeValues()	0	17	4
A	finalizeValue()	0	18	4
A	assertRequired()	0	10	2
A	assertEmptyUnrecognizedConfig()	0	11	3

<?php
/*
 * This file is part of the Borobudur-Config package.
 *
 * (c) Hexacodelabs <http://hexacodelabs.com>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Borobudur\Config\Definition;

use Borobudur\Config\Exception\InvalidArgumentException;
use Borobudur\Config\Exception\InvalidConfigurationException;
use Borobudur\Config\Exception\InvalidTypeException;

/**
 * @author      Iqbal Maulana <iq.bluejack@gmail.com>
 * @created     8/10/15
 */
class ArrayNode extends AbstractNode implements PrototypeNodeInterface
{
    /**
     * @var NodeInterface[]
     */
    protected $children = array();

    /**
     * @var bool|null
     */
    protected $defaultValueSet = null;

    /**
     * {@inheritdoc}
     */
    public function setName($name)
    {
        $this->name = $name;
    }

    /**
     * Append node.
     *
     * @param NodeInterface $child
     */
    public function append(NodeInterface $child)
    {
        $name = $child->getName();

        if (empty($name)) {
            throw new InvalidArgumentException('Child node name cannot be empty.');
        }

        if (isset($this->children[$name])) {
            throw new InvalidArgumentException(sprintf('Child node named "%s" already exists.', $name));
        }

        $this->children[$name] = $child;
    }

    /**
     * {@inheritdoc}
     */
    public function setDefaultValue($value)
    {
        // can't set default value for array node
    }

    /**
     * Get children node default values.
     *
     * @return array
     */
    public function getDefaultValue()
    {
        $defaults = array();
        foreach($this->children as $node) {
            $defaults[$node->getName()] = $node->getDefaultValue();
        }

        return $defaults;
    }

    /**
     * {@inheritdoc}
     */
    public function hasDefaultValue()
    {
        if (null === $this->defaultValueSet) {
            $this->defaultValueSet = 0 !== count($this->getDefaultValue());
        }

        return $this->defaultValueSet;
    }

    /**
     * {@inheritdoc}
     */
    protected function validateType($value)
    {
        if (!is_array($value)) {
            throw InvalidTypeException::invalidExpectedType($this->getPath(), 'array', $value);
        }
    }

    /**
     * {@inheritdoc}
     */
    protected function normalizeValue($value)
    {
        $normalized = array();
        foreach ($value as $name => $val) {
            if (isset($this->children[$name])) {
                $normalized[$name] = $this->children[$name]->normalize($val);
                unset($value[$name]);
            }
        }

        $this->assertEmptyUnrecognizedConfig($value);

        return $normalized;
    }

    /**
     * {@inheritdoc}
     */
    protected function mergeValues($left, $right)
    {
        foreach ($right as $key => $value) {
            if (!array_key_exists($key, $left)) {
                $left[$key] = $value;
                continue;
            }

            if (!isset($this->children[$key])) {
                throw new InvalidArgumentException(sprintf('Children "%s" is not defined.', $key));
            }

            $left[$key] = $this->children[$key]->merge($left[$key], $value);
        }

        return $left;
    }

    /**
     * {@inheritdoc}
     */
    protected function finalizeValue($value)
    {
        foreach ($this->children as $name => $child) {
            if (!array_key_exists($name, $value)) {
                $this->assertRequired($child->isRequired(), $name);

                if ($child->hasDefaultValue()) {
                    $value[$name] = $child->getDefaultValue();
                }

                continue;
            }

            $value[$name] = $child->finalize($value[$name]);
        }

        return $value;
    }

    /**
     * Assert if child is required.
     *
     * @param bool $required
     * @param string $name
     *
     * @throws InvalidConfigurationException
     */
    private function assertRequired($required, $name)
    {
        if (true === $required) {
            throw new InvalidConfigurationException(sprintf(
                'Child node "%s" at path "%s" should be configured.',
                $name,
                $this->getPath()
            ));
        }
    }

    /**
     * Assert that unrecognized config should be empty.
     *
     * @param array $value
     *
     * @throws InvalidConfigurationException
     */
    private function assertEmptyUnrecognizedConfig($value)
    {
        if (count($value)) {
            throw new InvalidConfigurationException(sprintf(
                'Unrecognized option%s "%s" under "%s"',
                1 === count($value) ? '' : 's',
                implode(', ', array_keys($value)),
                $this->getPath()
            ));
        }
    }
}