Borobudur\DependencyInjection\ParameterBag\Resolver

Complexity

Total Complexity

20

Size/Duplication

Total Lines	181
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Importance

Changes	5
Bugs	3	Features	1

9 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	normalizeValue()	0	12	3
B	resolve()	0	22	4
A	resolveValue()	0	18	4
A	resolveString()	0	14	3
A	isResolved()	0	4	1
A	escapeValue()	0	4	1
A	unescapeValue()	0	4	1
A	computeStringParameter()	0	17	2

<?php
/*
 * This file is part of the Borobudur-DependencyInjection 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\DependencyInjection\ParameterBag;

use Borobudur\DependencyInjection\Exception\InvalidArgumentException;
use Borobudur\DependencyInjection\Exception\ParameterNotFoundException;
use Borobudur\DependencyInjection\ParameterBag;

/**
 * @author      Iqbal Maulana <iq.bluejack@gmail.com>
 * @created     8/8/15
 */
class Resolver
{
    /**
     * @var bool
     */
    private $resolved;

    /**
     * @var ParameterBagInterface
     */
    private $parameter;

    /**
     * Constructor.
     *
     * @param ParameterBagInterface $parameter
     * @param bool                  $resolved
     */
    public function __construct(ParameterBagInterface $parameter, $resolved = false)
    {
        $this->parameter = $parameter;
        $this->resolved = (bool) $resolved;
    }

    /**
     * Normalize (escape / unescape) value.
     *
     * @param mixed $value
     * @param array $search
     * @param array $replace
     * @param array $callback
     *
     * @return array|mixed
     */
    private static function normalizeValue($value, $search, $replace, array $callback)
    {
        if (is_string($value)) {
            return str_replace($search, $replace, $value);
        }

        if (is_array($value)) {
            return array_map($callback, $value);
        }

        return $value;
    }

    /**
     * Resolve parameters.
     */
    public function resolve()
    {
        if (true === $this->resolved) {
            return;
        }

        $parameters = array();
        foreach ($this->parameter->all() as $name => $value) {
            try {
                $name = $this->resolveString($name);
                $value = $this->resolveValue($value);
                $parameters[$name] = $this->unescapeValue($value);
            } catch (ParameterNotFoundException $e) {
                $e->setSource($name);

                throw $e;
            }
        }

        $this->parameter->replace($parameters);
        $this->resolved = true;
    }

    /**
     * Resolve parameter placeholders by their values.
     *
     * @param mixed $value
     *
     * @return array|mixed
     */
    public function resolveValue($value)
    {
        if (is_array($value)) {
            $parameters = array();
            foreach ($value as $name => $val) {
                $name = $this->resolveString($name);
                $parameters[$name] = $this->resolveValue($val);
            }

            return $parameters;
        }

        if (!is_string($value)) {
            return $value;
        }

        return $this->resolveString($value);
    }

    /**
     * Resolve parameter inside string.
     *
     * @param string $value
     *
     * @return mixed
     */
    public function resolveString($value)
    {
        if (preg_match('/^%([^%\s]+)%$/', $value, $match)) {
            return $this->parameter->get(strtolower($match[1]));
        }

        return preg_replace_callback('/%%|%([^%\s]+)%/', function ($match) use ($value) {
            if (!isset($match[1])) {
                return '%%';
            }

            return $this->resolveString($this->computeStringParameter($match[1], $value));
        }, $value);
    }

    /**
     * Check if parameter has been resolved.
     *
     * @return bool
     */
    public function isResolved()
    {
        return $this->resolved;
    }

    /**
     * Escape parameter value.
     *
     * @param mixed $value
     *
     * @return array|mixed
     */
    public function escapeValue($value)
    {
        return self::normalizeValue($value, array('%', '@'), array('%%', '@@'), array($this, 'escapeValue'));
    }

    /**
     * Un-escape parameter value.
     *
     * @param mixed $value
     *
     * @return array|mixed
     */
    public function unescapeValue($value)
    {
        return self::normalizeValue($value, array('%%', '@@'), array('%', '@'), array($this, 'unescapeValue'));
    }

    /**
     * Compute string parameter.
     *
     * @param mixed $name
     * @param mixed $value
     *
     * @return string
     */
    private function computeStringParameter($name, $value)
    {
        $name = strtolower($name);
        $resolved = $this->parameter->get($name);

        // Only scalar type can be used in string value.
        if (!is_scalar($resolved)) {
            throw new InvalidArgumentException(sprintf(
                'Parameter "%s" cannot use type %s inside string value "%s".',
                $name,
                gettype($resolved),
                $value
            ));
        }

        return (string) $resolved;
    }
}